Struct DeltaTableBuilder 

pub struct DeltaTableBuilder { /* private fields */ }

Configures and loads one immutable Delta table snapshot.

The asynchronous path uses the caller’s Tokio runtime. Scans return a pull-driven stream and do not materialize the whole table.

Example

use delta_arrow_reader::{DeltaComparison, DeltaPredicate, DeltaScalar, DeltaTableBuilder};
use futures_util::TryStreamExt;

let table = DeltaTableBuilder::new("/tmp/example-delta-table")
    .load_table()
    .await?;
let scan = table
    .scan()
    .with_projection(["id", "name"])
    .with_predicate(DeltaPredicate::Compare {
        column: "id".into(),
        op: DeltaComparison::GtEq,
        value: DeltaScalar::Int64(10),
    })
    .with_limit(100)
    .build()
    .await?;
let mut batches = scan.into_stream();

while let Some(batch) = batches.try_next().await? {
    println!("rows={}", batch.num_rows());
}

Implementations

impl DeltaTableBuilder

pub fn new(table_location: impl Into<String>) -> Self

Creates a builder for the latest snapshot with default execution settings.

pub fn with_storage_options(self, storage_options: DeltaStorageOptions) -> Self

Replaces the storage options forwarded during table loading.

pub const fn with_snapshot_selection( self, snapshot_selection: DeltaSnapshotSelection, ) -> Self

Selects the Delta snapshot to load.

pub const fn with_execution_options( self, execution_options: DeltaScanExecutionOptions, ) -> Self

Replaces the default execution settings used by scans of this table.

pub const fn with_warmup(self, warmup: WarmupMode) -> Self

Selects work to finish during Self::load_table for reuse by later queries.

Self::load_snapshot does not build a table and rejects any setting other than WarmupMode::None.

pub async fn load_table(self) -> Result<DeltaTable, DeltaReaderError>

Loads the table through the caller-owned Tokio runtime.

With WarmupMode::None, this method loads the snapshot and converts its schema. Protocol validation and scan metadata loading remain deferred until a scan is built. This allows an application to inspect the version, schema, and protocol of a table that the reader cannot scan.

A warmup mode validates the protocol while loading because it builds reusable query-planning state. Query-planning warmup retains active-file metadata.

Errors

Returns an error if the table location, storage, snapshot, or schema cannot be loaded. A warmup can also fail if the table protocol is unsupported or its reusable metadata cannot be built.

pub async fn load_snapshot(self) -> Result<DeltaTableSnapshot, DeltaReaderError>

Loads a Delta Kernel snapshot without converting its logical Arrow schema.

Warmup settings apply to DeltaTable and are not supported by this method. Calling this method after selecting any mode other than WarmupMode::None returns a configuration error.

Errors

Returns an error if warmup was requested or if the table location, storage, or snapshot cannot be loaded.

Trait Implementations

impl Debug for DeltaTableBuilder

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

Formats the value using the given formatter.