Fix geo overlay tests

Author: Kontinuation

Cargo.lock

@@ -69,8 +69,10 @@ pub fn item_to_geometry(geo: impl GeometryTrait<T = f64>) -> Result<Geometry> {
 }
 
 // GeometryCollection causes issues because it has a recursive definition and won't work
-// with cargo run --release. Thus, we need our own version of this that limits the
-// recursion supported in a GeometryCollection.
+// with cargo run --release. Thus, we need our own version of this that works around this
+// problem by processing GeometryCollection using a free function instead of relying
+// on trait resolver.
+// See also https://github.com/geoarrow/geoarrow-rs/pull/956.
 fn to_geometry(item: impl GeometryTrait<T = f64>) -> Option<Geometry> {
     match item.as_type() {
         Point(geom) => geom.try_to_point().map(Geometry::Point),

rust/sedona-geo/src/to_geo.rs

@@ -42,7 +42,7 @@ criterion = { workspace = true, optional = true }
 datafusion-common = { workspace = true }
 datafusion-expr = { workspace = true }
 datafusion-physical-expr = { workspace = true }
-geo-traits = { workspace = true }
+geo-traits = { workspace = true, features = ["geo-types"] }
 geo-types = { workspace = true }
 parquet = { workspace = true, features = ["arrow", "snap", "zstd"] }
 rand = { workspace = true }
@@ -52,3 +52,4 @@ sedona-expr = { path = "../sedona-expr" }
 sedona-schema = { path = "../sedona-schema" }
 wkb = { workspace = true }
 wkt = { workspace = true }
+geo = { workspace = true }

rust/sedona-testing/Cargo.toml

@@ -23,7 +23,10 @@ use datafusion_common::{
     ScalarValue,
 };
 use datafusion_expr::ColumnarValue;
+use geo::Relate;
+use geo_traits::to_geo::ToGeoGeometry;
 use sedona_schema::datatypes::{SedonaType, WKB_GEOMETRY};
+use wkb::reader::Dimension;
 
 use crate::create::create_scalar;
 
@@ -104,7 +107,9 @@ pub fn assert_array_equal(actual: &ArrayRef, expected: &ArrayRef) {
 /// Panics if the values' are not equal, generating reasonable failure messages for geometry
 /// arrays where the default failure message would otherwise be uninformative.
 pub fn assert_scalar_equal_wkb_geometry(actual: &ScalarValue, expected_wkt: Option<&str>) {
-    assert_scalar_equal(actual, &create_scalar(expected_wkt, &WKB_GEOMETRY));
+    let expected = create_scalar(expected_wkt, &WKB_GEOMETRY);
+    assert_eq!(actual.data_type(), DataType::Binary);
+    assert_wkb_scalar_equal(actual, &expected);
 }
 
 /// Assert two [`ScalarValue`]s are equal
@@ -205,9 +210,32 @@ fn assert_wkb_value_equal(
             )
         }
         (Some(actual_wkb), Some(expected_wkb)) => {
+            // Quick test: if the binary of the WKB is the same, they are equal
             if actual_wkb != expected_wkb {
-                let (actual_wkt, expected_wkt) = (format_wkb(actual_wkb), format_wkb(expected_wkb));
-                panic!("{actual_label} != {expected_label}\n{actual_label}:\n  {actual_wkt}\n{expected_label}:\n  {expected_wkt}")
+                // Binary of the WKB are not the same, but geometries could be topologically the same.
+                let expected = wkb::reader::read_wkb(expected_wkb);
+                let actual = wkb::reader::read_wkb(actual_wkb);
+                let is_equals = match (expected, actual) {
+                    (Ok(expected_geom), Ok(actual_geom)) => {
+                        if expected_geom.dimension() == Dimension::Xy
+                            && actual_geom.dimension() == Dimension::Xy
+                        {
+                            let expected_geom = expected_geom.to_geometry();
+                            let actual_geom = actual_geom.to_geometry();
+                            expected_geom.relate(&actual_geom).is_equal_topo()
+                        } else {
+                            // geo crate does not support 3D/4D geometry operations, so we fall back to using the result
+                            // of byte-wise comparison
+                            false
+                        }
+                    }
+                    _ => false,
+                };
+                if !is_equals {
+                    let (actual_wkt, expected_wkt) =
+                        (format_wkb(actual_wkb), format_wkb(expected_wkb));
+                    panic!("{actual_label} != {expected_label}\n{actual_label}:\n  {actual_wkt}\n{expected_label}:\n  {expected_wkt}")
+                }
             }
         }
     }