Trait CommitHandler 

pub trait CommitHandler:
    Debug
    + Send
    + Sync {
    // Required method
    fn commit<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        manifest: &'life1 mut Manifest,
        indices: Option<Vec<IndexMetadata>>,
        base_path: &'life2 Path,
        object_store: &'life3 ObjectStore,
        manifest_writer: ManifestWriter,
        naming_scheme: ManifestNamingScheme,
        transaction: Option<Transaction>,
    ) -> Pin<Box<dyn Future<Output = Result<ManifestLocation, CommitError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;

    // Provided methods
    fn is_version_not_found_definitive(&self) -> bool { ... }
    fn propagate_commit_error_after_success(&self) -> bool { ... }
    fn resolve_latest_location<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        base_path: &'life1 Path,
        object_store: &'life2 ObjectStore,
    ) -> Pin<Box<dyn Future<Output = Result<ManifestLocation>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn resolve_version_location<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        base_path: &'life1 Path,
        version: u64,
        object_store: &'life2 dyn OSObjectStore,
    ) -> Pin<Box<dyn Future<Output = Result<ManifestLocation>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn version_exists<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        base_path: &'life1 Path,
        version: u64,
        object_store: &'life2 dyn OSObjectStore,
        naming_scheme: ManifestNamingScheme,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn list_detached_manifest_locations<'a>(
        &self,
        base_path: &Path,
        object_store: &'a ObjectStore,
    ) -> BoxStream<'a, Result<ManifestLocation>> { ... }
    fn list_manifest_locations<'a>(
        &self,
        base_path: &Path,
        object_store: &'a ObjectStore,
        sorted_descending: bool,
    ) -> BoxStream<'a, Result<ManifestLocation>> { ... }
    fn list_manifest_locations_since<'a>(
        &self,
        base_path: &Path,
        object_store: &'a ObjectStore,
        since_version: u64,
    ) -> BoxStream<'a, Result<ManifestLocation>> { ... }
    fn delete<'life0, 'life1, 'async_trait>(
        &'life0 self,
        _base_path: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
}

Handle commits that prevent conflicting writes.

Commit implementations ensure that if there are multiple concurrent writers attempting to write the next version of a table, only one will win. In order to work, all writers must use the same commit handler type. This trait is also responsible for resolving where the manifests live.

Required Methods

fn commit<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, manifest: &'life1 mut Manifest, indices: Option<Vec<IndexMetadata>>, base_path: &'life2 Path, object_store: &'life3 ObjectStore, manifest_writer: ManifestWriter, naming_scheme: ManifestNamingScheme, transaction: Option<Transaction>, ) -> Pin<Box<dyn Future<Output = Result<ManifestLocation, CommitError>> + Send + 'async_trait>>

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

Commit a manifest.

This function should return an CommitError::CommitConflict if another transaction has already been committed to the path.

Provided Methods

fn is_version_not_found_definitive(&self) -> bool

Whether a not-found result from Self::resolve_version_location is definitive immediately after a commit attempt.

Handlers backed by an eventually consistent or external source of truth should keep the conservative default. This prevents callers from deleting files that a newly committed manifest may reference while the manifest is not yet visible through the resolver.

fn propagate_commit_error_after_success(&self) -> bool

Whether an error should still be returned after readback proves that the manifest from the current commit attempt landed.

The conservative default preserves errors from custom handlers. Built-in object-store handlers override this because their commit errors may be ambiguous transport failures whose successful outcome is authoritative.

fn resolve_latest_location<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, base_path: &'life1 Path, object_store: &'life2 ObjectStore, ) -> Pin<Box<dyn Future<Output = Result<ManifestLocation>> + Send + 'async_trait>>

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

fn resolve_version_location<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, base_path: &'life1 Path, version: u64, object_store: &'life2 dyn OSObjectStore, ) -> Pin<Box<dyn Future<Output = Result<ManifestLocation>> + Send + 'async_trait>>

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

fn version_exists<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, base_path: &'life1 Path, version: u64, object_store: &'life2 dyn OSObjectStore, naming_scheme: ManifestNamingScheme, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

Check whether an attached manifest version exists without loading it.

The default implementation probes the deterministic manifest path for the given naming scheme. Commit handlers with an external source of truth should override this method.

fn list_detached_manifest_locations<'a>( &self, base_path: &Path, object_store: &'a ObjectStore, ) -> BoxStream<'a, Result<ManifestLocation>>

List detached manifest locations.

Returns a stream of detached manifest locations in arbitrary order.

fn list_manifest_locations<'a>( &self, base_path: &Path, object_store: &'a ObjectStore, sorted_descending: bool, ) -> BoxStream<'a, Result<ManifestLocation>>

If sorted_descending is true, the stream will yield manifests in descending order of version. When the object store has a lexicographically ordered list and the naming scheme is V2, this will use an optimized list operation. Otherwise, it will list all manifests and sort them in memory. When sorted_descending is false, the stream will yield manifests in arbitrary order.

fn list_manifest_locations_since<'a>( &self, base_path: &Path, object_store: &'a ObjectStore, since_version: u64, ) -> BoxStream<'a, Result<ManifestLocation>>

List manifest locations with version > since_version, in descending order of version.

On lexically-ordered stores this is the standard listing with early termination. On non-lexically-ordered stores (e.g. S3 Express) it uses the version hint to avoid an O(n) listing, falling back to a full listing if the hint is missing or stale.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, _base_path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Delete the recorded manifest information for a dataset at the base_path

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T: CommitLock + Send + Sync> CommitHandler for Arc<T>

where T::Lease: 'static,

fn is_version_not_found_definitive(&self) -> bool

fn propagate_commit_error_after_success(&self) -> bool

fn commit<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, manifest: &'life1 mut Manifest, indices: Option<Vec<IndexMetadata>>, base_path: &'life2 Path, object_store: &'life3 ObjectStore, manifest_writer: ManifestWriter, naming_scheme: ManifestNamingScheme, transaction: Option<Transaction>, ) -> Pin<Box<dyn Future<Output = Result<ManifestLocation, CommitError>> + Send + 'async_trait>>

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

Implementors

impl CommitHandler for ConditionalPutCommitHandler

impl CommitHandler for ExternalManifestCommitHandler

impl CommitHandler for RenameCommitHandler

impl CommitHandler for UnsafeCommitHandler

impl<T: CommitLock + Send + Sync> CommitHandler for T

where T::Lease: 'static,