Struct CheckpointWriter 

pub struct CheckpointWriter { /* private fields */ }

Orchestrates the process of creating a checkpoint for a table.

The CheckpointWriter is the entry point for generating checkpoint data for a Delta table. It automatically selects the appropriate checkpoint format (V1/V2) based on whether the table supports the v2Checkpoints reader/writer feature.

Warning

The checkpoint data must be fully written to storage before calling CheckpointWriter::finalize. Failing to do so may result in data loss or corruption.

See Also

See the module-level documentation for the complete checkpoint workflow

Implementations

impl CheckpointWriter

pub fn checkpoint_path(&self) -> DeltaResult<Url>

Returns the URL where the checkpoint file should be written.

This method generates the checkpoint path based on the table’s root and the version of the underlying snapshot being checkpointed. The resulting path follows the classic Delta checkpoint naming convention (where the version is zero-padded to 20 digits):

<table_root>/<version>.checkpoint.parquet

For example, if the table root is s3://bucket/path and the version is 10, the checkpoint path will be: s3://bucket/path/00000000000000000010.checkpoint.parquet

pub fn checkpoint_data( &self, engine: &dyn Engine, ) -> DeltaResult<ActionReconciliationIterator>

Returns the checkpoint data to be written to the checkpoint file.

This method reads actions from the log segment, processes them for checkpoint creation, and applies stats transforms based on table properties:

• delta.checkpoint.writeStatsAsJson (default: true)
• delta.checkpoint.writeStatsAsStruct (default: false)

The returned ActionReconciliationIterator yields FilteredEngineData batches with stats transforms already applied. Use ActionReconciliationIterator::state to get the shared state for building a LastCheckpointHintStats after the iterator is exhausted.

Engine Usage

let mut checkpoint_data = writer.checkpoint_data(&engine)?;
let state = checkpoint_data.state();
while let Some(batch) = checkpoint_data.next() {
    let data = batch?.apply_selection_vector()?;
    parquet_writer.write(&data).await?;
}
drop(checkpoint_data);
let state = Arc::into_inner(state)
    .ok_or(Error::internal_error("checkpoint state Arc still has other references"))?;
let last_checkpoint_stats =
    LastCheckpointHintStats::from_reconciliation_state(state, size_in_bytes, 0)?;
writer.finalize(&engine, &last_checkpoint_stats)?;

pub fn finalize( self, engine: &dyn Engine, last_checkpoint_stats: &LastCheckpointHintStats, ) -> DeltaResult<()>

Finalizes checkpoint creation by saving metadata about the checkpoint.

Important

This method must be called only after:

1. The checkpoint data iterator has been fully exhausted
2. All data has been successfully written to object storage

Parameters

• engine: Implementation of Engine APIs.
• last_checkpoint_stats: The LastCheckpointHintStats containing fields needed to write the _last_checkpoint file.

Returns: Ok if the checkpoint was successfully finalized

Trait Implementations

impl Clone for CheckpointWriter

fn clone(&self) -> CheckpointWriter

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CheckpointWriter

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

Formats the value using the given formatter.