Struct DeltaTable 

pub struct DeltaTable {
    pub state: Option<DeltaTableState>,
    pub config: DeltaTableConfig,
    /* private fields */
}

In memory representation of a Delta Table

A DeltaTable is a purely logical concept that represents a dataset that can ewvolve over time. To attain concrete information about a table a snapshot need to be loaded. Most commonly this is the latest state of the tablem but may also loaded for a specific version or point in time.

Fields

state: Option<DeltaTableState>

The state of the table as of the most recent loaded Delta log entry.

config: DeltaTableConfig

the load options used during load

Implementations

impl DeltaTable

pub async fn try_from_url(uri: Url) -> Result<DeltaTable, DeltaTableError>

Create a new DeltaOps instance, operating on DeltaTable at given URL.

use deltalake_core::DeltaTable;
use url::Url;

async {
    let url = Url::parse("memory:///").unwrap();
    let ops = DeltaTable::try_from_url(url).await.unwrap();
};

pub async fn try_from_url_with_storage_options( uri: Url, storage_options: HashMap<String, String>, ) -> Result<DeltaTable, DeltaTableError>

Create a DeltaTable instance from URL with storage options

pub fn create(&self) -> CreateBuilder

pub fn restore(self) -> RestoreBuilder

pub fn vacuum(self) -> VacuumBuilder

Vacuum stale files from delta table

pub fn filesystem_check(self) -> FileSystemCheckBuilder

Audit active files with files present on the filesystem

pub fn add_feature(self) -> AddTableFeatureBuilder

Enable a table feature for a table

pub fn set_tbl_properties(self) -> SetTablePropertiesBuilder

Set table properties

pub fn add_columns(self) -> AddColumnBuilder

Add new columns

pub fn update_field_metadata(self) -> UpdateFieldMetadataBuilder

Update field metadata

pub fn update_table_metadata(self) -> UpdateTableMetadataBuilder

Update table metadata

pub fn generate(self) -> GenerateBuilder

Generate a symlink_format_manifest for other engines

impl DeltaTable

pub fn scan_table(&self) -> LoadBuilder

pub fn scan_cdf(self) -> CdfLoadBuilder

Load a table with CDF Enabled

pub fn write( self, batches: impl IntoIterator<Item = RecordBatch>, ) -> WriteBuilder

pub fn optimize<'a>(self) -> OptimizeBuilder<'a>

Audit active files with files present on the filesystem

pub fn delete(self) -> DeleteBuilder

Delete data from Delta table

pub fn update(self) -> UpdateBuilder

Update data from Delta table

pub fn merge<E>(self, source: DataFrame, predicate: E) -> MergeBuilder

where E: Into<Expression>,

Update data from Delta table

pub fn add_constraint(self) -> ConstraintBuilder

Add a check constraint to a table

pub fn drop_constraints(self) -> DropConstraintBuilder

Drops constraints from a table

impl DeltaTable

pub fn new(log_store: Arc<dyn LogStore>, config: DeltaTableConfig) -> DeltaTable

Create a new Delta Table struct without loading any data from backing storage.

NOTE: This is for advanced users. If you don’t know why you need to use this method, please call one of the open_table helper methods instead.

pub fn new_in_memory() -> DeltaTable

Create a new DeltaTable instance, backed by an un-initialized in memory table

Using this will not persist any changes beyond the lifetime of the table object. The main purpose of in-memory tables is for use in testing.

use deltalake_core::DeltaTable;
let table = DeltaTable::new_in_memory();

pub fn object_store(&self) -> Arc<dyn ObjectStore>

get a shared reference to the delta object store

pub async fn verify_deltatable_existence(&self) -> Result<bool, DeltaTableError>

Check if the DeltaTable exists

pub fn table_url(&self) -> &Url

The URI of the underlying data

pub fn log_store(&self) -> Arc<dyn LogStore>

get a shared reference to the log store

pub async fn get_latest_version(&self) -> Result<u64, DeltaTableError>

returns the latest available version of the table

pub fn version(&self) -> Option<u64>

Currently loaded version of the table - if any.

