fix(vortex-geo): decode null geometry rows as None in aabbs_2d

A null geometry matches nothing in a spatial join (the predicate is NULL
under SQL three-valued logic), so aabbs_2d must give a null row the same
slot as an empty geometry - None - instead of aborting the whole decode.

Generalize the decode: the per-type decoders now surface geoarrow's
per-row Option (a null row is None) through a shared geometry_row step,
geometries_opt is the null-aware column decode, and the strict
geometries() becomes a thin wrapper that errors on any None, preserving
its behavior for the scalar functions and single_geometry, which reject
nullable operands up front. The Option reflects the array's logical
validity - pinned by a constant-null test, where no storage validity
exists until canonicalization.

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

Author: HarukiMoriarty

vortex-geo/src/bounds.rs

@@ -8,23 +8,24 @@ use vortex_array::ArrayRef;
 use vortex_array::ExecutionCtx;
 use vortex_error::VortexResult;
 
-use crate::extension::geometries;
+use crate::extension::geometries_opt;
 
 /// Per-row 2-D axis-aligned bounding boxes (AABBs) of a native geometry column, as `(min, max)`
 /// pairs of `[x, y]` corners.
 ///
 /// The per-row counterpart of the [`GeometryAabb`](crate::aggregate_fn::GeometryAabb) aggregate,
