deps: update geoarrow-rs (#708)

## Notes:

- geoarrow-rs no longer has `Table` or `ChunkedArray` concepts. This is
for symmetry with upstream `arrow`, to nudge people to use iterators
(especially `RecordBatchReader`) as much as possible, simplicity and
maintenance, and because I think higher-level libraries like DataFusion
will take care of the "table" case. I think for now, if you need a
"table" construct, it's best to have a struct wrapping
`(Vec<RecordBatch>, Arc<Schema>)` yourself.
- 


## Closes

- List any issues that this pull request closes
- Delete this section if it is not applicable

## Related to

- List any issues that this pull request is related to
- Delete this section if it is not applicable

## Description

Description of the changes, including any "sidecar" changes that came
along (e.g. small bugfixes you found along the way).

## Checklist

Delete any checklist items that do not apply (e.g. if your change is
minor, it may not require documentation updates).

- [ ] Unit tests
- [ ] Documentation, including doctests
- [ ] Git history is linear
- [ ] Commit messages are descriptive
- [ ] (optional) Git commit messages follow [conventional
commits](https://www.conventionalcommits.org/en/v1.0.0/)
- [ ] Code is formatted (`cargo fmt`)
- [ ] `cargo test`
- [ ] Changes are added to the CHANGELOG

<!-- markdownlint-disable-file MD041 -->

---------

Co-authored-by: Pete Gadomski <[email protected]>

Author: kylebarron

.github/workflows/docs.yml renamed to .github/workflows/cd.yml

@@ -1,12 +1,13 @@
-name: Docs
+name: CD
 
 on:
   push:
     branches:
-      - "main"
+      - main
 
 jobs:
-  build:
+  build-docs:
+    name: Build docs
     runs-on: ubuntu-latest
     env:
       GIT_COMMITTER_NAME: ci-bot
@@ -22,8 +23,9 @@ jobs:
         id: deployment
         with:
           path: site/
-  deploy:
-    needs: build
+  deploy-docs:
+    needs: build-docs
+    name: Deploy docs
     permissions:
       pages: write
       id-token: write
@@ -34,3 +36,18 @@ jobs:
     steps:
       - uses: actions/deploy-pages@v4
         id: deployment
+  coverage:
+    name: Coverage
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: Swatinem/rust-cache@v2
+      - name: Install tarpaulin
+        run: cargo install cargo-tarpaulin
+      - name: Test w/ coverage
+        run: cargo tarpaulin -p stac -p stac-api --all-features --out xml
+      - uses: codecov/codecov-action@v5
+        with:
+          files: ./cobertura.xml
+          token: ${{ secrets.CODECOV_TOKEN }}
+          fail_ci_if_error: true

.github/workflows/ci.yml

@@ -31,21 +31,6 @@ jobs:
       - uses: Swatinem/rust-cache@v2
       - name: Test
         run: cargo test -p stac --all-features
-  coverage:
-    name: Coverage
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: Swatinem/rust-cache@v2
-      - name: Install tarpaulin
-        run: cargo install cargo-tarpaulin
-      - name: Test w/ coverage
-        run: cargo tarpaulin -p stac -p stac-api --all-features --out xml
-      - uses: codecov/codecov-action@v5
-        with:
-          files: ./cobertura.xml
-          token: ${{ secrets.CODECOV_TOKEN }}
-          fail_ci_if_error: true
   check-features-core:
     name: Check all features
     runs-on: ubuntu-latest

Cargo.toml

@@ -29,7 +29,10 @@ rust-version = "1.85"
 
 [workspace.dependencies]
 anyhow = "1.0"
-arrow = "54.2.1"
+arrow-array = "55.0.0"
+arrow-cast = "55.0.0"
+arrow-json = "55.0.0"
+arrow-schema = "55.0.0"
 assert-json-diff = "2.0"
 assert_cmd = "2.0"
 async-stream = "0.3.6"
@@ -40,12 +43,15 @@ bytes = "1.7"
 chrono = "0.4.39"
 clap = "4.5"
 cql2 = "0.3.7-beta.0"
-duckdb = "1.2.1"
+duckdb = "1.2.2"
 fluent-uri = "0.3.2"
 futures = "0.3.31"
-geo = "0.29.0"
+geo = "0.30.0"
+geo-traits = "0.2"
 geo-types = "0.7.15"
-geoarrow = "0.4.0-beta.4"
+geoarrow-array = { git = "https://github.com/geoarrow/geoarrow-rs/", rev = "17bf33e4cf78b060afa08ca9560dc4efd73c2c76" }
+geoarrow-geoparquet = { git = "https://github.com/geoarrow/geoarrow-rs/", rev = "17bf33e4cf78b060afa08ca9560dc4efd73c2c76" }
+geoarrow-schema = { git = "https://github.com/geoarrow/geoarrow-rs/", rev = "17bf33e4cf78b060afa08ca9560dc4efd73c2c76" }
 geojson = "0.24.1"
 http = "1.1"
 indexmap = { version = "2.9.0", features = ["serde"] }
@@ -55,7 +61,7 @@ log = "0.4.25"
 mime = "0.3.17"
 mockito = "1.5"
 object_store = "0.12.0"
-parquet = { version = "54.2.1", default-features = false }
+parquet = { version = "55.0.0", default-features = false }
 pgstac = { version = "0.3.0", path = "crates/pgstac" }
 quote = "1.0"
 reqwest = { version = "0.12.8", default-features = false, features = [
@@ -91,6 +97,4 @@ url = "2.3"
 webpki-roots = "0.26.8"
 
 [patch.crates-io]
-# TODO unpatch cql2 when we upgrade geoarrow to use geo v0.30
-cql2 = { git = "https://github.com/gadomski/cql2-rs", branch = "geo-v0.29" }
-geoarrow = { git = "https://github.com/geoarrow/geoarrow-rs/", rev = "2cd0d623e4b9f1ac3bc5ff6563ccce689a47c641" }
+duckdb = { git = "https://github.com/gadomski/duckdb-rs/", branch = "arrow-v55" }

crates/core/Cargo.toml

@@ -13,17 +13,18 @@ rust-version.workspace = true
 
 [features]
 geo = ["dep:geo"]
-geoarrow = ["dep:geoarrow", "dep:arrow", "dep:geo-types"]
-geoparquet = ["geoarrow", "geoarrow/parquet", "dep:parquet"]
-geoparquet-compression = [
-    "geoparquet",
-    "geoarrow/parquet_compression",
-    "parquet/snap",
-    "parquet/brotli",
-    "parquet/flate2",
-    "parquet/lz4",
-    "parquet/zstd",
+geoarrow = [
+    "dep:geoarrow-array",
+    "dep:geoarrow-schema",
+    "dep:arrow-array",
+    "dep:arrow-cast",
+    "dep:arrow-json",
+    "dep:arrow-schema",
+    "dep:geo-traits",
+    "dep:geo-types",
 ]
+geoparquet = ["geoarrow", "dep:geoarrow-geoparquet", "dep:parquet"]
+geoparquet-compression = ["geoparquet", "geoarrow-geoparquet/compression"]
 object-store = ["dep:object_store", "dep:tokio"]
 object-store-aws = ["object-store", "object_store/aws"]
 object-store-azure = ["object-store", "object_store/azure"]
@@ -39,13 +40,19 @@ reqwest = ["dep:reqwest"]
 validate = ["dep:jsonschema", "dep:fluent-uri", "reqwest"]
 
 [dependencies]
-arrow = { workspace = true, optional = true }
+arrow-array = { workspace = true, optional = true, features = ["chrono-tz"] }
+arrow-cast = { workspace = true, optional = true }
+arrow-json = { workspace = true, optional = true }
+arrow-schema = { workspace = true, optional = true }
 bytes.workspace = true
 chrono = { workspace = true, features = ["serde"] }
 fluent-uri = { workspace = true, optional = true }
 geo = { workspace = true, optional = true }
+geo-traits = { workspace = true, optional = true }
 geo-types = { workspace = true, optional = true }
-geoarrow = { workspace = true, optional = true }
+geoarrow-array = { workspace = true, optional = true }
+geoarrow-geoparquet = { workspace = true, optional = true }
+geoarrow-schema = { workspace = true, optional = true }
 geojson.workspace = true
 indexmap.workspace = true
 jsonschema = { workspace = true, optional = true, features = ["resolve-http"] }

crates/core/src/error.rs

@@ -5,10 +5,10 @@ use thiserror::Error;
 #[derive(Error, Debug)]
 #[non_exhaustive]
 pub enum Error {
-    /// [arrow::error::ArrowError]
+    /// [arrow_schema::ArrowError]
     #[error(transparent)]
     #[cfg(feature = "geoarrow")]
-    Arrow(#[from] arrow::error::ArrowError),
+    Arrow(#[from] arrow_schema::ArrowError),
 
     /// [chrono::ParseError]
     #[error(transparent)]
@@ -34,10 +34,10 @@ pub enum Error {
         path: String,
     },
 
-    /// [geoarrow::error::GeoArrowError]
+    /// [geoarrow_array::error::GeoArrowError]
     #[error(transparent)]
     #[cfg(feature = "geoarrow")]
-    GeoArrow(#[from] geoarrow::error::GeoArrowError),
+    GeoArrow(#[from] geoarrow_array::error::GeoArrowError),
 
     /// [geojson::Error]
     #[error(transparent)]

crates/core/src/geoarrow/json.rs

@@ -38,12 +38,18 @@ const TOP_LEVEL_KEYS: [&str; 10] = [
     "collection",
 ];
 
-use arrow::array::{cast::*, types::*, *};
-use arrow::datatypes::*;
-use arrow::error::ArrowError;
-use arrow::json::JsonSerializable;
-use arrow::util::display::{ArrayFormatter, FormatOptions};
-use geoarrow::table::Table;
+use arrow_array::RecordBatchReader;
+use arrow_array::{cast::*, types::*, *};
+use arrow_cast::display::{ArrayFormatter, FormatOptions};
+use arrow_json::JsonSerializable;
+use arrow_schema::*;
+use geo_traits::to_geo::{
+    ToGeoGeometry, ToGeoGeometryCollection, ToGeoLineString, ToGeoMultiLineString, ToGeoMultiPoint,
+    ToGeoMultiPolygon, ToGeoPoint, ToGeoPolygon, ToGeoRect,
+};
+use geoarrow_array::ArrayAccessor;
+use geoarrow_array::array::from_arrow_array;
+use geoarrow_array::cast::AsGeoArrowArray;
 use serde_json::{Value, json, map::Map as JsonMap};
 use std::iter;
 
@@ -365,7 +371,7 @@ fn set_column_for_json_rows(
                 })?;
         }
         DataType::Dictionary(_, value_type) => {
-            let hydrated = arrow::compute::cast(&array, value_type)
+            let hydrated = arrow_cast::cast(&array, value_type)
                 .expect("cannot cast dictionary to underlying values");
             set_column_for_json_rows(rows, &hydrated, col_name, explicit_nulls)?;
         }
@@ -418,40 +424,63 @@ fn set_column_for_json_rows(
     Ok(())
 }
 
-/// Converts a table to json rows.
-pub fn from_table(table: Table) -> Result<Vec<serde_json::Map<String, Value>>, crate::Error> {
-    use geoarrow::{array::AsNativeArray, datatypes::NativeType::*, trait_::ArrayAccessor};
-    use geojson::Value;
+/// Creates JSON values from a record batch reader.
+pub fn from_record_batch_reader<R: RecordBatchReader>(
+    reader: R,
+) -> Result<Vec<serde_json::Map<String, Value>>, crate::Error> {
+    use geoarrow_array::GeoArrowType;
 
-    let index = table
-        .schema()
-        .column_with_name("geometry")
-        .map(|(index, _)| index);
-    let mut json_rows = record_batches_to_json_rows(table.batches(), index)?;
+    let schema = reader.schema();
+    let geometry_index = schema.column_with_name("geometry").map(|(index, _)| index);
+
+    // For now we collect all batches into memory, but in the future we could iterate on the stream
+    // directly.
+    let batches = reader.collect::<Result<Vec<_>, _>>()?;
+    let mut json_rows = record_batches_to_json_rows(&batches, geometry_index)?;
     let mut items = Vec::new();
-    if let Some(index) = index {
-        for chunk in table.geometry_column(Some(index))?.geometry_chunks() {
+    if let Some(index) = geometry_index {
+        let field = schema.field(index);
+        for batch in &batches {
+            let array = batch.column(index);
+            let chunk = from_arrow_array(array, field)?;
             for i in 0..chunk.len() {
+                use GeoArrowType::*;
                 let value = match chunk.data_type() {
-                    Point(_, _) => Value::from(&chunk.as_ref().as_point().value_as_geo(i)),
-                    LineString(_, _) => {
-                        Value::from(&chunk.as_ref().as_line_string().value_as_geo(i))
+                    Point(_) => geojson::Value::from(&chunk.as_point().value(i)?.to_point()),
+                    LineString(_) => {
+                        geojson::Value::from(&chunk.as_line_string().value(i)?.to_line_string())
+                    }
+                    Polygon(_) => geojson::Value::from(&chunk.as_polygon().value(i)?.to_polygon()),
+                    MultiPoint(_) => {
+                        geojson::Value::from(&chunk.as_multi_point().value(i)?.to_multi_point())
                     }
-                    Polygon(_, _) => Value::from(&chunk.as_ref().as_polygon().value_as_geo(i)),
-                    MultiPoint(_, _) => {
-                        Value::from(&chunk.as_ref().as_multi_point().value_as_geo(i))
+                    MultiLineString(_) => geojson::Value::from(
+                        &chunk
+                            .as_multi_line_string()
+                            .value(i)?
+                            .to_multi_line_string(),
+                    ),
+                    MultiPolygon(_) => {
+                        geojson::Value::from(&chunk.as_multi_polygon().value(i)?.to_multi_polygon())
                     }
-                    MultiLineString(_, _) => {
-                        Value::from(&chunk.as_ref().as_multi_line_string().value_as_geo(i))
+                    Geometry(_) => {
+                        geojson::Value::from(&chunk.as_geometry().value(i)?.to_geometry())
                     }
-                    MultiPolygon(_, _) => {
-                        Value::from(&chunk.as_ref().as_multi_polygon().value_as_geo(i))
+                    GeometryCollection(_) => geojson::Value::from(
+                        &chunk
+                            .as_geometry_collection()
+                            .value(i)?
+                            .to_geometry_collection(),
+                    ),
+                    Rect(_) => geojson::Value::from(&chunk.as_rect().value(i)?.to_rect()),
+                    Wkb(_) => geojson::Value::from(&chunk.as_wkb::<i32>().value(i)?.to_geometry()),
+                    LargeWkb(_) => {
+                        geojson::Value::from(&chunk.as_wkb::<i64>().value(i)?.to_geometry())
                     }
-                    Geometry(_) => Value::from(&chunk.as_ref().as_geometry().value_as_geo(i)),
-                    GeometryCollection(_, _) => {
-                        Value::from(&chunk.as_ref().as_geometry_collection().value_as_geo(i))
+                    Wkt(_) => geojson::Value::from(&chunk.as_wkt::<i32>().value(i)?.to_geometry()),
+                    LargeWkt(_) => {
+                        geojson::Value::from(&chunk.as_wkt::<i64>().value(i)?.to_geometry())
                     }
-                    Rect(_) => Value::from(&chunk.as_ref().as_rect().value_as_geo(i)),
                 };
                 let mut row = json_rows
                     .next()