Keep libgpuspatial only

Author: pwrliang

.github/workflows/rust-gpu.yml

@@ -216,40 +216,3 @@ jobs:
           # Build library only (skip tests - they require CUDA driver which isn't available)
           # --lib builds only the library, not test binaries
           cargo build --locked --package sedona-libgpuspatial --lib --features gpu --verbose
-
-      - name: Build GPU spatial join (with GPU feature)
-        run: |
-          echo "=== Building GPU spatial join package WITH GPU feature ==="
-          echo "Building Rust GPU spatial join (depends on libgpuspatial)"
-          echo ""
-          # Build library only (skip tests - they require CUDA driver)
-          cargo build --locked --package sedona-spatial-join-gpu --lib --features gpu --verbose
-
-      - name: Build entire workspace with GPU features
-        run: |
-          echo "=== Building entire SedonaDB workspace WITH GPU features ==="
-          echo "Verifying GPU packages integrate with rest of codebase"
-          echo ""
-          # Build entire workspace with GPU features enabled
-          # Exclude sedonadb (Python extension, requires maturin)
-          # Exclude sedona-s2geography (has GCC 11 compatibility issues, unrelated to GPU)
-          # Build libs only (skip tests - they require CUDA driver)
-          cargo build --workspace --exclude sedonadb --exclude sedona-s2geography --lib --features gpu --verbose
-
-      # GPU tests commented out - no GPU hardware on GitHub runners
-      # Uncomment these when running on self-hosted GPU runner
-
-      # - name: Test libgpuspatial
-      #   run: |
-      #     echo "Running libgpuspatial tests with GPU..."
-      #     cargo test --package sedona-libgpuspatial --features gpu -- --nocapture
-
-      # - name: Test GPU spatial join (structure tests)
-      #   run: |
-      #     echo "Running structure tests (don't require GPU execution)..."
-      #     cargo test --package sedona-spatial-join-gpu --features gpu
-
-      # - name: Test GPU functional tests (require GPU)
-      #   run: |
-      #     echo "Running GPU functional tests (require actual GPU)..."
-      #     cargo test --package sedona-spatial-join-gpu --features gpu -- --ignored --nocapture

Cargo.toml

@@ -37,31 +37,11 @@ members = [
     "rust/sedona-raster-functions",
     "rust/sedona-schema",
     "rust/sedona-spatial-join",
-    "rust/sedona-spatial-join-gpu",
     "rust/sedona-testing",
     "rust/sedona",
     "sedona-cli",
 ]
 resolver = "2"
-default-members = [
-    "c/sedona-geoarrow-c",
-    "c/sedona-geos",
-    "c/sedona-proj",
-    "c/sedona-s2geography",
-    "c/sedona-tg",
-    "r/sedonadb/src/rust",
-    "rust/sedona-adbc",
-    "rust/sedona-expr",
-    "rust/sedona-functions",
-    "rust/sedona-geo",
-    "rust/sedona-geometry",
-    "rust/sedona-geoparquet",
-    "rust/sedona-schema",
-    "rust/sedona-spatial-join",
-    "rust/sedona-testing",
-    "rust/sedona",
-    "sedona-cli",
-]
 
 [workspace.package]
 version = "0.2.0"

python/sedonadb/Cargo.toml

@@ -28,7 +28,6 @@ crate-type = ["cdylib"]
 default = ["mimalloc"]
 mimalloc = ["dep:mimalloc", "dep:libmimalloc-sys"]
 s2geography = ["sedona/s2geography"]
-gpu = ["sedona/gpu"]
 
 [dependencies]
 adbc_core = { workspace = true }

rust/sedona-common/src/option.rs

@@ -66,32 +66,6 @@ config_namespace! {
 
         /// Include tie-breakers in KNN join results when there are tied distances
         pub knn_include_tie_breakers: bool, default = false
-
-        /// GPU acceleration options
-        pub gpu: GpuOptions, default = GpuOptions::default()
-    }
-}
-
-config_namespace! {
-    /// Configuration options for GPU-accelerated spatial joins
-    pub struct GpuOptions {
-        /// Enable GPU-accelerated spatial joins (requires CUDA and GPU feature flag)
-        pub enable: bool, default = false
-
-        /// Minimum number of rows to consider GPU execution
-        pub min_rows_threshold: usize, default = 100000
-
-        /// GPU device ID to use (0 = first GPU, 1 = second, etc.)
-        pub device_id: usize, default = 0
-
-        /// Fall back to CPU if GPU initialization or execution fails
-        pub fallback_to_cpu: bool, default = true
-
-        /// Maximum GPU memory to use in megabytes (0 = unlimited)
-        pub max_memory_mb: usize, default = 0
-
-        /// Batch size for GPU processing
-        pub batch_size: usize, default = 8192
     }
 }
 

rust/sedona-functions/src/lib.rs

@@ -36,6 +36,7 @@ mod st_dwithin;
 pub mod st_envelope;
 pub mod st_envelope_aggr;
 pub mod st_flipcoordinates;
+mod st_geometryn;
 mod st_geometrytype;
 mod st_geomfromwkb;
 mod st_geomfromwkt;

rust/sedona-functions/src/register.rs

