fix(geoarrow-array): Fix validation of sliced geometry arrays (#1391)

### Change list

- Validation through `new`, e.g. `LineStringArray::new` was incorrect
for any input array with offsets that had been sliced.
- This PR fixes the validation and adds tests through the `new`
constructor for sliced arrays.

Closes #1390, closes
#1387

Author: kylebarron

Cargo.lock

@@ -17,7 +17,7 @@ exclude = ["js"]
 resolver = "2"
 
 [workspace.package]
-version = "0.6.1"
+version = "0.6.2"
 authors = ["Kyle Barron <[email protected]>"]
 edition = "2024"
 license = "MIT OR Apache-2.0"

Cargo.toml

@@ -4,7 +4,7 @@
 
 ## [0.6.0] - 2025-10-16
 
-## What's Changed
+### What's Changed
 
 - docs: include constructor docs in the table of contents by @keewis in https://github.com/geoarrow/geoarrow-rs/pull/1347
 - fix(geoarrow-flatgeobuf): Fix FlatGeobuf reader with missing (null) properties by @kylebarron in https://github.com/geoarrow/geoarrow-rs/pull/1356
@@ -16,7 +16,7 @@
 - fix(python): Fix `__geo_interface__` export for GeoScalar by @kylebarron in https://github.com/geoarrow/geoarrow-rs/pull/1384
 - feat(python): Constuctor for GeoArray by @kylebarron in https://github.com/geoarrow/geoarrow-rs/pull/1385
 
-## New Contributors
+### New Contributors
 
 - @keewis made their first contribution in https://github.com/geoarrow/geoarrow-rs/pull/1347
 

python/CHANGELOG.md

@@ -4,6 +4,10 @@
 
 ## Unreleased
 
+## 0.6.2 - 2025-10-27
+
+fix(geoarrow-array): Fix validation of sliced geometry arrays #1391
+
 ## 0.6.0 - 2025-10-15
 
 - fix(geoarrow-array): Fix persisting CRS when creating `GeometryArray` from `Field` by @kylebarron in https://github.com/geoarrow/geoarrow-rs/pull/1326

rust/geoarrow-array/CHANGELOG.md

@@ -44,9 +44,10 @@ pub(super) fn check(
         ));
     }
 
-    if *geom_offsets.last() as usize != coords.len() {
+    // Offset can be smaller than coords length if sliced
+    if *geom_offsets.last() as usize > coords.len() {
         return Err(GeoArrowError::InvalidGeoArrow(
-            "largest geometry offset must match coords length".to_string(),
+            "largest geometry offset must not be longer than coords length".to_string(),
         ));
     }
 
@@ -321,6 +322,8 @@ impl GeometryTypeId for LineStringArray {
 
 #[cfg(test)]
 mod test {
+    use arrow_array::RecordBatch;
+    use arrow_schema::Schema;
     use geo_traits::to_geo::ToGeoLineString;
     use geoarrow_schema::{CoordType, Dimension};
 
@@ -401,4 +404,70 @@ mod test {
 
         assert_ne!(arr1, arr2.slice(0, 2));
     }
+
+    #[test]
+    fn test_validation_with_sliced_array() {
+        let arr = linestring::array(CoordType::Interleaved, Dimension::XY);
+        let sliced = arr.slice(0, 1);
+
+        let back = LineStringArray::try_from((
+            sliced.to_array_ref().as_ref(),
+            arr.extension_type().clone(),
+        ))
+        .unwrap();
+        assert_eq!(back.len(), 1);
+    }
+
+    #[test]
+    fn slice_then_go_through_arrow() {
+        let arr = linestring::array(CoordType::Separated, Dimension::XY);
+        let sliced_array = arr.slice(0, 1);
+
+        let ls_array: LineStringArray = (
+            sliced_array.to_array_ref().as_ref(),
+            arr.extension_type().clone(),
+        )
+            .try_into()
+            .unwrap();
+        assert_eq!(ls_array.len(), 1);
+    }
+
+    #[test]
+    fn slice_back_from_arrow_rs_record_batch() {
+        let arr = linestring::array(CoordType::Separated, Dimension::XY);
+        let field = arr.extension_type().to_field("geometry", true);
+        let schema = Schema::new(vec![field]);
+
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![arr.to_array_ref()]).unwrap();
+        let sliced_batch = batch.slice(0, 1);
+
+        let array = sliced_batch.column(0);
+        let field = sliced_batch.schema_ref().field(0);
+        let ls_array: LineStringArray = (array.as_ref(), field).try_into().unwrap();
+        assert_eq!(ls_array.len(), 1);
+    }
+
+    #[test]
+    fn slice_back_from_arrow_rs_array() {
+        let arr = linestring::array(CoordType::Separated, Dimension::XY);
+        let field = arr.extension_type().to_field("geometry", true);
+
+        let array = arr.to_array_ref();
+        let sliced_array = array.slice(0, 1);
+
+        let ls_array: LineStringArray = (sliced_array.as_ref(), &field).try_into().unwrap();
+        assert_eq!(ls_array.len(), 1);
+    }
+
+    #[test]
+    fn slice_back_from_arrow_rs_array_with_nulls() {
+        let arr = linestring::ls_array(CoordType::Separated);
+        let field = arr.extension_type().to_field("geometry", true);
+
+        let array = arr.to_array_ref();
+        let sliced_array = array.slice(0, 1);
+
+        let ls_array: LineStringArray = (sliced_array.as_ref(), &field).try_into().unwrap();
+        assert_eq!(ls_array.len(), 1);
+    }
 }

rust/geoarrow-array/src/array/linestring.rs

@@ -54,9 +54,10 @@ pub(super) fn check(
         ));
     }
 
