feat(raster-zarr): sedona-raster-zarr crate + sedona-zarr plugin

Cargo.toml

@@ -39,6 +39,7 @@ members = [
     "rust/sedona-raster",
     "rust/sedona-raster-functions",
     "rust/sedona-raster-gdal",
+    "rust/sedona-raster-zarr",
     "rust/sedona-schema",
     "rust/sedona-spatial-join",
     "rust/sedona-spatial-join-geography",
@@ -133,6 +134,9 @@ tokio = { version = "1.52", features = ["macros", "rt", "sync"] }
 url = "2.5.7"
 wkb = "0.9.2"
 wkt = "0.14.0"
+zarrs = { version = "0.23", default-features = false }
+zarrs_filesystem = "0.3"
+zarrs_object_store = "0.6"
 
 # Workspace path dependencies for internal crates
 sedona = { version = "0.4.0", path = "rust/sedona" }
@@ -150,6 +154,7 @@ sedona-pointcloud = { version = "0.4.0", path = "rust/sedona-pointcloud" }
 sedona-raster = { version = "0.4.0", path = "rust/sedona-raster" }
 sedona-raster-functions = { version = "0.4.0", path = "rust/sedona-raster-functions" }
 sedona-raster-gdal = { version = "0.4.0", path = "rust/sedona-raster-gdal" }
+sedona-raster-zarr = { version = "0.4.0", path = "rust/sedona-raster-zarr" }
 sedona-schema = { version = "0.4.0", path = "rust/sedona-schema" }
 sedona-spatial-join = { version = "0.4.0", path = "rust/sedona-spatial-join" }
 sedona-spatial-join-gpu = { version = "0.4.0", path = "rust/sedona-spatial-join-gpu" }

python/sedonadb/python/sedonadb/functions/table.py

@@ -16,7 +16,7 @@
 # under the License.
 
 import json
-from typing import Optional, Literal, Union, Tuple, Iterable
+from typing import Optional, Literal, Union, Tuple, Iterable, List
 
 from sedonadb.dataframe import DataFrame
 from sedonadb.utility import sedona  # noqa: F401
@@ -112,3 +112,68 @@ def sd_random_geometry(
         args = {k: v for k, v in args.items() if v is not None}
 
         return self._ctx.sql(f"SELECT * FROM sd_random_geometry('{json.dumps(args)}')")
+
+    def sd_read_zarr(
+        self,
+        uri: str,
+        *,
+        indb: Optional[bool] = None,
+        rows_per_batch: Optional[int] = None,
+        num_partitions: Optional[int] = None,
+        arrays: Optional[List[str]] = None,
+    ) -> DataFrame:
+        """
+        Read a Zarr group as a DataFrame of N-D rasters.
+
+        Returns a single-column DataFrame ``raster: Raster`` with one row per
+        chunk position in the Zarr group's chunk grid. Each row's bands are
+        the corresponding chunks of each array in the group. All ``RS_*``
+        UDFs operate on the column unchanged.
+
+        Only local filesystem stores are supported (``file://`` URIs or
+        bare paths).
+
+        Parameters
+        ----------
+        uri : str
+            Zarr group URI. ``file:///path/to/foo.zarr`` or a bare local path.
+        indb : bool, optional
+            ``True`` (default) materializes every chunk's bytes into the
+            Arrow ``data`` column eagerly. ``False`` emits chunk-anchor
+            URIs only; byte resolution depends on the OutDb resolver
+            being registered (follow-up PR).
+        rows_per_batch : int, optional
+            Chunks per ``RecordBatch`` (default 1024).
+        num_partitions : int, optional
+            Scan partitions. Only ``1`` is supported; ``> 1`` errors.
+        arrays : list of str, optional
+            Names of arrays in the group to read. By default every
+            multi-dimensional array is read; 1-D arrays (typical xarray
+            coord variables) are auto-skipped. Passing an explicit list
+            reads exactly those arrays. 1-D arrays are always rejected
+            (a raster band needs at least 2 dimensions); naming one
+            explicitly errors. Unknown names also error.
+
+        Examples
+        --------
+        >>> sd = sedona.db.connect()
+        >>> sd.funcs.table.sd_read_zarr("file:///path/to/datacube.zarr")  # doctest: +SKIP
+        >>> sd.funcs.table.sd_read_zarr(
+        ...     "file:///path/to/datacube.zarr",
+        ...     arrays=["temperature", "pressure"],
+        ... )  # doctest: +SKIP
+        """
+
+        args = {
+            "indb": indb,
+            "rows_per_batch": rows_per_batch,
+            "num_partitions": num_partitions,
+            "arrays": arrays,
+        }
+        args = {k: v for k, v in args.items() if v is not None}
+
+        if args:
+            return self._ctx.sql(
+                f"SELECT * FROM sd_read_zarr('{uri}', '{json.dumps(args)}')"
+            )
+        return self._ctx.sql(f"SELECT * FROM sd_read_zarr('{uri}')")

python/sedonadb/tests/test_funcs.py

@@ -24,3 +24,35 @@ def test_random_geometry(con):
 
     # Ensure the output is reproducible
     assert df.to_arrow_table() == df.to_arrow_table()
+
+
+def test_read_zarr(con, tmp_path):
+    # Skip cleanly if the optional `zarr` Python lib isn't installed —
+    # the binding is exercised by the Rust-side integration tests; this
+    # test only verifies the Python wrapper threads arguments through.
+    import pytest
+
+    zarr = pytest.importorskip("zarr")
+    np = pytest.importorskip("numpy")
+
+    # Build a 2x2 UInt8 array with two chunks, dim_names=["y","x"], inside
+    # a group at the temp path. Matches the minimal shape sd_read_zarr
+    # expects (2-D array with [y, x] suffix).
+    root = zarr.open_group(str(tmp_path), mode="w")
+    arr = root.create_array(
+        "temperature",
+        shape=(2, 2),
+        chunks=(1, 2),
+        dtype="uint8",
+        dimension_names=["y", "x"],
+    )
+    arr[:] = np.array([[10, 11], [20, 21]], dtype=np.uint8)
+
+    # Default-mode (InDb) read — every chunk materialized into the
+    # Arrow `data` column.
+    df = con.funcs.table.sd_read_zarr(f"file://{tmp_path}")
+    assert df.count() == 2
+
+    # Options thread through: rows_per_batch slices the output.
+    df = con.funcs.table.sd_read_zarr(f"file://{tmp_path}", rows_per_batch=1)
+    assert df.count() == 2

rust/sedona-raster-zarr/Cargo.toml

@@ -0,0 +1,53 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+[package]
+name = "sedona-raster-zarr"
+version.workspace = true
+license.workspace = true
+keywords.workspace = true
+categories.workspace = true
+homepage.workspace = true
+repository.workspace = true
+description.workspace = true
+readme.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[lints.clippy]
+result_large_err = "allow"
+
+[dependencies]
+arrow-array = { workspace = true }
+arrow-schema = { workspace = true }
+datafusion-common = { workspace = true }
+log = { workspace = true }
+sedona-common = { workspace = true }
+sedona-raster = { workspace = true }
+sedona-schema = { workspace = true }
+serde_json = { workspace = true }
+zarrs = { workspace = true, features = ["filesystem", "gzip", "zstd", "crc32c", "sharding", "transpose"] }
+zarrs_filesystem = { workspace = true }
+
+# `blosc` is gated off Windows: c-blosc (statically linked) bundles its own
+# `pthread_create` / `pthread_cond_*` symbols, which conflict with rtools45's
+# `libpthread.a` during the MinGW link of the R `sedonadb.dll`. Non-Windows
+# targets get the full blosc-compressed Zarr reading capability.
+[target.'cfg(not(target_os = "windows"))'.dependencies]
+zarrs = { workspace = true, features = ["blosc"] }
+
+[dev-dependencies]
+tempfile = { workspace = true }

rust/sedona-raster-zarr/src/dtype.rs

@@ -0,0 +1,66 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+//! Mapping between Zarr datatypes and SedonaDB's `BandDataType`.
+//!
+//! zarrs 0.23 models `DataType` as a wrapper around `Arc<dyn DataTypeTraits>`,
+//! so we discriminate via the type-erased `is::<T>()` check rather than
+//! pattern-matching an enum.
+
+use arrow_schema::ArrowError;
+use sedona_schema::raster::BandDataType;
+use zarrs::array::data_type::{
+    BoolDataType, Float32DataType, Float64DataType, Int16DataType, Int32DataType, Int64DataType,
+    Int8DataType, UInt16DataType, UInt32DataType, UInt64DataType, UInt8DataType,
+};
+use zarrs::array::DataType as ZarrDataType;
+
+/// Map a Zarr `DataType` to a SedonaDB `BandDataType`.
+///
+/// Bool maps to UInt8 losslessly (Zarr packs bools to one byte each, matching
+/// our representation). Variable-length, complex, and extended-precision
+/// types error with `NotYetImplemented` — they have no numeric counterpart
+/// in `BandDataType` today.
+pub fn zarr_to_band_data_type(dt: &ZarrDataType) -> Result<BandDataType, ArrowError> {
+    if dt.is::<BoolDataType>() {
+        Ok(BandDataType::UInt8)
+    } else if dt.is::<Int8DataType>() {
+        Ok(BandDataType::Int8)
+    } else if dt.is::<UInt8DataType>() {
+        Ok(BandDataType::UInt8)
+    } else if dt.is::<Int16DataType>() {
+        Ok(BandDataType::Int16)
+    } else if dt.is::<UInt16DataType>() {
+        Ok(BandDataType::UInt16)
+    } else if dt.is::<Int32DataType>() {
+        Ok(BandDataType::Int32)
+    } else if dt.is::<UInt32DataType>() {
+        Ok(BandDataType::UInt32)
+    } else if dt.is::<Int64DataType>() {
+        Ok(BandDataType::Int64)
+    } else if dt.is::<UInt64DataType>() {
+        Ok(BandDataType::UInt64)
+    } else if dt.is::<Float32DataType>() {
+        Ok(BandDataType::Float32)
+    } else if dt.is::<Float64DataType>() {
+        Ok(BandDataType::Float64)
+    } else {
+        Err(ArrowError::NotYetImplemented(format!(
+            "Zarr datatype {dt:?} has no BandDataType mapping yet"
+        )))
+    }
+}