Use non-cryptographic hashing algorithm for internal maps (#582)

jpschorr · web-flow · commit 2ae6c4e31fb1 · 2025-06-30T16:18:31.000-07:00
* Use non-cryptographic hashing algorithm for internal maps
* Clippy &amp; cargo fix for rust 1.88
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 ### Changed
+- Changed many internal `HashMap`s to use `rustc-hash`'s `FxHash`
 
 ### Added
 
diff --git a/extension/partiql-extension-ddl/src/ddl.rs b/extension/partiql-extension-ddl/src/ddl.rs
@@ -208,8 +208,7 @@ impl PartiqlDdlEncoder for PartiqlBasicDdlEncoder {
             Ok(output)
         } else {
             Err(ShapeEncodingError::UnsupportedEncoding(format!(
-                "Unsupported top level type {:?}",
-                ty
+                "Unsupported top level type {ty:?}"
             )))
         }
     }
diff --git a/extension/partiql-extension-ion/src/boxed_ion.rs b/extension/partiql-extension-ion/src/boxed_ion.rs
@@ -875,7 +875,7 @@ mod tests {
                 flatten_dump(c.expect("boxed ion element"))
             }
         } else {
-            println!("{:?}", doc);
+            println!("{doc:?}");
         }
     }
 
diff --git a/extension/partiql-extension-visualize/src/ast_to_dot.rs b/extension/partiql-extension-visualize/src/ast_to_dot.rs
@@ -186,10 +186,10 @@ fn lit_to_str(ast: &ast::Lit) -> String {
         Lit::DoubleLit(l) => l.to_string(),
         Lit::BoolLit(l) => (if *l { "TRUE" } else { "FALSE" }).to_string(),
         Lit::EmbeddedDocLit(l, typ) => format!("`{}`::{}", l, type_to_str(typ)),
-        Lit::CharStringLit(l) => format!("'{}'", l),
-        Lit::NationalCharStringLit(l) => format!("'{}'", l),
-        Lit::BitStringLit(l) => format!("b'{}'", l),
-        Lit::HexStringLit(l) => format!("x'{}'", l),
+        Lit::CharStringLit(l) => format!("'{l}'"),
+        Lit::NationalCharStringLit(l) => format!("'{l}'"),
+        Lit::BitStringLit(l) => format!("b'{l}'"),
+        Lit::HexStringLit(l) => format!("x'{l}'"),
         Lit::BagLit(_b) => todo!("bag literals"),
         Lit::ListLit(_b) => todo!("list literals"),
         Lit::StructLit(_b) => todo!("struct literals"),
@@ -220,7 +220,7 @@ fn custom_type_part_to_str(part: &ast::CustomTypePart) -> String {
                 .map(custom_type_param_to_str)
                 .collect::<Vec<_>>()
                 .join(",");
-            format!("{}({})", name, args)
+            format!("{name}({args})")
         }
     }
 }
@@ -235,7 +235,7 @@ fn type_to_str(ty: &ast::Type) -> String {
             .map(custom_type_part_to_str)
             .collect::<Vec<_>>()
             .join(" "),
-        _ => format!("{:?}", ty),
+        _ => format!("{ty:?}"),
     }
 }
 
@@ -467,7 +467,7 @@ impl ToDot<ast::VarRef> for AstToDot {
         let lbl = symbol_primitive_to_label(&ast.name);
         let lbl = match &ast.qualifier {
             ast::ScopeQualifier::Unqualified => lbl,
-            ast::ScopeQualifier::Qualified => format!("@{}", lbl),
+            ast::ScopeQualifier::Qualified => format!("@{lbl}"),
         };
         let id = out.node_auto_labelled(&lbl).id();
 
diff --git a/extension/partiql-extension-visualize/src/plan_to_dot.rs b/extension/partiql-extension-visualize/src/plan_to_dot.rs
@@ -60,7 +60,7 @@ impl PlanToDot {
                         )
                     })
                     .join(" | ");
