You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@sedona.apache.org by ja...@apache.org on 2026/08/02 18:44:33 UTC

(sedona-db) branch main updated: Drop datafusion-common from sedona-proj (#1104)

This is an automated email from the ASF dual-hosted git repository.

james-willis pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/sedona-db.git


The following commit(s) were added to refs/heads/main by this push:
     new 73828e3d5 Drop datafusion-common from sedona-proj (#1104)
73828e3d5 is described below

commit 73828e3d51c67c6d6ec4dea19ec2c43752725082
Author: James Willis <ja...@users.noreply.github.com>
AuthorDate: Sun Aug 2 11:44:28 2026 -0700

    Drop datafusion-common from sedona-proj (#1104)
---
 Cargo.lock                                         |  3 ---
 c/sedona-proj/Cargo.toml                           |  3 ---
 c/sedona-proj/src/error.rs                         |  3 +++
 c/sedona-proj/src/transform.rs                     | 29 ++++++++++++++--------
 python/sedonadb/src/lib.rs                         |  3 ++-
 rust/sedona-raster-functions/src/crs_utils.rs      | 18 ++++++++------
 .../src/rs_spatial_predicates.rs                   |  2 ++
 rust/sedona-raster-gdal/src/rs_clip.rs             |  3 +++
 rust/sedona-raster-gdal/src/rs_zonal_stats.rs      |  2 ++
 .../tests/spatial_join_integration.rs              | 17 +++++++------
 10 files changed, 50 insertions(+), 33 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4009e2125..fb29ce510 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6172,14 +6172,11 @@ name = "sedona-proj"
 version = "0.4.0"
 dependencies = [
  "approx",
- "datafusion-common",
  "geo-traits",
  "geo-types",
  "libloading 0.9.0",
  "proj-sys",
- "sedona-common",
  "sedona-geometry",
- "sedona-schema",
  "serde_json",
  "thiserror 2.0.17",
  "wkb",
diff --git a/c/sedona-proj/Cargo.toml b/c/sedona-proj/Cargo.toml
index 722a9a50b..9fe439785 100644
--- a/c/sedona-proj/Cargo.toml
+++ b/c/sedona-proj/Cargo.toml
@@ -40,10 +40,7 @@ proj-sys = [ "dep:proj-sys" ]
 [dependencies]
 libloading = { workspace = true }
 serde_json = { workspace = true }
-datafusion-common = { workspace = true }
 geo-traits = { workspace = true }
 proj-sys = { version = "0.26.0", optional = true }
-sedona-common = { workspace = true }
 sedona-geometry = { workspace = true }
-sedona-schema = { workspace = true }
 thiserror = { workspace = true }
diff --git a/c/sedona-proj/src/error.rs b/c/sedona-proj/src/error.rs
index a6e015930..d04a37063 100644
--- a/c/sedona-proj/src/error.rs
+++ b/c/sedona-proj/src/error.rs
@@ -27,4 +27,7 @@ pub enum SedonaProjError {
     CreateError(String),
     #[error("{0}")]
     TransformError(String),
+    /// A violation of an internal invariant (e.g. a poisoned global lock)
+    #[error("{0}")]
+    Internal(String),
 }
diff --git a/c/sedona-proj/src/transform.rs b/c/sedona-proj/src/transform.rs
index 73e6604f9..7366fc02e 100644
--- a/c/sedona-proj/src/transform.rs
+++ b/c/sedona-proj/src/transform.rs
@@ -17,9 +17,7 @@
 
 use crate::error::SedonaProjError;
 use crate::proj::{Proj, ProjContext};
-use datafusion_common::{DataFusionError, Result};
 use geo_traits::Dimensions;
-use sedona_common::sedona_internal_datafusion_err;
 use sedona_geometry::bounding_box::BoundingBox;
 use sedona_geometry::error::SedonaGeometryError;
 use sedona_geometry::interval::IntervalTrait;
@@ -187,9 +185,9 @@ impl ProjCrsEngineBuilder {
 /// deliberately to ensure that if an error occurs creating an engine that the
 /// configuration can be set again. Notably, this will occur if this crate was
 /// built without proj-sys the first time somebody calls st_transform.
-pub fn configure_global_proj_engine(builder: ProjCrsEngineBuilder) -> Result<()> {
+pub fn configure_global_proj_engine(builder: ProjCrsEngineBuilder) -> Result<(), SedonaProjError> {
     let mut global_builder = PROJ_ENGINE_BUILDER.try_write().map_err(|_| {
-        DataFusionError::Configuration(
+        SedonaProjError::Internal(
             "Failed to acquire write lock for global PROJ configuration".to_string(),
         )
     })?;
@@ -199,9 +197,17 @@ pub fn configure_global_proj_engine(builder: ProjCrsEngineBuilder) -> Result<()>
 
 /// Do something with the global thread-local PROJ engine, creating it if it has not
 /// already been created.
-pub fn with_global_proj_engine<R, F: FnMut(&CachingCrsEngine<ProjCrsEngine>) -> Result<R>>(
+///
+/// The closure receives the engine and returns its own [`Result`]. Only the
+/// engine-acquisition failure surfaces as a [`SedonaProjError`]; callers that
+/// need to reconcile that with a different error type (a DataFusion error, a
+/// binding error) convert it explicitly at the call boundary.
+pub fn with_global_proj_engine<
+    R,
+    F: FnMut(&CachingCrsEngine<ProjCrsEngine>) -> Result<R, SedonaProjError>,
+>(
     mut func: F,
-) -> Result<R> {
+) -> Result<R, SedonaProjError> {
     PROJ_ENGINE.with(|engine_cell| {
         // If there is already an engine, use it!
         if let Some(engine) = engine_cell.get() {
@@ -211,8 +217,8 @@ pub fn with_global_proj_engine<R, F: FnMut(&CachingCrsEngine<ProjCrsEngine>) ->
         // Otherwise, attempt to get the builder
         let maybe_builder = PROJ_ENGINE_BUILDER.read().map_err(|_| {
             // Highly unlikely (can only occur when a panic occurred during set)
-            sedona_internal_datafusion_err!(
-                "Failed to acquire read lock for global PROJ configuration"
+            SedonaProjError::Internal(
+                "Failed to acquire read lock for global PROJ configuration".to_string(),
             )
         })?;
 
@@ -221,12 +227,13 @@ pub fn with_global_proj_engine<R, F: FnMut(&CachingCrsEngine<ProjCrsEngine>) ->
         let proj_engine = maybe_builder
             .as_ref()
             .unwrap_or(&ProjCrsEngineBuilder::default())
-            .build()
-            .map_err(|e| DataFusionError::External(Box::new(e)))?;
+            .build()?;
 
         engine_cell
             .set(CachingCrsEngine::new(proj_engine))
-            .map_err(|_| sedona_internal_datafusion_err!("Failed to set cached PROJ transform"))?;
+            .map_err(|_| {
+                SedonaProjError::Internal("Failed to set cached PROJ transform".to_string())
+            })?;
         func(engine_cell.get().unwrap())
     })
 }
diff --git a/python/sedonadb/src/lib.rs b/python/sedonadb/src/lib.rs
index 6c4abb2e0..1c5f0f94d 100644
--- a/python/sedonadb/src/lib.rs
+++ b/python/sedonadb/src/lib.rs
@@ -97,7 +97,8 @@ fn configure_proj_shared(
         builder = builder.with_search_paths(vec![search_path.into()]);
     }
 
-    configure_global_proj_engine(builder)?;
+    configure_global_proj_engine(builder)
+        .map_err(|e| PySedonaError::SedonaPython(e.to_string()))?;
     Ok(())
 }
 
diff --git a/rust/sedona-raster-functions/src/crs_utils.rs b/rust/sedona-raster-functions/src/crs_utils.rs
index 1996114b9..e18c7a2c6 100644
--- a/rust/sedona-raster-functions/src/crs_utils.rs
+++ b/rust/sedona-raster-functions/src/crs_utils.rs
@@ -152,11 +152,11 @@ mod tests {
     fn align_wkb_borrows_when_crses_are_missing_or_equal() {
         let wkb = sample_wkb();
         with_global_proj_engine(|engine| {
-            let source = resolve_crs(Some("EPSG:4326"))?;
-            let target = resolve_crs(Some("EPSG:4326"))?;
+            let source = resolve_crs(Some("EPSG:4326")).unwrap();
+            let target = resolve_crs(Some("EPSG:4326")).unwrap();
 
             assert!(matches!(
-                align_wkb_to_crs(&wkb, None, None, "source", "target", engine)?,
+                align_wkb_to_crs(&wkb, None, None, "source", "target", engine).unwrap(),
                 Cow::Borrowed(_)
             ));
             assert!(matches!(
@@ -167,7 +167,8 @@ mod tests {
                     "source",
                     "target",
                     engine,
-                )?,
+                )
+                .unwrap(),
                 Cow::Borrowed(_)
             ));
             Ok(())
@@ -179,8 +180,8 @@ mod tests {
     fn align_wkb_owns_transformed_coordinates() {
         let wkb = sample_wkb();
         with_global_proj_engine(|engine| {
-            let source = resolve_crs(Some("EPSG:4326"))?;
-            let target = resolve_crs(Some("EPSG:3857"))?;
+            let source = resolve_crs(Some("EPSG:4326")).unwrap();
+            let target = resolve_crs(Some("EPSG:3857")).unwrap();
             let aligned = align_wkb_to_crs(
                 &wkb,
                 source.as_deref(),
@@ -188,7 +189,8 @@ mod tests {
                 "source",
                 "target",
                 engine,
-            )?;
+            )
+            .unwrap();
             assert!(matches!(aligned, Cow::Owned(_)));
             assert_ne!(aligned.as_ref(), wkb);
             Ok(())
@@ -200,7 +202,7 @@ mod tests {
     fn align_wkb_errors_when_only_one_crs_is_present() {
         let wkb = sample_wkb();
         with_global_proj_engine(|engine| {
-            let crs = resolve_crs(Some("EPSG:4326"))?;
+            let crs = resolve_crs(Some("EPSG:4326")).unwrap();
             assert!(align_wkb_to_crs(
                 &wkb,
                 crs.as_deref(),
diff --git a/rust/sedona-raster-functions/src/rs_spatial_predicates.rs b/rust/sedona-raster-functions/src/rs_spatial_predicates.rs
index e866beef2..a502ffc82 100644
--- a/rust/sedona-raster-functions/src/rs_spatial_predicates.rs
+++ b/rust/sedona-raster-functions/src/rs_spatial_predicates.rs
@@ -416,6 +416,7 @@ mod tests {
     use datafusion_expr::ScalarUDF;
     use rstest::rstest;
     use sedona_geometry::types::Edges;
+    use sedona_proj::error::SedonaProjError;
     use sedona_proj::transform::{with_global_proj_engine, LazyProjEngine};
     use sedona_raster::builder::RasterBuilder;
     use sedona_raster::traits::{BandMetadata, RasterMetadata};
@@ -539,6 +540,7 @@ mod tests {
         let rasters = generate_test_rasters(3, Some(0)).unwrap();
         let (x, y) = with_global_proj_engine(|engine| {
             crs_transform_coord((2.15, 2.75), "OGC:CRS84", "EPSG:3857", engine)
+                .map_err(|e| SedonaProjError::Invalid(e.to_string()))
         })
         .unwrap();
         let point_3857 = format!("POINT ({} {})", x, y);
diff --git a/rust/sedona-raster-gdal/src/rs_clip.rs b/rust/sedona-raster-gdal/src/rs_clip.rs
index 06b978350..78821a2b6 100644
--- a/rust/sedona-raster-gdal/src/rs_clip.rs
+++ b/rust/sedona-raster-gdal/src/rs_clip.rs
@@ -768,6 +768,7 @@ mod tests {
     use super::*;
     use arrow_array::{cast::AsArray, StructArray};
     use sedona_expr::scalar_udf::SedonaScalarKernel;
+    use sedona_proj::error::SedonaProjError;
     use sedona_proj::transform::{with_global_proj_engine, LazyProjEngine};
     use sedona_raster::array::RasterStructArray;
     use sedona_schema::crs::deserialize_crs;
@@ -941,6 +942,7 @@ mod tests {
         let geom_wkb_4326 = make_wkb("POLYGON((0 0, 2 0, 2 2, 0 2, 0 0))");
         let geom_wkb_3857 = with_global_proj_engine(|engine| {
             crs_transform_wkb(&geom_wkb_4326, crs_4326.as_ref(), crs_3857.as_ref(), engine)
+                .map_err(|e| SedonaProjError::Invalid(e.to_string()))
         })
         .unwrap();
 
@@ -1396,6 +1398,7 @@ mod tests {
         let geom_wkb_4326 = make_wkb("POLYGON((0 0, 2 0, 2 2, 0 2, 0 0))");
         let geom_wkb_3857 = with_global_proj_engine(|engine| {
             crs_transform_wkb(&geom_wkb_4326, crs_4326.as_ref(), crs_3857.as_ref(), engine)
+                .map_err(|e| SedonaProjError::Invalid(e.to_string()))
         })
         .unwrap();
 
diff --git a/rust/sedona-raster-gdal/src/rs_zonal_stats.rs b/rust/sedona-raster-gdal/src/rs_zonal_stats.rs
index a82bb8028..7e8d25a20 100644
--- a/rust/sedona-raster-gdal/src/rs_zonal_stats.rs
+++ b/rust/sedona-raster-gdal/src/rs_zonal_stats.rs
@@ -1275,6 +1275,7 @@ mod udf_tests {
     use arrow_array::types::{Float64Type, Int64Type};
     use arrow_array::{Array, StructArray};
     use datafusion_expr::ScalarUDF;
+    use sedona_proj::error::SedonaProjError;
     use sedona_proj::transform::{with_global_proj_engine, LazyProjEngine};
     use sedona_raster_functions::crs_utils::crs_transform_wkb;
     use sedona_schema::crs::deserialize_crs;
@@ -1738,6 +1739,7 @@ mod udf_tests {
         let wkb_4326 = make_wkb(LEFT_HALF);
         let wkb_3857 = with_global_proj_engine(|engine| {
             crs_transform_wkb(&wkb_4326, crs_4326.as_ref(), crs_3857.as_ref(), engine)
+                .map_err(|e| SedonaProjError::Invalid(e.to_string()))
         })
         .unwrap();
 
diff --git a/rust/sedona-spatial-join-raster/tests/spatial_join_integration.rs b/rust/sedona-spatial-join-raster/tests/spatial_join_integration.rs
index 9c72be667..102a3d171 100644
--- a/rust/sedona-spatial-join-raster/tests/spatial_join_integration.rs
+++ b/rust/sedona-spatial-join-raster/tests/spatial_join_integration.rs
@@ -51,6 +51,7 @@ use sedona_common::option::SpatialJoinOptions;
 use sedona_common::SedonaOptions;
 use sedona_geometry::transform::CrsEngine;
 use sedona_geometry::types::Edges;
+use sedona_proj::error::SedonaProjError;
 use sedona_proj::transform::{with_global_proj_engine, LazyProjEngine};
 use sedona_query_planner::{
     optimizer::register_spatial_join_logical_optimizer, query_planner::SedonaQueryPlanner,
@@ -305,16 +306,17 @@ async fn cross_crs_matches_constructed_reference() -> Result<()> {
     let ref_ring: Vec<(f64, f64)> = with_global_proj_engine(|engine| {
         let transform = engine
             .get_transform_crs_to_crs("EPSG:3857", &lnglat_crs, None, "")
-            .map_err(|e| datafusion_common::exec_datafusion_err!("{e}"))?;
+            .map_err(|e| SedonaProjError::Invalid(format!("{e}")))?;
         let mut ring = Vec::new();
         densify_footprint_ring(native_corners, &mut ring);
         for point in ring.iter_mut() {
             transform
                 .transform_coord(point)
-                .map_err(|e| datafusion_common::exec_datafusion_err!("{e}"))?;
+                .map_err(|e| SedonaProjError::Invalid(format!("{e}")))?;
         }
         Ok(ring)
-    })?;
+    })
+    .map_err(|e| datafusion_common::exec_datafusion_err!("{e}"))?;
 
     // The four reprojected corners are the densified ring's vertices at the start
     // of each edge. Test points are placed relative to these corners and the
@@ -487,11 +489,11 @@ async fn densification_catches_curved_edge_sliver() -> Result<()> {
     with_global_proj_engine(|engine| {
         let transform = engine
             .get_transform_crs_to_crs("EPSG:3857", &lnglat_crs, None, "")
-            .map_err(|e| datafusion_common::exec_datafusion_err!("{e}"))?;
+            .map_err(|e| SedonaProjError::Invalid(format!("{e}")))?;
         for corner in hull.iter_mut() {
             transform
                 .transform_coord(corner)
-                .map_err(|e| datafusion_common::exec_datafusion_err!("{e}"))?;
+                .map_err(|e| SedonaProjError::Invalid(format!("{e}")))?;
         }
         for (e, mid) in curve_mids.iter_mut().enumerate() {
             let a = native_corners[e];
@@ -499,11 +501,12 @@ async fn densification_catches_curved_edge_sliver() -> Result<()> {
             let mut m = ((a.0 + b.0) / 2.0, (a.1 + b.1) / 2.0);
             transform
                 .transform_coord(&mut m)
-                .map_err(|e| datafusion_common::exec_datafusion_err!("{e}"))?;
+                .map_err(|e| SedonaProjError::Invalid(format!("{e}")))?;
             *mid = m;
         }
         Ok(())
-    })?;
+    })
+    .map_err(|e| datafusion_common::exec_datafusion_err!("{e}"))?;
 
     let cx = hull.iter().map(|c| c.0).sum::<f64>() / 4.0;
     let cy = hull.iter().map(|c| c.1).sum::<f64>() / 4.0;