-/// which unions the whole column into one box. A point yields a degenerate box with `min == max`;
-/// a geometry with no extent (e.g. an empty polygon) yields `None`.
+/// which unions the whole column into one box. A point yields a degenerate box with `min == max`.
+/// A null row, or a geometry with no extent (e.g. an empty polygon), yields `None`: either way
+/// the row has no box, and matches nothing in a spatial join.
 ///
 /// A non-geometry column is an error. Any `z`/`m` ordinates carry no bounds, this decodes to 2-D `geo_types`.
 pub fn aabbs_2d(
     array: &ArrayRef,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<impl Iterator<Item = Option<([f64; 2], [f64; 2])>> + use<>> {
-    Ok(geometries(array, ctx)?.into_iter().map(|geometry| {
+    Ok(geometries_opt(array, ctx)?.into_iter().map(|geometry| {
         geometry
-            .bounding_rect()
+            .and_then(|geometry| geometry.bounding_rect())
             .map(|rect| ([rect.min().x, rect.min().y], [rect.max().x, rect.max().y]))
     }))
 }
@@ -33,14 +34,18 @@ pub fn aabbs_2d(
 mod tests {
     use vortex_array::IntoArray;
     use vortex_array::VortexSessionExecute;
+    use vortex_array::arrays::ConstantArray;
     use vortex_array::arrays::PrimitiveArray;
+    use vortex_array::scalar::Scalar;
     use vortex_error::VortexResult;
 
     use super::aabbs_2d;
     use crate::test_harness::linestring_column;
     use crate::test_harness::multilinestring_column;
     use crate::test_harness::multipoint_column;
     use crate::test_harness::multipolygon_column;
+    use crate::test_harness::nullable_multipolygon_column;
+    use crate::test_harness::nullable_point_column;
     use crate::test_harness::point_column;
     use crate::test_harness::polygon_column;
     use crate::test_harness::rect_column;
@@ -139,6 +144,61 @@ mod tests {
         Ok(())
     }
 
+    /// A null geometry row yields `None`, just like an empty geometry: no box, so it matches
+    /// nothing in a spatial join. Valid rows keep their boxes.
+    #[test]
+    fn null_row_yields_none() -> VortexResult<()> {
+        let session = vortex_array::array_session();
+        let mut ctx = session.create_execution_ctx();
+
+        let points = nullable_point_column(vec![Some((1.0, 2.0)), None, Some((3.0, 4.0))])?;
+        assert_eq!(
+            aabbs_2d(&points, &mut ctx)?.collect::<Vec<_>>(),
+            vec![bounds(1.0, 2.0, 1.0, 2.0), None, bounds(3.0, 4.0, 3.0, 4.0)]
+        );
+        Ok(())
+    }
+
+    /// Valid, empty, and null rows stay positionally aligned: the valid row keeps its box, and
+    /// the empty and null rows are both `None`.
+    #[test]
+    fn mixed_valid_empty_null_rows_align() -> VortexResult<()> {
+        let session = vortex_array::array_session();
+        let mut ctx = session.create_execution_ctx();
+
+        let multipolygons = nullable_multipolygon_column(vec![
+            Some(vec![vec![vec![
+                (0.0, 0.0),
+                (1.0, 0.0),
+                (1.0, 1.0),
+                (0.0, 1.0),
+            ]]]),
+            Some(vec![]),
+            None,
+        ])?;
+        assert_eq!(
+            aabbs_2d(&multipolygons, &mut ctx)?.collect::<Vec<_>>(),
+            vec![bounds(0.0, 0.0, 1.0, 1.0), None, None]
+        );
+        Ok(())
+    }
+
+    /// A constant-null column has no materialized storage validity until canonicalization, so
+    /// this pins that the decode reflects the array's logical validity: every row is `None`.
+    #[test]
+    fn constant_null_column_is_all_none() -> VortexResult<()> {
+        let session = vortex_array::array_session();
+        let mut ctx = session.create_execution_ctx();
+
+        let dtype = point_column(vec![0.0], vec![0.0])?.dtype().as_nullable();
+        let nulls = ConstantArray::new(Scalar::null(dtype), 2).into_array();
+        assert_eq!(
+            aabbs_2d(&nulls, &mut ctx)?.collect::<Vec<_>>(),
+            vec![None, None]
+        );
+        Ok(())
+    }
+
     /// A zero-row column yields a zero-row result.
     #[test]
     fn empty_column_yields_nothing() -> VortexResult<()> {

vortex-geo/src/extension/linestring.rs

@@ -11,7 +11,6 @@ use arrow_array::ArrayRef as ArrowArrayRef;
 use arrow_schema::DataType;
 use arrow_schema::Field;
 use arrow_schema::extension::ExtensionType;
-use geo_traits::to_geo::ToGeoGeometry;
 use geo_types::Geometry;
 use geoarrow::array::GeoArrowArrayAccessor;
 use geoarrow::array::IntoArrow;
@@ -53,6 +52,7 @@ use super::coordinate::coordinate_storage_dtype;
 use super::geo_metadata_from_arrow;
 use super::geoarrow_metadata;
 use super::geoarrow_to_wkb;
+use super::geometry_row;
 
 /// A line string: `geoarrow.linestring`, stored as `List<Struct<x, y[, z][, m]>>` (an ordered path
 /// of vertices).
@@ -111,20 +111,15 @@ fn linestring_type(geo_metadata: &GeoMetadata, dimension: Dimension) -> LineStri
     LineStringType::new(dimension.into(), geoarrow_metadata(geo_metadata))
 }
 
-/// Decode `LineString` storage (`List<coordinate>`) to `geo_types` line strings, for the geo scalar
-/// functions. CRS does not affect planar geometry ops, so default metadata is used.
+/// Decode `LineString` storage (`List<coordinate>`) to `geo_types` line strings, one `Option` per
+/// row: a null row is `None`. CRS does not affect planar geometry ops, so default metadata is used.
 pub(crate) fn linestring_geometries(
     storage: &ArrayRef,
     ctx: &mut ExecutionCtx,
-) -> VortexResult<Vec<Geometry<f64>>> {
+) -> VortexResult<Vec<Option<Geometry<f64>>>> {
     linestring_array(storage, ctx)?
         .iter()
-        .map(|geometry| -> VortexResult<Geometry<f64>> {
-            Ok(geometry
-                .ok_or_else(|| vortex_err!("geo: null geometry is not supported"))?
-                .map_err(|e| vortex_err!("geo: geometry access failed: {e}"))?
-                .to_geometry())
-        })
+        .map(geometry_row)
         .collect()
 }
 

vortex-geo/src/extension/mod.rs

@@ -16,6 +16,7 @@ use std::sync::Arc;
 
 use ::wkb::reader::GeometryType;
 use arrow_array::BinaryArray;
+use geo_traits::to_geo::ToGeoGeometry;
 use geo_types::Geometry;
 use geoarrow::array::GenericWkbArray;
 use geoarrow::array::GeoArrowArray;
@@ -115,11 +116,25 @@ pub(crate) fn flatten_coordinates(
     node.execute::<StructArray>(ctx)
 }
 
-/// Decode a native geometry column to `geo_types`. A non-geometry operand is an error.
-pub(crate) fn geometries(
+/// Decode one geoarrow row to `geo_types`: a null row is `None`; a geometry access failure is an
+/// error. The shared per-row step of the per-type decoders.
+pub(crate) fn geometry_row<T: ToGeoGeometry<f64>, E: Display>(
+    row: Option<Result<T, E>>,
+) -> VortexResult<Option<Geometry<f64>>> {
+    row.map(|geometry| {
+        geometry
+            .map(|g| g.to_geometry())
+            .map_err(|e| vortex_err!("geo: geometry access failed: {e}"))
+    })
+    .transpose()
+}
+
+/// Decode a native geometry column to `geo_types`, one `Option` per row: a null row is `None`.
+/// A non-geometry column is an error.
+pub(crate) fn geometries_opt(
     array: &ArrayRef,
     ctx: &mut ExecutionCtx,
-) -> VortexResult<Vec<Geometry<f64>>> {
+) -> VortexResult<Vec<Option<Geometry<f64>>>> {
     let Some(ext) = array.dtype().as_extension_opt() else {
         vortex_bail!(
             "geo: operand is not a geometry extension type, was {}",
@@ -150,6 +165,19 @@ pub(crate) fn geometries(
     }
 }
 
+/// Decode a native geometry column to `geo_types`, erroring on any null row — the strict form of
+/// [`geometries_opt`] for callers that never decode nulls: the scalar functions reject nullable
+/// operands up front. A non-geometry column is an error.
+pub(crate) fn geometries(
+    array: &ArrayRef,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<Vec<Geometry<f64>>> {
+    geometries_opt(array, ctx)?
+        .into_iter()
+        .map(|geometry| geometry.ok_or_else(|| vortex_err!("geo: null geometry is not supported")))
+        .collect()
+}
+
 /// Decode a constant operand scalar to one geo geometry, a constant of any
 /// supported geometry type is decoded exactly like a column.
 pub(crate) fn single_geometry(
@@ -296,6 +324,7 @@ pub(crate) fn geo_metadata_from_arrow(metadata: &Metadata) -> GeoMetadata {
 #[cfg(test)]
 mod tests {
     use prost::Message;
+    use vortex_array::VortexSessionExecute;
     use vortex_array::dtype::DType;
     use vortex_error::VortexResult;
     use vortex_error::vortex_err;
@@ -305,8 +334,26 @@ mod tests {
     use super::MultiPoint;
     use super::Point;
     use super::Polygon;
+    use super::geometries;
+    use super::geometries_opt;
     use super::native_geometry_scalar_from_wkb;
     use crate::extension::GeoMetadata;
+    use crate::test_harness::nullable_point_column;
+
+    /// A null row is `None` in the null-aware decode but an error in the strict one — the strict
+    /// contract the scalar functions rely on must not shift.
+    #[test]
+    fn null_row_is_none_in_opt_but_errors_in_strict() -> VortexResult<()> {
+        let session = vortex_array::array_session();
+        let mut ctx = session.create_execution_ctx();
+
+        let points = nullable_point_column(vec![Some((1.0, 2.0)), None])?;
+        let decoded = geometries_opt(&points, &mut ctx)?;
+        assert!(decoded[0].is_some());
+        assert!(decoded[1].is_none());
+        assert!(geometries(&points, &mut ctx).is_err());
+        Ok(())
+    }
 
     #[test]
     fn test_metadata() {

vortex-geo/src/extension/multilinestring.rs

@@ -12,7 +12,6 @@ use arrow_array::ArrayRef as ArrowArrayRef;
 use arrow_schema::DataType;
 use arrow_schema::Field;
 use arrow_schema::extension::ExtensionType;
-use geo_traits::to_geo::ToGeoGeometry;
 use geo_types::Geometry;
 use geoarrow::array::GeoArrowArrayAccessor;
 use geoarrow::array::IntoArrow;
@@ -54,6 +53,7 @@ use super::coordinate::coordinate_storage_dtype;
 use super::geo_metadata_from_arrow;
 use super::geoarrow_metadata;
 use super::geoarrow_to_wkb;
+use super::geometry_row;
 
 /// A multilinestring: `geoarrow.multilinestring`, stored as `List<List<Struct<x, y[, z][, m]>>>`
 /// (line strings of vertices).
@@ -116,19 +116,15 @@ fn multilinestring_type(geo_metadata: &GeoMetadata, dimension: Dimension) -> Mul
     MultiLineStringType::new(dimension.into(), geoarrow_metadata(geo_metadata))
 }
 
-/// Decode storage to `geo_types` for the geo scalar functions (CRS is irrelevant to planar ops).
+/// Decode storage to `geo_types`, one `Option` per row: a null row is `None` (CRS is irrelevant
+/// to planar ops).
 pub(crate) fn multilinestring_geometries(
     storage: &ArrayRef,
     ctx: &mut ExecutionCtx,
-) -> VortexResult<Vec<Geometry<f64>>> {
+) -> VortexResult<Vec<Option<Geometry<f64>>>> {
     multilinestring_array(storage, ctx)?
         .iter()
-        .map(|geometry| -> VortexResult<Geometry<f64>> {
-            Ok(geometry
-                .ok_or_else(|| vortex_err!("geo: null geometry is not supported"))?
-                .map_err(|e| vortex_err!("geo: geometry access failed: {e}"))?
-                .to_geometry())
-        })
+        .map(geometry_row)
         .collect()
 }
 

vortex-geo/src/extension/multipoint.rs

@@ -12,7 +12,6 @@ use arrow_array::ArrayRef as ArrowArrayRef;
 use arrow_schema::DataType;
 use arrow_schema::Field;
 use arrow_schema::extension::ExtensionType;
-use geo_traits::to_geo::ToGeoGeometry;
 use geo_types::Geometry;
 use geoarrow::array::GeoArrowArrayAccessor;
 use geoarrow::array::IntoArrow;
@@ -54,6 +53,7 @@ use super::coordinate::coordinate_storage_dtype;
 use super::geo_metadata_from_arrow;
 use super::geoarrow_metadata;
 use super::geoarrow_to_wkb;
+use super::geometry_row;
 
 /// A multipoint: `geoarrow.multipoint`, stored as `List<Struct<x, y[, z][, m]>>` (a set of points).
 #[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
@@ -110,19 +110,15 @@ fn multipoint_type(geo_metadata: &GeoMetadata, dimension: Dimension) -> MultiPoi
     MultiPointType::new(dimension.into(), geoarrow_metadata(geo_metadata))
 }
 
-/// Decode `MultiPoint` storage (`List<coordinate>`) to `geo_types`, for the geo scalar functions.
+/// Decode `MultiPoint` storage (`List<coordinate>`) to `geo_types`, one `Option` per row: a null
+/// row is `None`.
 pub(crate) fn multipoint_geometries(
     storage: &ArrayRef,
     ctx: &mut ExecutionCtx,
-) -> VortexResult<Vec<Geometry<f64>>> {
+) -> VortexResult<Vec<Option<Geometry<f64>>>> {
     multipoint_array(storage, ctx)?
         .iter()
-        .map(|geometry| -> VortexResult<Geometry<f64>> {
-            Ok(geometry
-                .ok_or_else(|| vortex_err!("geo: null geometry is not supported"))?
-                .map_err(|e| vortex_err!("geo: geometry access failed: {e}"))?
-                .to_geometry())
-        })
+        .map(geometry_row)
         .collect()
 }
 

vortex-geo/src/extension/multipolygon.rs

@@ -11,7 +11,6 @@ use arrow_array::ArrayRef as ArrowArrayRef;
 use arrow_schema::DataType;
 use arrow_schema::Field;
 use arrow_schema::extension::ExtensionType;
-use geo_traits::to_geo::ToGeoGeometry;
 use geo_types::Geometry;
 use geoarrow::array::GeoArrowArrayAccessor;
 use geoarrow::array::IntoArrow;
@@ -53,6 +52,7 @@ use super::coordinate::coordinate_storage_dtype;
 use super::geo_metadata_from_arrow;
 use super::geoarrow_metadata;
 use super::geoarrow_to_wkb;
+use super::geometry_row;
 
 /// A multipolygon (`geoarrow.multipolygon`); a single `Polygon` is a one-element multipolygon.
 #[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
@@ -117,19 +117,15 @@ fn multipolygon_type(geo_metadata: &GeoMetadata, dimension: Dimension) -> MultiP
     MultiPolygonType::new(dimension.into(), geoarrow_metadata(geo_metadata))
 }
 
-/// Decode storage to `geo_types` for the geo scalar functions (CRS is irrelevant to planar ops).
+/// Decode storage to `geo_types`, one `Option` per row: a null row is `None` (CRS is irrelevant
+/// to planar ops).
 pub(crate) fn multipolygon_geometries(
     storage: &ArrayRef,
     ctx: &mut ExecutionCtx,
-) -> VortexResult<Vec<Geometry<f64>>> {
+) -> VortexResult<Vec<Option<Geometry<f64>>>> {
     multipolygon_array(storage, ctx)?
         .iter()
-        .map(|geometry| -> VortexResult<Geometry<f64>> {
-            Ok(geometry
-                .ok_or_else(|| vortex_err!("geo: null geometry is not supported"))?
-                .map_err(|e| vortex_err!("geo: geometry access failed: {e}"))?
-                .to_geometry())
-        })
+        .map(geometry_row)
         .collect()
 }