@@ -72,6 +72,7 @@ pub fn default_function_set() -> FunctionSet {
         crate::st_dwithin::st_dwithin_udf,
         crate::st_envelope::st_envelope_udf,
         crate::st_flipcoordinates::st_flipcoordinates_udf,
+        crate::st_geometryn::st_geometryn_udf,
         crate::st_geometrytype::st_geometry_type_udf,
         crate::st_geomfromwkb::st_geogfromwkb_udf,
         crate::st_geomfromwkb::st_geomfromwkb_udf,

rust/sedona-raster-functions/benches/native-raster-functions.rs

@@ -21,6 +21,12 @@ fn criterion_benchmark(c: &mut Criterion) {
     let f = sedona_raster_functions::register::default_function_set();
 
     benchmark::scalar(c, &f, "native", "rs_height", Raster(64, 64));
+    benchmark::scalar(c, &f, "native", "rs_scalex", Raster(64, 64));
+    benchmark::scalar(c, &f, "native", "rs_scaley", Raster(64, 64));
+    benchmark::scalar(c, &f, "native", "rs_skewx", Raster(64, 64));
+    benchmark::scalar(c, &f, "native", "rs_skewy", Raster(64, 64));
+    benchmark::scalar(c, &f, "native", "rs_upperleftx", Raster(64, 64));
+    benchmark::scalar(c, &f, "native", "rs_upperlefty", Raster(64, 64));
     benchmark::scalar(c, &f, "native", "rs_width", Raster(64, 64));
 }
 

rust/sedona-raster-functions/src/lib.rs

@@ -18,4 +18,5 @@
 mod executor;
 pub mod register;
 pub mod rs_example;
+pub mod rs_geotransform;
 pub mod rs_size;

rust/sedona-raster-functions/src/register.rs

@@ -39,6 +39,12 @@ pub fn default_function_set() -> FunctionSet {
     register_scalar_udfs!(
         function_set,
         crate::rs_example::rs_example_udf,
+        crate::rs_geotransform::rs_scalex_udf,
+        crate::rs_geotransform::rs_scaley_udf,
+        crate::rs_geotransform::rs_skewx_udf,
+        crate::rs_geotransform::rs_skewy_udf,
+        crate::rs_geotransform::rs_upperleftx_udf,
+        crate::rs_geotransform::rs_upperlefty_udf,
         crate::rs_size::rs_height_udf,
         crate::rs_size::rs_width_udf,
     );

rust/sedona-raster-functions/src/rs_size.rs

@@ -62,7 +62,7 @@ fn rs_width_doc() -> Documentation {
         "RS_Width(raster: Raster)".to_string(),
     )
     .with_argument("raster", "Raster: Input raster")
-    .with_sql_example("SELECT RS_Width(raster)".to_string())
+    .with_sql_example("SELECT RS_Width(RS_Example())".to_string())
     .build()
 }
 
@@ -73,7 +73,7 @@ fn rs_height_doc() -> Documentation {
         "RS_Height(raster: Raster)".to_string(),
     )
     .with_argument("raster", "Raster: Input raster")
-    .with_sql_example("SELECT RS_Height(raster)".to_string())
+    .with_sql_example("SELECT RS_Height(RS_Example())".to_string())
     .build()
 }
 
@@ -130,11 +130,13 @@ impl SedonaScalarKernel for RsSize {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use arrow_array::{Array, UInt64Array};
+    use arrow_array::UInt64Array;
     use datafusion_expr::ScalarUDF;
     use rstest::rstest;
     use sedona_schema::datatypes::RASTER;
+    use sedona_testing::compare::assert_array_equal;
     use sedona_testing::rasters::generate_test_rasters;
+    use sedona_testing::testers::ScalarUdfTester;
 
     #[test]
     fn udf_size() {
@@ -149,35 +151,21 @@ mod tests {
 
     #[rstest]
     fn udf_invoke(#[values(SizeType::Width, SizeType::Height)] st: SizeType) {
-        let kernel = RsSize {
-            size_type: st.clone(),
+        let udf = match st {
+            SizeType::Height => rs_height_udf(),
+            SizeType::Width => rs_width_udf(),
         };
-        // 3 rasters, second one is null
-        let rasters = generate_test_rasters(3, Some(1)).unwrap();
-
-        // Create the UDF and invoke it
-        let args = [ColumnarValue::Array(Arc::new(rasters))];
-        let arg_types = vec![RASTER];
-
-        let result = kernel.invoke_batch(&arg_types, &args).unwrap();
-
-        // Check the result
-        if let ColumnarValue::Array(result_array) = result {
-            let size_array = result_array.as_any().downcast_ref::<UInt64Array>().unwrap();
+        let tester = ScalarUdfTester::new(udf.into(), vec![RASTER]);
 
-            assert_eq!(size_array.len(), 3);
+        let rasters = generate_test_rasters(3, Some(1)).unwrap();
+        let expected_values = match st {
+            SizeType::Height => vec![Some(2), None, Some(4)],
+            SizeType::Width => vec![Some(1), None, Some(3)],
+        };
+        let expected: Arc<dyn arrow_array::Array> = Arc::new(UInt64Array::from(expected_values));
 
-            match st.clone() {
-                SizeType::Width => assert_eq!(size_array.value(0), 1), // First raster width
-                SizeType::Height => assert_eq!(size_array.value(0), 2), // First raster height
-            }
-            assert!(size_array.is_null(1)); // Second raster is null
-            match st.clone() {
-                SizeType::Width => assert_eq!(size_array.value(2), 3), // Third raster width
-                SizeType::Height => assert_eq!(size_array.value(2), 4), // Third raster height
-            }
-        } else {
-            panic!("Expected array result");
-        }
+        // Check scalars
+        let result = tester.invoke_array(Arc::new(rasters)).unwrap();
+        assert_array_equal(&result, &expected);
     }
 }