Apache SedonaDB

libgpuspatial is a GPU-accelerated geospatial processing library designed for joining large geospatial datasets. It uses a 'Build and Stream' model:

• Build: A smaller dataset that fits into device memory and is used to construct a spatial index.
• Stream: A potentially continuous dataset that is streamed against the index to find matches.

Inputs are provided via two ArrowArray objects containing geometries in WKB (Well-Known Binary) format. Multiple geometry types can coexist within a single array.

Supported Geometries:

• Point
• LineString
• Polygon
• MultiPoint
• MultiLineString
• MultiPolygon

Supported Spatial Join Types (DE-9IM relations):

• Equals
• Disjoint
• Touches
• Contains
• Covers
• Intersects
• Within
• CoveredBy

The SedonaDB Python API is organized into several functional modules. Depending on your task, you will interact with one or more of the following namespaces:

• sedonadb.context: Likely manages the connection context or session state for SedonaDB.
• sedonadb.dataframe: Provides DataFrame-like abstractions for spatial data manipulation.
• sedonadb.dbapi: Implements the Python Database API Specification (PEP 249) for standard SQL connectivity.
• sedonadb.udf: Used for defining and registering User-Defined Functions.
• sedonadb.testing and sedonadb.raster_testing: Utilities for validating spatial and raster operations in test environments.

The geo-traits-ext crate is an extension of the geo-traits crate. It provides additional traits and implementations designed to facilitate the implementation of spatial algorithms in the geo-generic-alg crate.

Key characteristics:

• Trait-based design: Most methods are inspired by the geo-types crate but are implemented as traits for geo-traits types to enable generic programming.
• Algorithm Portability: It allows algorithms originally written for concrete geo-types to be ported to generic geo-traits-ext types more easily.
• Intermediate Results: Some methods return concrete types defined in geo-types to handle small, intermediate computational results during algorithm execution.

The sedonadb-zarr package is a mixed Rust/Python package built using maturin.

• Rust Layer: Acts as a thin PyO3 shim around sedona-raster-zarr.
• Data Interface: It exposes PyZarrChunkReader, which implements the __arrow_c_stream__ protocol, allowing efficient data transfer via the Arrow C Data Interface.

When integrating PostGIS with SedonaDB, choose your workflow based on your requirements:

• GeoPandas Approach: Best for simplicity, exploratory data analysis, and small-to-medium datasets. It uses standard SQLAlchemy and GeoPandas patterns.
• ADBC Approach: Best for large datasets, production pipelines, and performance-critical tasks. It leverages Apache Arrow for efficient, zero-copy data transfer and minimizes memory overhead by avoiding row-wise iteration.

SedonaDB uses NVIDIA GPUs to accelerate spatial joins through a two-stage execution model:

1. Filtering stage: Uses NVIDIA RT cores to quickly generate candidate geometry pairs that intersect.
2. Refining stage: Performs exact predicate checks. Point-in-polygon (PIP) pairs are accelerated using RT-core-backed ray-tracing. Other spatial join patterns run on CUDA-core kernels.

Prerequisites:

• NVIDIA CUDA 12+
• GPU with compute capability 7.5 or higher.
• A SedonaDB build with GPU support enabled.

When working with spatial data in SedonaDB, it is critical to choose the correct function for handling Coordinate Reference Systems:

1. ST_SetSRID(geometry, srid): Use this to assign an SRID to a geometry when the CRS is known but was not automatically inferred by SedonaDB. This does not change the underlying coordinate values.
2. ST_Transform(geometry, target_srid): Use this to re-project a geometry from its current CRS to a new one. This re-projects the actual coordinate values.

The memory_pool_type option determines how the memory budget is distributed among concurrent operators. This option only takes effect when memory_limit is not set to "unlimited".

• "fair" (default): Distributes memory among spillable consumers and reserves a fraction for unspillable consumers. This is more stable under memory pressure.
• "greedy": Grants memory on a first-come-first-served basis. This is simpler but can lead to reservation failures if one consumer exhausts the pool before others can reserve memory.

import sedona.db

sd = sedona.db.connect()
sd.options.memory_limit = "4gb"
sd.options.memory_pool_type = "greedy"

A Coordinate Reference System (CRS) defines how 2D map coordinates relate to real-world locations. For spatial operations like joins, distance calculations, or overlays to be accurate, all datasets must use the same CRS.

SedonaDB includes a safety feature that prevents users from performing spatial operations on datasets with mismatched CRSs. If you attempt to join two tables with different CRSs (e.g., EPSG:4326 and EPSG:3857), SedonaDB will raise a SedonaError with the message Mismatched CRS arguments: ....