This will return the latest version of the table if it has been loaded. Returns None if the table has not been loaded.

pub async fn load(&mut self) -> Result<(), DeltaTableError>

Load DeltaTable with data from latest checkpoint

pub async fn update_state(&mut self) -> Result<(), DeltaTableError>

Updates the DeltaTable to the most recent state committed to the transaction log by loading the last checkpoint and incrementally applying each version since.

pub async fn update_incremental( &mut self, max_version: Option<u64>, ) -> Result<(), DeltaTableError>

Updates the DeltaTable by incrementally applying newer versions, optionally bounded by max_version.

This API is forward-only. Use DeltaTable::load_version to load an older version.

pub async fn load_version( &mut self, version: u64, ) -> Result<(), DeltaTableError>

Loads the DeltaTable state for the given version.

pub async fn history( &self, limit: Option<usize>, ) -> Result<impl Iterator<Item = CommitInfo> + use<>, DeltaTableError>

Returns provenance information, including the operation, user, and so on, for each write to a table. The table history retention is based on the logRetentionDuration property of the Delta Table, 30 days by default. If limit is given, this returns the information of the latest limit commits made to this table. Otherwise, it returns all commits from the earliest commit.

pub fn get_active_add_actions_by_partitions( &self, filters: &[PartitionFilter], ) -> Pin<Box<dyn Stream<Item = Result<LogicalFileView, DeltaTableError>> + Send + '_>>

Stream all logical files matching the provided PartitionFilters.

pub async fn get_files_by_partitions( &self, filters: &[PartitionFilter], ) -> Result<Vec<Path>, DeltaTableError>

Returns the file list tracked in current table state filtered by provided PartitionFilters.

pub async fn get_file_uris_by_partitions( &self, filters: &[PartitionFilter], ) -> Result<Vec<String>, DeltaTableError>

Return the file uris as strings for the partition(s)

pub fn get_file_uris( &self, ) -> Result<impl Iterator<Item = String>, DeltaTableError>

Returns a URIs for all active files present in the current table version.

pub fn snapshot(&self) -> Result<&DeltaTableState, DeltaTableError>

Returns the currently loaded state snapshot.

This method provides access to the currently loaded state of the Delta table.

Returns

A reference to the current state of the Delta table.

Errors

Returns NotInitialized if the table has not been initialized.

pub async fn load_with_datetime( &mut self, datetime: DateTime<Utc>, ) -> Result<(), DeltaTableError>

Time travel Delta table to the latest version that’s created at or before provided datetime argument.

Internally, this methods performs a binary search on all Delta transaction logs.

impl DeltaTable

pub fn table_provider(&self) -> TableProviderBuilder

Get a table provider for the table referenced by this DeltaTable.

See TableProviderBuilder for options when building the provider.

pub fn update_datafusion_session( &self, session: &dyn Session, ) -> Result<(), DeltaTableError>

Ensure the provided DataFusion session is prepared to read this table.

This registers the table’s root object store with the session’s RuntimeEnv if missing. Registration is idempotent and will not overwrite an existing mapping.

If the session already has an object store registered for the table’s URL but it is stale or incorrect, this method will not replace it. To override an existing mapping, call RuntimeEnv::register_object_store directly.

use datafusion::prelude::SessionContext;
use deltalake_core::{DeltaResult, DeltaTable};

let table = DeltaTable::new_in_memory();
let ctx = SessionContext::new();
let state = ctx.state();
table.update_datafusion_session(&state)?;

Trait Implementations

impl AsRef<DeltaTable> for DeltaOps

fn as_ref(&self) -> &DeltaTable

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for DeltaTable

fn clone(&self) -> DeltaTable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeltaTable

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DeltaTable

fn deserialize<D>( deserializer: D, ) -> Result<DeltaTable, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DeltaTable

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

Formats the value using the given formatter.

impl From<DeltaOps> for DeltaTable

fn from(ops: DeltaOps) -> DeltaTable

Converts to this type from the input type.

impl From<DeltaTable> for DeltaOps

fn from(table: DeltaTable) -> DeltaOps

Converts to this type from the input type.

impl Serialize for DeltaTable

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.