refactor(vortex-geo): move null-propagating dispatch to its own module

Address PR review round 2:
- Move the shared null-propagating dispatch out of scalar_fn/mod.rs into
  scalar_fn/null_propagate.rs, keeping mod.rs to module-tree wiring.
- Bring ST_Distance and ST_Intersects null-path coverage to parity with
  ST_Contains: all-null-column and empty-combined-mask early returns, plus
  the two-column path for ST_Intersects.

Signed-off-by: Nemo Yu <zyu379@wisc.edu>

Author: HarukiMoriarty

vortex-geo/src/scalar_fn/contains.rs

@@ -22,8 +22,8 @@ use vortex_session::VortexSession;
 use vortex_session::registry::CachedId;
 
 use crate::extension::validate_geometry_operands;
-use crate::scalar_fn::binary_result_validity;
-use crate::scalar_fn::execute_null_propagating;
+use crate::scalar_fn::null_propagate::binary_result_validity;
+use crate::scalar_fn::null_propagate::execute_null_propagating;
 
 /// OGC `ST_Contains` between two native geometry operands, each a column or a constant
 /// literal: true where operand `b` lies completely inside operand `a` (boundary contact alone

vortex-geo/src/scalar_fn/distance.rs

@@ -24,8 +24,8 @@ use vortex_session::VortexSession;
 use vortex_session::registry::CachedId;
 
 use crate::extension::validate_geometry_operands;
-use crate::scalar_fn::binary_result_validity;
-use crate::scalar_fn::execute_null_propagating;
+use crate::scalar_fn::null_propagate::binary_result_validity;
+use crate::scalar_fn::null_propagate::execute_null_propagating;
 
 /// Planar (Euclidean) `ST_Distance` (no geodesic correction) between two native geometry
 /// operands, each a column or a constant literal.
@@ -268,6 +268,38 @@ mod tests {
         Ok(())
     }
 
+    /// An entirely-null geometry column yields an all-null output (the fully-null fast path in
+    /// `eval_column`).
+    #[test]
+    fn distance_all_null_column_is_all_null() -> VortexResult<()> {
+        let session = vortex_array::array_session();
+        let mut ctx = session.create_execution_ctx();
+
+        let a = nullable_point_column(vec![None, None])?;
+        let b = point_constant(0.0, 0.0, 2, &mut ctx)?;
+        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+
+        let expected = PrimitiveArray::new(vec![0.0f64; 2], Validity::AllInvalid).into_array();
+        assert_arrays_eq!(distance, expected, &mut ctx);
+        Ok(())
+    }
+
+    /// Two nullable columns whose nulls never line up: the combined mask is empty, so the output
+    /// is all null (the `valid.all_false()` early return in `eval_column_pair`).
+    #[test]
+    fn distance_column_pair_all_null() -> VortexResult<()> {
+        let session = vortex_array::array_session();
+        let mut ctx = session.create_execution_ctx();
+
+        let a = nullable_point_column(vec![Some((0.0, 0.0)), None])?;
+        let b = nullable_point_column(vec![None, Some((1.0, 1.0))])?;
+        let distance = GeoDistance::try_new_array(a, b)?.into_array();
+
+        let expected = PrimitiveArray::new(vec![0.0f64; 2], Validity::AllInvalid).into_array();
+        assert_arrays_eq!(distance, expected, &mut ctx);
+        Ok(())
+    }
+
     /// A non-geometry operand dtype is rejected up front, before execution.
     #[test]
     fn non_geometry_operand_is_rejected() -> VortexResult<()> {

vortex-geo/src/scalar_fn/intersects.rs

@@ -22,8 +22,8 @@ use vortex_session::VortexSession;
 use vortex_session::registry::CachedId;
 
 use crate::extension::validate_geometry_operands;
-use crate::scalar_fn::binary_result_validity;
-use crate::scalar_fn::execute_null_propagating;
+use crate::scalar_fn::null_propagate::binary_result_validity;
+use crate::scalar_fn::null_propagate::execute_null_propagating;
 
 /// OGC `ST_Intersects` (not disjoint; boundary contact counts) between two native geometry
 /// operands, each a column or a constant literal.
@@ -337,6 +337,70 @@ mod tests {
         Ok(())
     }
 
+    /// Both operands nullable columns: the verdict is null wherever either row is null, and
+    /// computed on the rows valid in both (points intersect exactly when equal).
+    #[test]
+    fn intersects_propagates_column_pair_nulls() -> VortexResult<()> {
+        let session = vortex_array::array_session();
+        let mut ctx = session.create_execution_ctx();
+
+        let a = nullable_point_column(vec![
+            Some((0.0, 0.0)),
+            None,
+            Some((2.0, 2.0)),
+            Some((3.0, 3.0)),
+        ])?;
+        let b = nullable_point_column(vec![
+            Some((0.0, 0.0)),
+            Some((5.0, 5.0)),
+            None,
+            Some((9.0, 9.0)),
+        ])?;
+        let intersects = GeoIntersects::try_new_array(a, b)?.into_array();
+
+        let expected = BoolArray::new(
+            BitBuffer::from_iter([true, false, false, false]),
+            Validity::from_iter([true, false, false, true]),
+        )
+        .into_array();
+        assert_arrays_eq!(intersects, expected, &mut ctx);
+        Ok(())
+    }
+
+    /// An entirely-null geometry column yields an all-null output (the fully-null fast path in
+    /// `eval_column`).
+    #[test]
+    fn intersects_all_null_column_is_all_null() -> VortexResult<()> {
+        let session = vortex_array::array_session();
+        let mut ctx = session.create_execution_ctx();
+
+        let points = nullable_point_column(vec![None, None])?;
+        let query = geometry_constant(&donut(), 2)?;
+        let intersects = GeoIntersects::try_new_array(points, query)?.into_array();
+
+        let expected =
+            BoolArray::new(BitBuffer::from_iter([false, false]), Validity::AllInvalid).into_array();
+        assert_arrays_eq!(intersects, expected, &mut ctx);
+        Ok(())
+    }
+
+    /// Two nullable columns whose nulls never line up: the combined mask is empty, so the output
+    /// is all null (the `valid.all_false()` early return in `eval_column_pair`).
+    #[test]
+    fn intersects_column_pair_all_null() -> VortexResult<()> {
+        let session = vortex_array::array_session();
+        let mut ctx = session.create_execution_ctx();
+
+        let a = nullable_point_column(vec![Some((0.0, 0.0)), None])?;
+        let b = nullable_point_column(vec![None, Some((1.0, 1.0))])?;
+        let intersects = GeoIntersects::try_new_array(a, b)?.into_array();
+
+        let expected =
+            BoolArray::new(BitBuffer::from_iter([false, false]), Validity::AllInvalid).into_array();
+        assert_arrays_eq!(intersects, expected, &mut ctx);
+        Ok(())
+    }
+
     /// A non-geometry operand dtype is rejected up front, before execution.
     #[test]
     fn non_geometry_operand_is_rejected() -> VortexResult<()> {