-    if *geom_offsets.last() as usize != ring_offsets.len_proxy() {
+    // Offset can be smaller than length if sliced
+    if *geom_offsets.last() as usize > ring_offsets.len_proxy() {
         return Err(GeoArrowError::InvalidGeoArrow(
-            "largest geometry offset must match ring offsets length".to_string(),
+            "largest geometry offset must not be longer than ring offsets length".to_string(),
         ));
     }
 
@@ -502,4 +503,27 @@ mod test {
             assert_ne!(arr1, arr2.slice(0, 2));
         }
     }
+
+    #[test]
+    fn test_validation_with_sliced_array() {
+        let arr = multilinestring::array(CoordType::Interleaved, Dimension::XY);
+        let sliced = arr.slice(0, 1);
+
+        let back = MultiLineStringArray::try_from((
+            sliced.to_array_ref().as_ref(),
+            arr.extension_type().clone(),
+        ))
+        .unwrap();
+        assert_eq!(back.len(), 1);
+    }
+
+    #[test]
+    fn test_validation_with_array_sliced_by_arrow_rs() {
+        let arr = multilinestring::array(CoordType::Interleaved, Dimension::XY);
+        let sliced = arr.to_array_ref().slice(0, 1);
+
+        let back = MultiLineStringArray::try_from((sliced.as_ref(), arr.extension_type().clone()))
+            .unwrap();
+        assert_eq!(back.len(), 1);
+    }
 }

rust/geoarrow-array/src/array/multilinestring.rs

@@ -44,9 +44,10 @@ pub(super) fn check(
         ));
     }
 
-    if *geom_offsets.last() as usize != coords.len() {
+    // Offset can be smaller than coords length if sliced
+    if *geom_offsets.last() as usize > coords.len() {
         return Err(GeoArrowError::InvalidGeoArrow(
-            "largest geometry offset must match coords length".to_string(),
+            "largest geometry offset must not be longer than coords length".to_string(),
         ));
     }
 

rust/geoarrow-array/src/array/multipoint.rs

@@ -51,6 +51,8 @@ pub(super) fn check(
             "nulls mask length must match the number of values".to_string(),
         ));
     }
+
+    // Offset can be smaller than coords length if sliced
     if *ring_offsets.last() as usize != coords.len() {
         return Err(GeoArrowError::InvalidGeoArrow(
             "largest ring offset must match coords length".to_string(),
@@ -63,9 +65,9 @@ pub(super) fn check(
         ));
     }
 
-    if *geom_offsets.last() as usize != polygon_offsets.len_proxy() {
+    if *geom_offsets.last() as usize > polygon_offsets.len_proxy() {
         return Err(GeoArrowError::InvalidGeoArrow(
-            "largest geometry offset must match polygon offsets length".to_string(),
+            "largest geometry offset must not be longer than polygon offsets length".to_string(),
         ));
     }
 
@@ -555,4 +557,27 @@ mod test {
             assert_ne!(arr1, arr2.slice(0, 2));
         }
     }
+
+    #[test]
+    fn test_validation_with_sliced_array() {
+        let arr = multipolygon::array(CoordType::Interleaved, Dimension::XY);
+        let sliced = arr.slice(0, 1);
+
+        let back = MultiPolygonArray::try_from((
+            sliced.to_array_ref().as_ref(),
+            arr.extension_type().clone(),
+        ))
+        .unwrap();
+        assert_eq!(back.len(), 1);
+    }
+
+    #[test]
+    fn test_validation_with_array_sliced_by_arrow_rs() {
+        let arr = multipolygon::array(CoordType::Interleaved, Dimension::XY);
+        let sliced = arr.to_array_ref().slice(0, 1);
+
+        let back =
+            MultiPolygonArray::try_from((sliced.as_ref(), arr.extension_type().clone())).unwrap();
+        assert_eq!(back.len(), 1);
+    }
 }

rust/geoarrow-array/src/array/multipolygon.rs

@@ -56,9 +56,10 @@ pub(super) fn check(
         ));
     }
 
-    if *geom_offsets.last() as usize != ring_offsets.len_proxy() {
+    // Offset can be smaller than length if sliced
+    if *geom_offsets.last() as usize > ring_offsets.len_proxy() {
         return Err(GeoArrowError::InvalidGeoArrow(
-            "largest geometry offset must match ring offsets length".to_string(),
+            "largest geometry offset must not be longer than ring offsets length".to_string(),
         ));
     }
 
@@ -488,4 +489,24 @@ mod test {
 
         assert_ne!(arr1, arr2.slice(0, 2));
     }
+
+    #[test]
+    fn test_validation_with_sliced_array() {
+        let arr = polygon::array(CoordType::Interleaved, Dimension::XY);
+        let sliced = arr.slice(0, 1);
+
+        let back =
+            PolygonArray::try_from((sliced.to_array_ref().as_ref(), arr.extension_type().clone()))
+                .unwrap();
+        assert_eq!(back.len(), 1);
+    }
+
+    #[test]
+    fn test_validation_with_array_sliced_by_arrow_rs() {
+        let arr = polygon::array(CoordType::Interleaved, Dimension::XY);
+        let sliced = arr.to_array_ref().slice(0, 1);
+
+        let back = PolygonArray::try_from((sliced.as_ref(), arr.extension_type().clone())).unwrap();
+        assert_eq!(back.len(), 1);
+    }
 }