-                format!("{{order by | {} }}", specs)
+                format!("{{order by | {specs} }}")
             }
             BindingsOp::LimitOffset(lo) => {
                 let clauses = [
@@ -148,7 +148,7 @@ fn expr_to_str(expr: &ValueExpr) -> String {
             )
         }
         expr => {
-            let expr: String = format!("{:?}", expr).escape_default().collect();
+            let expr: String = format!("{expr:?}").escape_default().collect();
             let expr = expr.replace('{', "\\{");
             let expr = expr.replace('}', "\\}");
             let expr = expr.replace('<', "\\<");
diff --git a/partiql-catalog/Cargo.toml b/partiql-catalog/Cargo.toml
@@ -30,5 +30,6 @@ thiserror = "1.0"
 ordered-float = "5"
 itertools = "0.14"
 unicase = "2.7"
+rustc-hash = "2"
 
 dyn-clone = "1"
diff --git a/partiql-catalog/src/catalog.rs b/partiql-catalog/src/catalog.rs
@@ -3,12 +3,11 @@ use crate::scalar_fn::ScalarFunction;
 use crate::table_fn::TableFunction;
 use partiql_common::catalog::{CatalogId, EntryId, ObjectId};
 use partiql_types::PartiqlShape;
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 use std::fmt::Debug;
 use std::sync::atomic::{AtomicU64, Ordering};
 use thiserror::Error;
 use unicase::UniCase;
-
 /// Contains the errors that occur during Catalog related operations
 #[derive(Error, Debug, Clone, PartialEq)]
 #[error("Catalog error: encountered errors")]
@@ -218,9 +217,9 @@ impl PartiqlCatalog {
 
 #[derive(Debug)]
 struct CatalogEntrySet<T> {
-    entries: HashMap<EntryId, T>,
-    by_name: HashMap<UniCase<String>, EntryId>,
-    by_alias: HashMap<UniCase<String>, EntryId>,
+    entries: FxHashMap<EntryId, T>,
+    by_name: FxHashMap<UniCase<String>, EntryId>,
+    by_alias: FxHashMap<UniCase<String>, EntryId>,
 
     next_id: AtomicU64,
 }
diff --git a/partiql-common/src/metadata.rs b/partiql-common/src/metadata.rs
@@ -345,24 +345,24 @@ where
                     if idx > 0 {
                         write!(f, ", ")?;
                     }
-                    write!(f, "{}", item)?;
+                    write!(f, "{item}")?;
                 }
                 write!(f, "]")
             }
-            PartiqlMetaValue::Bool(v) => write!(f, "{}", v),
-            PartiqlMetaValue::Decimal(v) => write!(f, "{}", v),
-            PartiqlMetaValue::Float64(v) => write!(f, "{}", v),
-            PartiqlMetaValue::Float32(v) => write!(f, "{}", v),
-            PartiqlMetaValue::Int32(v) => write!(f, "{}", v),
-            PartiqlMetaValue::Int64(v) => write!(f, "{}", v),
+            PartiqlMetaValue::Bool(v) => write!(f, "{v}"),
+            PartiqlMetaValue::Decimal(v) => write!(f, "{v}"),
+            PartiqlMetaValue::Float64(v) => write!(f, "{v}"),
+            PartiqlMetaValue::Float32(v) => write!(f, "{v}"),
+            PartiqlMetaValue::Int32(v) => write!(f, "{v}"),
+            PartiqlMetaValue::Int64(v) => write!(f, "{v}"),
             PartiqlMetaValue::Map(map) => {
                 write!(f, "{{")?;
                 for (t, v) in map.iter() {
-                    write!(f, "{}: {} , ", t, v)?;
+                    write!(f, "{t}: {v} , ")?;
                 }
                 write!(f, "}}")
             }
-            PartiqlMetaValue::String(v) => write!(f, "{}", v),
+            PartiqlMetaValue::String(v) => write!(f, "{v}"),
         }
     }
 }
