datafusion-common: restore hash_utils leaf fast path

xudong963 · xudong963 · commit 501b2237a842 · 2026-04-09T16:07:29.000+08:00
diff --git a/datafusion/common/src/hash_utils.rs b/datafusion/common/src/hash_utils.rs
@@ -209,29 +209,49 @@ fn hash_null(random_state: &RandomState, hashes_buffer: &'_ mut [u64], mul_col:
 }
 
 pub trait HashValue {
-    fn hash_one<S: BuildHasher>(&self, state: &S) -> u64;
+    fn hash_one(&self, state: &RandomState) -> u64;
     /// Write this value into an existing hasher (same data as `hash_one`).
     fn hash_write(&self, hasher: &mut impl Hasher);
 }
 
 impl<T: HashValue + ?Sized> HashValue for &T {
-    fn hash_one<S: BuildHasher>(&self, state: &S) -> u64 {
+    fn hash_one(&self, state: &RandomState) -> u64 {
         T::hash_one(self, state)
     }
     fn hash_write(&self, hasher: &mut impl Hasher) {
         T::hash_write(self, hasher)
     }
 }
 
+#[cfg(not(feature = "force_hash_collisions"))]
+// Keep custom BuildHasher leaf hashing off the default RandomState fast path.
+trait BuildHasherHashValue {
+    fn hash_one_with_hasher<S: BuildHasher>(&self, state: &S) -> u64;
+}
+
+#[cfg(not(feature = "force_hash_collisions"))]
+impl<T: BuildHasherHashValue + ?Sized> BuildHasherHashValue for &T {
+    fn hash_one_with_hasher<S: BuildHasher>(&self, state: &S) -> u64 {
+        T::hash_one_with_hasher(self, state)
+    }
+}
+
 macro_rules! hash_value {
     ($($t:ty),+) => {
         $(impl HashValue for $t {
-            fn hash_one<S: BuildHasher>(&self, state: &S) -> u64 {
+            fn hash_one(&self, state: &RandomState) -> u64 {
                 state.hash_one(self)
             }
             fn hash_write(&self, hasher: &mut impl Hasher) {
                 Hash::hash(self, hasher)
             }
+        }
+
+        #[cfg(not(feature = "force_hash_collisions"))]
+        impl BuildHasherHashValue for $t {
+            fn hash_one_with_hasher<S: BuildHasher>(&self, state: &S) -> u64 {
+                state.hash_one(self)
+            }
         })+
     };
 }
@@ -241,12 +261,19 @@ hash_value!(bool, str, [u8], IntervalDayTime, IntervalMonthDayNano);
 macro_rules! hash_float_value {
     ($(($t:ty, $i:ty)),+) => {
         $(impl HashValue for $t {
-            fn hash_one<S: BuildHasher>(&self, state: &S) -> u64 {
+            fn hash_one(&self, state: &RandomState) -> u64 {
                 state.hash_one(<$i>::from_ne_bytes(self.to_ne_bytes()))
             }
             fn hash_write(&self, hasher: &mut impl Hasher) {
                 hasher.write(&self.to_ne_bytes())
             }
+        }
+
+        #[cfg(not(feature = "force_hash_collisions"))]
+        impl BuildHasherHashValue for $t {
+            fn hash_one_with_hasher<S: BuildHasher>(&self, state: &S) -> u64 {
+                state.hash_one(<$i>::from_ne_bytes(self.to_ne_bytes()))
+            }
         })+
     };
 }
@@ -551,7 +578,7 @@ fn hash_array_primitive_with_hasher<T, S>(
     hashes_buffer: &mut [u64],
     rehash: bool,
 ) where
-    T: ArrowPrimitiveType<Native: HashValue>,
+    T: ArrowPrimitiveType<Native: BuildHasherHashValue>,
     S: BuildHasher,
 {
     assert_eq!(
@@ -563,23 +590,25 @@ fn hash_array_primitive_with_hasher<T, S>(
     if array.null_count() == 0 {
         if rehash {
             for (hash, &value) in hashes_buffer.iter_mut().zip(array.values().iter()) {
-                *hash = combine_hashes(value.hash_one(hash_builder), *hash);
+                *hash = combine_hashes(value.hash_one_with_hasher(hash_builder), *hash);
             }
         } else {
             for (hash, &value) in hashes_buffer.iter_mut().zip(array.values().iter()) {
-                *hash = value.hash_one(hash_builder);
+                *hash = value.hash_one_with_hasher(hash_builder);
             }
         }
     } else if rehash {
         for i in array.nulls().unwrap().valid_indices() {
             let value = unsafe { array.value_unchecked(i) };
-            hashes_buffer[i] =
-                combine_hashes(value.hash_one(hash_builder), hashes_buffer[i]);
+            hashes_buffer[i] = combine_hashes(
+                value.hash_one_with_hasher(hash_builder),
+                hashes_buffer[i],
+            );
         }
     } else {
         for i in array.nulls().unwrap().valid_indices() {
             let value = unsafe { array.value_unchecked(i) };
-            hashes_buffer[i] = value.hash_one(hash_builder);
+            hashes_buffer[i] = value.hash_one_with_hasher(hash_builder);
         }
     }
 }
@@ -592,7 +621,7 @@ fn hash_array_with_hasher<T, S>(
     rehash: bool,
 ) where
     T: ArrayAccessor,
-    T::Item: HashValue,
+    T::Item: BuildHasherHashValue,
     S: BuildHasher,
 {
     assert_eq!(
@@ -605,24 +634,26 @@ fn hash_array_with_hasher<T, S>(
         if rehash {
             for (i, hash) in hashes_buffer.iter_mut().enumerate() {
                 let value = unsafe { array.value_unchecked(i) };
-                *hash = combine_hashes(value.hash_one(hash_builder), *hash);
+                *hash = combine_hashes(value.hash_one_with_hasher(hash_builder), *hash);
             }
         } else {
             for (i, hash) in hashes_buffer.iter_mut().enumerate() {
                 let value = unsafe { array.value_unchecked(i) };
-                *hash = value.hash_one(hash_builder);
+                *hash = value.hash_one_with_hasher(hash_builder);
             }
         }
     } else if rehash {
         for i in array.nulls().unwrap().valid_indices() {
             let value = unsafe { array.value_unchecked(i) };
-            hashes_buffer[i] =
-                combine_hashes(value.hash_one(hash_builder), hashes_buffer[i]);
+            hashes_buffer[i] = combine_hashes(
+                value.hash_one_with_hasher(hash_builder),
+                hashes_buffer[i],
+            );
         }
     } else {
         for i in array.nulls().unwrap().valid_indices() {
             let value = unsafe { array.value_unchecked(i) };
-            hashes_buffer[i] = value.hash_one(hash_builder);
+            hashes_buffer[i] = value.hash_one_with_hasher(hash_builder);
         }
     }
 }
@@ -664,17 +695,17 @@ fn hash_string_view_array_inner_with_hasher<
         let view_len = v as u32;
         if !HAS_BUFFERS || view_len <= 12 {
             if REHASH {
-                *hash = combine_hashes(v.hash_one(hash_builder), *hash);
+                *hash = combine_hashes(v.hash_one_with_hasher(hash_builder), *hash);
             } else {
-                *hash = v.hash_one(hash_builder);
+                *hash = v.hash_one_with_hasher(hash_builder);
             }
             continue;
         }
         let value = view_bytes(view_len, v);
         if REHASH {
-            *hash = combine_hashes(value.hash_one(hash_builder), *hash);
+            *hash = combine_hashes(value.hash_one_with_hasher(hash_builder), *hash);
         } else {
-            *hash = value.hash_one(hash_builder);
+            *hash = value.hash_one_with_hasher(hash_builder);
         }
     }
 }
@@ -693,12 +724,12 @@ fn hash_generic_byte_view_array_with_hasher<T: ByteViewType, S: BuildHasher>(
     ) {
         (false, false, false) => {
             for (hash, &view) in hashes_buffer.iter_mut().zip(array.views().iter()) {
-                *hash = view.hash_one(hash_builder);
+                *hash = view.hash_one_with_hasher(hash_builder);
             }
         }
         (false, false, true) => {
             for (hash, &view) in hashes_buffer.iter_mut().zip(array.views().iter()) {
-                *hash = combine_hashes(view.hash_one(hash_builder), *hash);
+                *hash = combine_hashes(view.hash_one_with_hasher(hash_builder), *hash);
             }
         }
         (false, true, false) => {

Original file line number	Diff line number	Diff line change
`@@ -209,29 +209,49 @@ fn hash_null(random_state: &RandomState, hashes_buffer: &'_ mut [u64], mul_col:`
`209`	`209`	`}`
`210`	`210`
`211`	`211`	`pub trait HashValue {`
`212`		`- fn hash_one<S: BuildHasher>(&self, state: &S) -> u64;`
	`212`	`+ fn hash_one(&self, state: &RandomState) -> u64;`
`213`	`213`	/// Write this value into an existing hasher (same data as `hash_one`).
`214`	`214`	`fn hash_write(&self, hasher: &mut impl Hasher);`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`impl<T: HashValue + ?Sized> HashValue for &T {`
`218`		`- fn hash_one<S: BuildHasher>(&self, state: &S) -> u64 {`
	`218`	`+ fn hash_one(&self, state: &RandomState) -> u64 {`
`219`	`219`	`T::hash_one(self, state)`
`220`	`220`	`}`
`221`	`221`	`fn hash_write(&self, hasher: &mut impl Hasher) {`
`222`	`222`	`T::hash_write(self, hasher)`
`223`	`223`	`}`
`224`	`224`	`}`
`225`	`225`
	`226`	`+#[cfg(not(feature = "force_hash_collisions"))]`
	`227`	`+// Keep custom BuildHasher leaf hashing off the default RandomState fast path.`
	`228`	`+trait BuildHasherHashValue {`
	`229`	`+ fn hash_one_with_hasher<S: BuildHasher>(&self, state: &S) -> u64;`
	`230`	`+}`
	`231`	`+`
	`232`	`+#[cfg(not(feature = "force_hash_collisions"))]`
	`233`	`+impl<T: BuildHasherHashValue + ?Sized> BuildHasherHashValue for &T {`
	`234`	`+ fn hash_one_with_hasher<S: BuildHasher>(&self, state: &S) -> u64 {`
	`235`	`+ T::hash_one_with_hasher(self, state)`
	`236`	`+ }`
	`237`	`+}`
	`238`	`+`
`226`	`239`	`macro_rules! hash_value {`
`227`	`240`	`($($t:ty),+) => {`
`228`	`241`	`$(impl HashValue for $t {`
`229`		`- fn hash_one<S: BuildHasher>(&self, state: &S) -> u64 {`
	`242`	`+ fn hash_one(&self, state: &RandomState) -> u64 {`
`230`	`243`	`state.hash_one(self)`
`231`	`244`	`}`
`232`	`245`	`fn hash_write(&self, hasher: &mut impl Hasher) {`
`233`	`246`	`Hash::hash(self, hasher)`
`234`	`247`	`}`
	`248`	`+ }`
	`249`	`+`
	`250`	`+ #[cfg(not(feature = "force_hash_collisions"))]`
	`251`	`+ impl BuildHasherHashValue for $t {`
	`252`	`+ fn hash_one_with_hasher<S: BuildHasher>(&self, state: &S) -> u64 {`
	`253`	`+ state.hash_one(self)`
	`254`	`+ }`
`235`	`255`	`})+`
`236`	`256`	`};`
`237`	`257`	`}`
`@@ -241,12 +261,19 @@ hash_value!(bool, str, [u8], IntervalDayTime, IntervalMonthDayNano);`
`241`	`261`	`macro_rules! hash_float_value {`
`242`	`262`	`($(($t:ty, $i:ty)),+) => {`
`243`	`263`	`$(impl HashValue for $t {`
`244`		`- fn hash_one<S: BuildHasher>(&self, state: &S) -> u64 {`
	`264`	`+ fn hash_one(&self, state: &RandomState) -> u64 {`
`245`	`265`	`state.hash_one(<$i>::from_ne_bytes(self.to_ne_bytes()))`
`246`	`266`	`}`
`247`	`267`	`fn hash_write(&self, hasher: &mut impl Hasher) {`
`248`	`268`	`hasher.write(&self.to_ne_bytes())`
`249`	`269`	`}`
	`270`	`+ }`
	`271`	`+`
	`272`	`+ #[cfg(not(feature = "force_hash_collisions"))]`
	`273`	`+ impl BuildHasherHashValue for $t {`
	`274`	`+ fn hash_one_with_hasher<S: BuildHasher>(&self, state: &S) -> u64 {`
	`275`	`+ state.hash_one(<$i>::from_ne_bytes(self.to_ne_bytes()))`
	`276`	`+ }`
`250`	`277`	`})+`
`251`	`278`	`};`
`252`	`279`	`}`
`@@ -551,7 +578,7 @@ fn hash_array_primitive_with_hasher<T, S>(`
`551`	`578`	`hashes_buffer: &mut [u64],`
`552`	`579`	`rehash: bool,`
`553`	`580`	`) where`
`554`		`- T: ArrowPrimitiveType<Native: HashValue>,`
	`581`	`+ T: ArrowPrimitiveType<Native: BuildHasherHashValue>,`
`555`	`582`	`S: BuildHasher,`
`556`	`583`	`{`
`557`	`584`	`assert_eq!(`
`@@ -563,23 +590,25 @@ fn hash_array_primitive_with_hasher<T, S>(`
`563`	`590`	`if array.null_count() == 0 {`
`564`	`591`	`if rehash {`
`565`	`592`	`for (hash, &value) in hashes_buffer.iter_mut().zip(array.values().iter()) {`
`566`		`- hash = combine_hashes(value.hash_one(hash_builder), hash);`
	`593`	`+ hash = combine_hashes(value.hash_one_with_hasher(hash_builder), hash);`
`567`	`594`	`}`
`568`	`595`	`} else {`
`569`	`596`	`for (hash, &value) in hashes_buffer.iter_mut().zip(array.values().iter()) {`
`570`		`- *hash = value.hash_one(hash_builder);`
	`597`	`+ *hash = value.hash_one_with_hasher(hash_builder);`
`571`	`598`	`}`
`572`	`599`	`}`
`573`	`600`	`} else if rehash {`
`574`	`601`	`for i in array.nulls().unwrap().valid_indices() {`
`575`	`602`	`let value = unsafe { array.value_unchecked(i) };`
`576`		`- hashes_buffer[i] =`
`577`		`- combine_hashes(value.hash_one(hash_builder), hashes_buffer[i]);`
	`603`	`+ hashes_buffer[i] = combine_hashes(`
	`604`	`+ value.hash_one_with_hasher(hash_builder),`
	`605`	`+ hashes_buffer[i],`
	`606`	`+ );`
`578`	`607`	`}`
`579`	`608`	`} else {`
`580`	`609`	`for i in array.nulls().unwrap().valid_indices() {`
`581`	`610`	`let value = unsafe { array.value_unchecked(i) };`
`582`		`- hashes_buffer[i] = value.hash_one(hash_builder);`
	`611`	`+ hashes_buffer[i] = value.hash_one_with_hasher(hash_builder);`
`583`	`612`	`}`
`584`	`613`	`}`
`585`	`614`	`}`
`@@ -592,7 +621,7 @@ fn hash_array_with_hasher<T, S>(`
`592`	`621`	`rehash: bool,`
`593`	`622`	`) where`
`594`	`623`	`T: ArrayAccessor,`
`595`		`- T::Item: HashValue,`
	`624`	`+ T::Item: BuildHasherHashValue,`
`596`	`625`	`S: BuildHasher,`
`597`	`626`	`{`
`598`	`627`	`assert_eq!(`
`@@ -605,24 +634,26 @@ fn hash_array_with_hasher<T, S>(`
`605`	`634`	`if rehash {`
`606`	`635`	`for (i, hash) in hashes_buffer.iter_mut().enumerate() {`
`607`	`636`	`let value = unsafe { array.value_unchecked(i) };`
`608`		`- hash = combine_hashes(value.hash_one(hash_builder), hash);`
	`637`	`+ hash = combine_hashes(value.hash_one_with_hasher(hash_builder), hash);`
`609`	`638`	`}`
`610`	`639`	`} else {`
`611`	`640`	`for (i, hash) in hashes_buffer.iter_mut().enumerate() {`
`612`	`641`	`let value = unsafe { array.value_unchecked(i) };`
`613`		`- *hash = value.hash_one(hash_builder);`
	`642`	`+ *hash = value.hash_one_with_hasher(hash_builder);`
`614`	`643`	`}`
`615`	`644`	`}`
`616`	`645`	`} else if rehash {`
`617`	`646`	`for i in array.nulls().unwrap().valid_indices() {`
`618`	`647`	`let value = unsafe { array.value_unchecked(i) };`
`619`		`- hashes_buffer[i] =`
`620`		`- combine_hashes(value.hash_one(hash_builder), hashes_buffer[i]);`
	`648`	`+ hashes_buffer[i] = combine_hashes(`
	`649`	`+ value.hash_one_with_hasher(hash_builder),`
	`650`	`+ hashes_buffer[i],`
	`651`	`+ );`
`621`	`652`	`}`
`622`	`653`	`} else {`
`623`	`654`	`for i in array.nulls().unwrap().valid_indices() {`
`624`	`655`	`let value = unsafe { array.value_unchecked(i) };`
`625`		`- hashes_buffer[i] = value.hash_one(hash_builder);`
	`656`	`+ hashes_buffer[i] = value.hash_one_with_hasher(hash_builder);`
`626`	`657`	`}`
`627`	`658`	`}`
`628`	`659`	`}`
`@@ -664,17 +695,17 @@ fn hash_string_view_array_inner_with_hasher<`
`664`	`695`	`let view_len = v as u32;`
`665`	`696`	`if !HAS_BUFFERS \|\| view_len <= 12 {`
`666`	`697`	`if REHASH {`
`667`		`- hash = combine_hashes(v.hash_one(hash_builder), hash);`
	`698`	`+ hash = combine_hashes(v.hash_one_with_hasher(hash_builder), hash);`
`668`	`699`	`} else {`
`669`		`- *hash = v.hash_one(hash_builder);`
	`700`	`+ *hash = v.hash_one_with_hasher(hash_builder);`
`670`	`701`	`}`
`671`	`702`	`continue;`
`672`	`703`	`}`
`673`	`704`	`let value = view_bytes(view_len, v);`
`674`	`705`	`if REHASH {`
`675`		`- hash = combine_hashes(value.hash_one(hash_builder), hash);`
	`706`	`+ hash = combine_hashes(value.hash_one_with_hasher(hash_builder), hash);`
`676`	`707`	`} else {`
`677`		`- *hash = value.hash_one(hash_builder);`
	`708`	`+ *hash = value.hash_one_with_hasher(hash_builder);`
`678`	`709`	`}`
`679`	`710`	`}`
`680`	`711`	`}`
`@@ -693,12 +724,12 @@ fn hash_generic_byte_view_array_with_hasher<T: ByteViewType, S: BuildHasher>(`
`693`	`724`	`) {`
`694`	`725`	`(false, false, false) => {`
`695`	`726`	`for (hash, &view) in hashes_buffer.iter_mut().zip(array.views().iter()) {`
`696`		`- *hash = view.hash_one(hash_builder);`
	`727`	`+ *hash = view.hash_one_with_hasher(hash_builder);`
`697`	`728`	`}`
`698`	`729`	`}`
`699`	`730`	`(false, false, true) => {`
`700`	`731`	`for (hash, &view) in hashes_buffer.iter_mut().zip(array.views().iter()) {`
`701`		`- hash = combine_hashes(view.hash_one(hash_builder), hash);`
	`732`	`+ hash = combine_hashes(view.hash_one_with_hasher(hash_builder), hash);`
`702`	`733`	`}`
`703`	`734`	`}`
`704`	`735`	`(false, true, false) => {`