Struct ZarrTable 

pub struct ZarrTable { /* private fields */ }

Implementations

impl ZarrTable

pub fn new(schema: SchemaRef, path: impl Into<String>) -> Self

pub fn with_metadata( schema: SchemaRef, path: impl Into<String>, metadata: ZarrStoreMeta, ) -> Self

Create a ZarrTable with store metadata (for local paths)

Examples found in repository

examples/query_era5.rs (line 29)

async fn main() -> datafusion::error::Result<()> {
    common::init_tracing();
    let ctx = common::create_local_context();

    // Load ERA5 data from Zarr v3 store with metadata for statistics
    let store_path = "data/era5_v3.zarr";
    let (schema, metadata) = infer_schema_with_meta(store_path).expect("Failed to infer schema");
    let schema = Arc::new(schema);

    println!("ERA5 Schema:");
    for field in schema.fields() {
        println!("  {}: {:?}", field.name(), field.data_type());
    }
    println!("Total rows: {}", metadata.total_rows);

    let table = Arc::new(ZarrTable::with_metadata(schema, store_path, metadata));
    ctx.register_table("era5", table)?;

    // Query 1: Sample data overview
    common::run_query(
        &ctx,
        "Sample ERA5 data (first 10 rows):",
        "SELECT * FROM era5 LIMIT 10",
    )
    .await?;

    // Query 2: Average temperature by hybrid level (pressure level)
    common::run_query(
        &ctx,
        "Average temperature by hybrid level:",
        "SELECT hybrid,
                AVG(temperature) as avg_temp,
                MIN(temperature) as min_temp,
                MAX(temperature) as max_temp
         FROM era5
         GROUP BY hybrid
         ORDER BY hybrid",
    )
    .await?;

    // Query 3: Count (optimized - uses statistics)
    common::run_query(
        &ctx,
        "Total rows (optimized - uses statistics, no data scan):",
        "SELECT COUNT(*) as total FROM era5",
    )
    .await?;

    Ok(())
}

examples/query_synthetic.rs (line 33)

async fn main() -> datafusion::error::Result<()> {
    common::init_tracing();
    let ctx = common::create_local_context();

    // Load synthetic weather data (Zarr v3) with metadata for statistics
    let store_path = "data/synthetic_v3.zarr";
    let (schema, metadata) = infer_schema_with_meta(store_path).expect("Failed to infer schema");
    let schema = Arc::new(schema);

    println!("Synthetic Weather Data Schema:");
    for field in schema.fields() {
        println!("  {}: {:?}", field.name(), field.data_type());
    }
    println!("Total rows: {}", metadata.total_rows);

    let table = Arc::new(ZarrTable::with_metadata(schema, store_path, metadata));
    ctx.register_table("synthetic", table)?;

    common::run_query(
        &ctx,
        "Sample data (first 10 rows):",
        "SELECT * FROM synthetic LIMIT 10",
    )
    .await?;

    common::run_query(
        &ctx,
        "Filtered data (temperature > 5):",
        "SELECT time, lat, lon, temperature FROM synthetic WHERE temperature > 5 LIMIT 10",
    )
    .await?;

    common::run_query(
        &ctx,
        "Average temperature per day:",
        "SELECT time, AVG(temperature) as avg_temp FROM synthetic GROUP BY time ORDER BY time",
    )
    .await?;

    common::run_query(
        &ctx,
        "Total rows (optimized - uses statistics, no data scan):",
        "SELECT COUNT(temperature) as total FROM synthetic",
    )
    .await?;

    common::run_query(
        &ctx,
        "Coordinate bounds (optimized - uses statistics, no data scan):",
        "SELECT MIN(lat) as lat_min, MAX(lat) as lat_max, MIN(lon) as lon_min, MAX(lon) as lon_max FROM synthetic",
    )
    .await?;

    Ok(())
}

pub fn with_cached_remote( schema: SchemaRef, path: impl Into<String>, store: AsyncReadableListableStorage, prefix: ObjectPath, metadata: ZarrStoreMeta, ) -> Self

Create a ZarrTable with a cached async store and metadata (for remote URLs)

Trait Implementations

impl Debug for ZarrTable

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl TableProvider for ZarrTable

fn supports_filters_pushdown( &self, filters: &[&Expr], ) -> Result<Vec<TableProviderFilterPushDown>>

Indicate which filters can be pushed down to the scan

Returns Inexact for all filters - we’ll handle coordinate equality filters during scan, but DataFusion should still apply filters post-scan for correctness (in case we miss any).

fn statistics(&self) -> Option<Statistics>

Return statistics for this table

This enables DataFusion’s optimizer to convert count(*) and count(column) queries into constant values without scanning the data.

For coordinate columns, we also provide:

• min_value/max_value: Enables MIN(coord)/MAX(coord) optimization
• distinct_count: Number of unique coordinate values

fn as_any(&self) -> &dyn Any

Returns the table provider as Any so that it can be downcast to a specific implementation.

fn schema(&self) -> SchemaRef

Get a reference to the schema for this table

fn table_type(&self) -> TableType

Get the type of this table for metadata/catalog purposes.

fn scan<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _state: &'life1 dyn Session, projection: Option<&'life2 Vec<usize>>, filters: &'life3 [Expr], limit: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn ExecutionPlan>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Create an ExecutionPlan for scanning the table with optionally specified projection, filter and limit, described below.

fn constraints(&self) -> Option<&Constraints>

Get a reference to the constraints of the table. Returns:

fn get_table_definition(&self) -> Option<&str>

Get the create statement used to create this table, if available.

fn get_logical_plan(&self) -> Option<Cow<'_, LogicalPlan>>

Get the LogicalPlan of this table, if available.

fn get_column_default(&self, _column: &str) -> Option<&Expr>

Get the default value for a column, if available.

fn scan_with_args<'a, 'life0, 'life1, 'async_trait>( &'life0 self, state: &'life1 dyn Session, args: ScanArgs<'a>, ) -> Pin<Box<dyn Future<Output = Result<ScanResult, DataFusionError>> + Send + 'async_trait>>

where 'a: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Create an ExecutionPlan for scanning the table using structured arguments.

fn insert_into<'life0, 'life1, 'async_trait>( &'life0 self, _state: &'life1 dyn Session, _input: Arc<dyn ExecutionPlan>, _insert_op: InsertOp, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn ExecutionPlan>, DataFusionError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Return an ExecutionPlan to insert data into this table, if supported.