fix: drop Python callable from UDF Hash impls

`Python::attach(|py| self.func.bind(py).hash().unwrap_or(0))`
silently collapsed every unhashable closure (e.g. a lambda with an
unhashable captured value) to the same hash bucket — the worst case
for hashmap lookups, and arrived at via `unwrap_or` rather than a
deliberate design choice.

Hash on the identifying header (name + signature + return field /
state fields) only. The Rust `Hash` contract requires
`a == b ⇒ hash(a) == hash(b)`, not the converse, so a coarser hash
is still sound — `PartialEq` (which still calls Python `eq` on the
callable) disambiguates two UDFs that share a header but differ in
their callable. Applied symmetrically to scalar, aggregate, and
window UDFs.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: timsaucer

crates/core/src/udaf.rs

@@ -249,16 +249,15 @@ impl PartialEq for PythonFunctionAggregateUDF {
 
 impl std::hash::Hash for PythonFunctionAggregateUDF {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        // See `PythonFunctionScalarUDF`'s `Hash` impl for the
+        // rationale: hash the identifying header only and let
+        // `PartialEq` disambiguate callables.
         self.name.hash(state);
         self.signature.hash(state);
         self.return_type.hash(state);
         for f in &self.state_fields {
             f.hash(state);
         }
-        Python::attach(|py| {
-            let py_hash = self.accumulator.bind(py).hash().unwrap_or(0);
-            state.write_isize(py_hash);
-        });
     }
 }
 

crates/core/src/udf.rs

@@ -106,15 +106,18 @@ impl PartialEq for PythonFunctionScalarUDF {
 
 impl Hash for PythonFunctionScalarUDF {
     fn hash<H: Hasher>(&self, state: &mut H) {
+        // Hash only the identifying header (name + signature + return
+        // field). Skipping `func` is intentional: the Rust `Hash`
+        // contract requires `a == b ⇒ hash(a) == hash(b)`, not the
+        // converse, so a coarser hash is sound — `PartialEq` still
+        // disambiguates two UDFs with the same header but distinct
+        // callables. Falling back to a sentinel on `py_hash` failure
+        // (as a prior revision did) silently mapped every unhashable
+        // closure to the same bucket; that is the worst case for a
+        // hashmap and is what this rewrite avoids.
         self.name.hash(state);
         self.signature.hash(state);
         self.return_field.hash(state);
-
-        Python::attach(|py| {
-            let py_hash = self.func.bind(py).hash().unwrap_or(0); // Handle unhashable objects
-
-            state.write_isize(py_hash);
-        });
     }
 }
 

crates/core/src/udwf.rs

@@ -340,13 +340,12 @@ impl PartialEq for PythonFunctionWindowUDF {
 
 impl std::hash::Hash for PythonFunctionWindowUDF {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        // See `PythonFunctionScalarUDF`'s `Hash` impl for the
+        // rationale: hash the identifying header only and let
+        // `PartialEq` disambiguate evaluators.
         self.name.hash(state);
         self.signature.hash(state);
         self.return_type.hash(state);
-        Python::attach(|py| {
-            let py_hash = self.evaluator.bind(py).hash().unwrap_or(0);
-            state.write_isize(py_hash);
-        });
     }
 }