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 async fn load_table(self) -> Result<DeltaTable, DeltaReaderError>

Loads table metadata and its logical Arrow schema through the caller-owned Tokio runtime.

Unsupported protocol metadata remains inspectable; scan planning validates it.

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

Loads a table and eagerly retains its active Delta scan metadata in memory.

This moves Delta log and checkpoint replay into initialization so later scans of this immutable snapshot can plan without reopening the Delta log. It increases initialization time and retains active-file metadata and statistics for the lifetime of the table. Parquet footer and data reads remain query-time operations. Load a new table to observe a newer snapshot. Unlike Self::load_table, unsupported protocols fail during initialization because materialization constructs a scan. See the scan-planning guide for measured tradeoffs.

pub async fn load_table_with_prepared_parquet_metadata( self, limits: ParquetMetadataPreparationLimits, ) -> Result<DeltaTable, DeltaReaderError>

Loads a table and prepares the Parquet metadata for every active file.

This experimental loading mode includes eager Delta scan metadata, then fetches and parses each active file’s Parquet footer and optional offset indexes. The returned table shares the prepared metadata across its streaming scans and clones. Initialization fails without returning a table if the direct Parquet backend is not selected, a resource limit is exceeded, or any file cannot be prepared.

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

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

Trait Implementations

impl Debug for DeltaTableBuilder

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

Formats the value using the given formatter.