diff --git a/partiql-conformance-test-generator/src/util.rs b/partiql-conformance-test-generator/src/util.rs
@@ -29,7 +29,7 @@ fn escape_str(s: &str) -> String {
         None => "_".to_string(),
         Some(c) => {
             if c.is_numeric() {
-                format!("_{}", snake_case)
+                format!("_{snake_case}")
             } else {
                 snake_case
             }
diff --git a/partiql-eval/Cargo.toml b/partiql-eval/Cargo.toml
@@ -30,7 +30,6 @@ partiql-extension-ion = { path = "../extension/partiql-extension-ion", version =
 ion-rs_old = { version = "0.18", package = "ion-rs" }
 lasso = "0.7"
 petgraph = "0.7"
-fxhash = "0.2"
 indexmap = "2"
 ordered-float = "5"
 itertools = "0.14"
diff --git a/partiql-eval/src/env.rs b/partiql-eval/src/env.rs
@@ -8,20 +8,20 @@ pub mod basic {
     use partiql_value::datum::{RefFieldView, RefTupleView};
     use std::borrow::Cow;
 
-    use std::collections::HashMap;
+    use rustc_hash::FxHashMap;
 
     #[derive(Debug, Clone)]
     pub struct MapBindings<T> {
-        sensitive: HashMap<String, usize>,
-        insensitive: HashMap<UniCase<String>, usize>,
+        sensitive: FxHashMap<String, usize>,
+        insensitive: FxHashMap<UniCase<String>, usize>,
         values: Vec<T>,
     }
 
     impl<T> Default for MapBindings<T> {
         fn default() -> Self {
             MapBindings {
-                sensitive: HashMap::new(),
-                insensitive: HashMap::new(),
+                sensitive: FxHashMap::default(),
+                insensitive: FxHashMap::default(),
                 values: vec![],
             }
         }
diff --git a/partiql-eval/src/eval/eval_expr_wrapper.rs b/partiql-eval/src/eval/eval_expr_wrapper.rs
@@ -382,10 +382,7 @@ where
                     let arg_end = args.len();
                     let arg_count = 0..arg_end;
 
-                    let signature = (arg_count)
-                        .map(types)
-                        .map(|typ| format!("{}", typ))
-                        .join(",");
+                    let signature = (arg_count).map(types).map(|typ| format!("{typ}")).join(",");
                     let before = (0..idx).map(|_| "_");
                     let arg = "MISSING"; // TODO display actual argument?
                     let after = (idx + 1..arg_end).map(|_| "_");
diff --git a/partiql-eval/src/eval/graph/engine.rs b/partiql-eval/src/eval/graph/engine.rs
@@ -6,9 +6,9 @@ use crate::eval::graph::result::{PathPatternNodes, Triple};
 use crate::eval::graph::string_graph::StringGraphTypes;
 use crate::eval::graph::types::GraphTypes;
 use crate::eval::EvalContext;
-use fxhash::FxBuildHasher;
 use indexmap::IndexSet;
 use partiql_value::Value;
+use rustc_hash::FxBuildHasher;
 
 /// A graph 'engine'; Exposes scanning, node access, and plan conversion to a target graph.
 pub trait GraphEngine<GT: GraphTypes>:
diff --git a/partiql-eval/src/eval/graph/evaluator.rs b/partiql-eval/src/eval/graph/evaluator.rs
@@ -3,9 +3,7 @@ use crate::eval::graph::result::{
     GraphElement, NodeBinding, PathBinding, PathPatternBinding, PathPatternNodes, Triple,
 };
 use partiql_logical::graph::bind_name::BindNameExt;
-use std::collections::HashMap;
 
-use fxhash::FxBuildHasher;
 use indexmap::IndexMap;
 use itertools::Itertools;
 
@@ -14,6 +12,7 @@ use crate::eval::graph::string_graph::StringGraphTypes;
 use crate::eval::graph::types::GraphTypes;
 use crate::eval::EvalContext;
 use partiql_value::{Bag, Tuple, Value};
+use rustc_hash::{FxBuildHasher, FxHashMap};
 use std::marker::PhantomData;
 
 /// An evaluator for [`PathPatternMatch`]s over a graph.
@@ -219,7 +218,7 @@ fn join_bindings<GT: GraphTypes>(
                             _ => None,
                         })
                         .collect_vec();
-                    let mut seen: HashMap<&GT::NodeId, usize> = HashMap::default();
+                    let mut seen: FxHashMap<&GT::NodeId, usize> = FxHashMap::default();
                     for i in 0..path_elts.len() {
                         let last_seen = seen.get(&path_elts[i]);
                         if let Some(last_seen) = last_seen {
diff --git a/partiql-eval/src/eval/graph/result.rs b/partiql-eval/src/eval/graph/result.rs
@@ -1,7 +1,7 @@
 use crate::eval::graph::plan::{BindSpec, NodeMatch, TripleStepMatch};
 use crate::eval::graph::types::GraphTypes;
-use fxhash::FxBuildHasher;
 use indexmap::IndexSet;
+use rustc_hash::FxBuildHasher;
 
 type FxIndexSet<T> = IndexSet<T, FxBuildHasher>;
 
diff --git a/partiql-eval/src/eval/graph/simple_graph/engine.rs b/partiql-eval/src/eval/graph/simple_graph/engine.rs
@@ -10,11 +10,11 @@ use crate::eval::graph::string_graph::StringGraphTypes;
 use crate::eval::graph::types::GraphTypes;
 use crate::eval::EvalContext;
 use delegate::delegate;
-use fxhash::FxBuildHasher;
 use indexmap::IndexSet;
 use lasso::Rodeo;
 use partiql_value::datum::DatumTupleRef;
 use partiql_value::{GEdgeId, GLabelId, GNodeId, SimpleGraph, Value};
+use rustc_hash::FxBuildHasher;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
diff --git a/partiql-eval/src/eval/mod.rs b/partiql-eval/src/eval/mod.rs
@@ -2,7 +2,6 @@ use itertools::Itertools;
 use std::any::Any;
 use std::borrow::Cow;
 use std::cell::RefCell;
-use std::collections::HashMap;
 
 use delegate::delegate;
 use petgraph::algo::toposort;
@@ -20,6 +19,7 @@ use petgraph::graph::NodeIndex;
 use crate::error::{EvalErr, EvaluationError};
 use partiql_catalog::context::{Bindings, SessionContext, SystemContext};
 use petgraph::visit::EdgeRef;
+use rustc_hash::FxHashMap;
 use unicase::UniCase;
 
 use crate::eval::evaluable::{EvalType, Evaluable};
@@ -91,7 +91,7 @@ impl EvalPlan {
                 "Malformed evaluation plan detected: {e:?}"
             ))],
         })?;
-        let mut inputs: HashMap<NodeIndex, [Option<Value>; 2]> = HashMap::new();
+        let mut inputs: FxHashMap<NodeIndex, [Option<Value>; 2]> = FxHashMap::default();
 
         // Set source node inputs to empty
         for idx in ops.clone() {
@@ -185,7 +185,7 @@ pub struct BasicContext<'u> {
     pub bindings: MapBindings<Value>,
 
     pub sys: SystemContext,
-    pub user: HashMap<UniCase<String>, &'u (dyn Any)>,
+    pub user: FxHashMap<UniCase<String>, &'u (dyn Any)>,
 
     pub errors: RefCell<Vec<EvaluationError>>,
 }
diff --git a/partiql-eval/src/plan.rs b/partiql-eval/src/plan.rs
@@ -29,7 +29,7 @@ use partiql_logical::{
 use partiql_value::boxed_variant::DynBoxedVariantTypeFactory;
 use partiql_value::{Bag, List, Tuple, Value, Variant};
 use petgraph::prelude::StableGraph;
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 use std::rc::Rc;
 
 #[macro_export]
@@ -77,7 +77,7 @@ impl From<(&str, BindError)> for PlanningError {
             BindError::NotYetImplemented(name) => PlanningError::NotYetImplemented(name),
             BindError::ArgumentConstraint(msg) => PlanningError::IllegalState(msg),
             BindError::LiteralValue(err) => {
-                PlanningError::IllegalState(format!("Literal error: {}", err))
+                PlanningError::IllegalState(format!("Literal error: {err}"))
             }
         }
     }
@@ -153,7 +153,7 @@ impl<'c> EvaluatorPlanner<'c> {
         let flows = lg.flows();
 
         let mut plan_graph: StableGraph<_, _> = Default::default();
-        let mut seen = HashMap::new();
+        let mut seen = FxHashMap::default();
 
         for (s, d, branch_num) in flows {
             let mut add_node = |op_id: &OpId| {
diff --git a/partiql-logical-planner/Cargo.toml b/partiql-logical-planner/Cargo.toml
@@ -40,6 +40,7 @@ fnv = "1"
 assert_matches = "1"
 once_cell = "1"
 thiserror = "1"
+rustc-hash = "2"
 
 [dev-dependencies]
 #partiql-eval = { path = "../partiql-eval", version = "0.12.*" }
diff --git a/partiql-logical-planner/src/builtins.rs b/partiql-logical-planner/src/builtins.rs
@@ -1,11 +1,10 @@
 use itertools::Itertools;
 use once_cell::sync::Lazy;
+use partiql_catalog::call_defs::{CallDef, CallSpec, CallSpecArg};
 use partiql_logical as logical;
 use partiql_logical::{SetQuantifier, ValueExpr};
-use std::collections::HashMap;
+use rustc_hash::FxHashMap;
 use std::fmt::Debug;
-
-use partiql_catalog::call_defs::{CallDef, CallSpec, CallSpecArg};
 use unicase::UniCase;
 
 fn function_call_def_char_len() -> CallDef {
@@ -727,8 +726,8 @@ pub(crate) static FN_SYM_TAB: Lazy<FnSymTab> = Lazy::new(function_call_def);
 /// Function symbol table
 #[derive(Debug)]
 pub struct FnSymTab {
-    calls: HashMap<UniCase<String>, CallDef>,
-    synonyms: HashMap<UniCase<String>, UniCase<String>>,
+    calls: FxHashMap<UniCase<String>, CallDef>,
+    synonyms: FxHashMap<UniCase<String>, UniCase<String>>,
 }
 
 impl FnSymTab {
@@ -740,8 +739,8 @@ impl FnSymTab {
 }
 
 pub fn function_call_def() -> FnSymTab {
-    let mut calls: HashMap<UniCase<String>, CallDef> = HashMap::new();
-    let mut synonyms: HashMap<UniCase<String>, UniCase<String>> = HashMap::new();
+    let mut calls: FxHashMap<UniCase<String>, CallDef> = FxHashMap::default();
+    let mut synonyms: FxHashMap<UniCase<String>, UniCase<String>> = FxHashMap::default();
 
     for def in [
         function_call_def_char_len(),
diff --git a/partiql-logical-planner/src/lower.rs b/partiql-logical-planner/src/lower.rs
diff --git a/partiql-logical-planner/src/typer.rs b/partiql-logical-planner/src/typer.rs
diff --git a/partiql-logical/Cargo.toml b/partiql-logical/Cargo.toml
diff --git a/partiql-logical/src/lib.rs b/partiql-logical/src/lib.rs
diff --git a/partiql-value/src/boxed_variant.rs b/partiql-value/src/boxed_variant.rs
diff --git a/partiql-value/src/value.rs b/partiql-value/src/value.rs

Original file line number	Diff line number	Diff line change
`@@ -208,8 +208,7 @@ impl PartiqlDdlEncoder for PartiqlBasicDdlEncoder {`
`208`	`208`	`Ok(output)`
`209`	`209`	`} else {`
`210`	`210`	`Err(ShapeEncodingError::UnsupportedEncoding(format!(`
`211`		`- "Unsupported top level type {:?}",`
`212`		`- ty`
	`211`	`+ "Unsupported top level type {ty:?}"`
`213`	`212`	`)))`
`214`	`213`	`}`
`215`	`214`	`}`
Original file line number	Diff line number	Diff line change
`@@ -875,7 +875,7 @@ mod tests {`
`875`	`875`	`flatten_dump(c.expect("boxed ion element"))`
`876`	`876`	`}`
`877`	`877`	`} else {`
`878`		`- println!("{:?}", doc);`
	`878`	`+ println!("{doc:?}");`
`879`	`879`	`}`
`880`	`880`	`}`
`881`	`881`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ impl PlanToDot {`
`60`	`60`	`)`
`61`	`61`	`})`
`62`	`62`	`.join(" \| ");`
`63`		`- format!("{{order by \| {} }}", specs)`
	`63`	`+ format!("{{order by \| {specs} }}")`
`64`	`64`	`}`
`65`	`65`	`BindingsOp::LimitOffset(lo) => {`
`66`	`66`	`let clauses = [`
`@@ -148,7 +148,7 @@ fn expr_to_str(expr: &ValueExpr) -> String {`
`148`	`148`	`)`
`149`	`149`	`}`
`150`	`150`	`expr => {`
`151`		`- let expr: String = format!("{:?}", expr).escape_default().collect();`
	`151`	`+ let expr: String = format!("{expr:?}").escape_default().collect();`
`152`	`152`	`let expr = expr.replace('{', "\\{");`
`153`	`153`	`let expr = expr.replace('}', "\\}");`
`154`	`154`	`let expr = expr.replace('<', "\\<");`
Original file line number	Diff line number	Diff line change
`@@ -345,24 +345,24 @@ where`
`345`	`345`	`if idx > 0 {`
`346`	`346`	`write!(f, ", ")?;`
`347`	`347`	`}`
`348`		`- write!(f, "{}", item)?;`
	`348`	`+ write!(f, "{item}")?;`
`349`	`349`	`}`
`350`	`350`	`write!(f, "]")`
`351`	`351`	`}`
`352`		`- PartiqlMetaValue::Bool(v) => write!(f, "{}", v),`
`353`		`- PartiqlMetaValue::Decimal(v) => write!(f, "{}", v),`
`354`		`- PartiqlMetaValue::Float64(v) => write!(f, "{}", v),`
`355`		`- PartiqlMetaValue::Float32(v) => write!(f, "{}", v),`
`356`		`- PartiqlMetaValue::Int32(v) => write!(f, "{}", v),`
`357`		`- PartiqlMetaValue::Int64(v) => write!(f, "{}", v),`
	`352`	`+ PartiqlMetaValue::Bool(v) => write!(f, "{v}"),`
	`353`	`+ PartiqlMetaValue::Decimal(v) => write!(f, "{v}"),`
	`354`	`+ PartiqlMetaValue::Float64(v) => write!(f, "{v}"),`
	`355`	`+ PartiqlMetaValue::Float32(v) => write!(f, "{v}"),`
	`356`	`+ PartiqlMetaValue::Int32(v) => write!(f, "{v}"),`
	`357`	`+ PartiqlMetaValue::Int64(v) => write!(f, "{v}"),`
`358`	`358`	`PartiqlMetaValue::Map(map) => {`
`359`	`359`	`write!(f, "{{")?;`
`360`	`360`	`for (t, v) in map.iter() {`
`361`		`- write!(f, "{}: {} , ", t, v)?;`
	`361`	`+ write!(f, "{t}: {v} , ")?;`
`362`	`362`	`}`
`363`	`363`	`write!(f, "}}")`
`364`	`364`	`}`
`365`		`- PartiqlMetaValue::String(v) => write!(f, "{}", v),`
	`365`	`+ PartiqlMetaValue::String(v) => write!(f, "{v}"),`
`366`	`366`	`}`
`367`	`367`	`}`
`368`	`368`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ fn escape_str(s: &str) -> String {`
`29`	`29`	`None => "_".to_string(),`
`30`	`30`	`Some(c) => {`
`31`	`31`	`if c.is_numeric() {`
`32`		`- format!("_{}", snake_case)`
	`32`	`+ format!("_{snake_case}")`
`33`	`33`	`} else {`
`34`	`34`	`snake_case`
`35`	`35`	`}`