Trait TableStorage 

pub trait TableStorage:
    Sealed
    + Send
    + Sync
    + Debug {
    // Required methods
    fn open_snapshot_at_entry<'life0, 'life1, 'async_trait>(
        &'life0 self,
        entry: &'life1 SubTableEntry,
    ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn open_snapshot_at_table<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 Snapshot,
        table_key: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn open_dataset_head<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dataset_uri: &'life1 str,
        branch: Option<&'life2 str>,
    ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn open_dataset_head_for_write<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        table_key: &'life1 str,
        dataset_uri: &'life2 str,
        branch: Option<&'life3 str>,
    ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn open_dataset_at_state<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        table_path: &'life1 str,
        branch: Option<&'life2 str>,
        version: u64,
    ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn fork_branch_from_state<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        dataset_uri: &'life1 str,
        source_branch: Option<&'life2 str>,
        table_key: &'life3 str,
        source_version: u64,
        target_branch: &'life4 str,
    ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn delete_branch<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dataset_uri: &'life1 str,
        branch: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn reopen_for_mutation<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        dataset_uri: &'life1 str,
        branch: Option<&'life2 str>,
        table_key: &'life3 str,
        expected_version: u64,
    ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn ensure_expected_version(
        &self,
        snapshot: &SnapshotHandle,
        table_key: &str,
        expected_version: u64,
    ) -> Result<()>;
    fn scan<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        projection: Option<&'life2 [&'life3 str]>,
        filter: Option<&'life4 str>,
        order_by: Option<Vec<ColumnOrdering>>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn scan_with_row_id<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        projection: Option<&'life2 [&'life3 str]>,
        filter: Option<&'life4 str>,
        order_by: Option<Vec<ColumnOrdering>>,
        with_row_id: bool,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
    fn scan_batches<'life0, 'life1, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn scan_batches_for_rewrite<'life0, 'life1, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn count_rows<'life0, 'life1, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        filter: Option<String>,
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn count_rows_with_staged<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        staged: &'life2 [StagedHandle],
        filter: Option<String>,
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn scan_with_staged<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        staged: &'life2 [StagedHandle],
        projection: Option<&'life3 [&'life4 str]>,
        filter: Option<&'life5 str>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait;
    fn scan_with_pending<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        pending: &'life2 [RecordBatch],
        pending_schema: Option<SchemaRef>,
        projection: Option<&'life3 [&'life4 str]>,
        filter: Option<&'life5 str>,
        key_column: Option<&'life6 str>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait,
             'life6: 'async_trait;
    fn first_row_id_for_filter<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        filter: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<u64>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn table_state<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dataset_uri: &'life1 str,
        snapshot: &'life2 SnapshotHandle,
    ) -> Pin<Box<dyn Future<Output = Result<TableState>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn stage_append<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        batch: RecordBatch,
        prior_stages: &'life2 [StagedHandle],
    ) -> Pin<Box<dyn Future<Output = Result<StagedHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn stage_merge_insert<'life0, 'async_trait>(
        &'life0 self,
        snapshot: SnapshotHandle,
        batch: RecordBatch,
        key_columns: Vec<String>,
        when_matched: WhenMatched,
        when_not_matched: WhenNotMatched,
    ) -> Pin<Box<dyn Future<Output = Result<StagedHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn commit_staged<'life0, 'async_trait>(
        &'life0 self,
        snapshot: SnapshotHandle,
        staged: StagedHandle,
    ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn stage_overwrite<'life0, 'life1, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        batch: RecordBatch,
    ) -> Pin<Box<dyn Future<Output = Result<StagedHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn stage_create_btree_index<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        columns: &'life2 [&'life3 str],
    ) -> Pin<Box<dyn Future<Output = Result<StagedHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn stage_create_inverted_index<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        column: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<StagedHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn append_batch<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dataset_uri: &'life1 str,
        snapshot: SnapshotHandle,
        batch: RecordBatch,
    ) -> Pin<Box<dyn Future<Output = Result<(SnapshotHandle, TableState)>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn merge_insert_batches<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dataset_uri: &'life1 str,
        snapshot: SnapshotHandle,
        batches: Vec<RecordBatch>,
        key_columns: Vec<String>,
        when_matched: WhenMatched,
        when_not_matched: WhenNotMatched,
    ) -> Pin<Box<dyn Future<Output = Result<TableState>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn overwrite_batch<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dataset_uri: &'life1 str,
        snapshot: SnapshotHandle,
        batch: RecordBatch,
    ) -> Pin<Box<dyn Future<Output = Result<(SnapshotHandle, TableState)>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn delete_where<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dataset_uri: &'life1 str,
        snapshot: SnapshotHandle,
        filter: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<(SnapshotHandle, DeleteState)>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn has_btree_index<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        column: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn has_fts_index<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        column: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn has_vector_index<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        column: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn create_btree_index<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        snapshot: SnapshotHandle,
        columns: &'life1 [&'life2 str],
    ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn create_inverted_index<'life0, 'life1, 'async_trait>(
        &'life0 self,
        snapshot: SnapshotHandle,
        column: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn create_vector_index<'life0, 'life1, 'async_trait>(
        &'life0 self,
        snapshot: SnapshotHandle,
        column: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn root_uri(&self) -> &str;
    fn dataset_uri(&self, table_path: &str) -> String;
    fn scan_stream<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        snapshot: &'life1 SnapshotHandle,
        projection: Option<&'life2 [&'life3 str]>,
        filter: Option<&'life4 str>,
        order_by: Option<Vec<ColumnOrdering>>,
        with_row_id: bool,
    ) -> Pin<Box<dyn Future<Output = Result<DatasetRecordBatchStream>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait;
}

Engine-internal trait covering every Lance dataset operation an omnigraph engine call site might perform.

TableStore is the only impl. The trait is sealed; the inline Lance APIs are not reachable through trait dispatch. New writers that might advance Lance HEAD MUST add a staged-shape method here.

Required Methods

fn open_snapshot_at_entry<'life0, 'life1, 'async_trait>( &'life0 self, entry: &'life1 SubTableEntry, ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>

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

fn open_snapshot_at_table<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, snapshot: &'life1 Snapshot, table_key: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>

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

fn open_dataset_head<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dataset_uri: &'life1 str, branch: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>

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

fn open_dataset_head_for_write<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, table_key: &'life1 str, dataset_uri: &'life2 str, branch: Option<&'life3 str>, ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>

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

fn open_dataset_at_state<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, table_path: &'life1 str, branch: Option<&'life2 str>, version: u64, ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>

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

fn fork_branch_from_state<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, dataset_uri: &'life1 str, source_branch: Option<&'life2 str>, table_key: &'life3 str, source_version: u64, target_branch: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>

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

fn delete_branch<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dataset_uri: &'life1 str, branch: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

fn reopen_for_mutation<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dataset_uri: &'life1 str, branch: Option<&'life2 str>, table_key: &'life3 str, expected_version: u64, ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>

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

fn ensure_expected_version( &self, snapshot: &SnapshotHandle, table_key: &str, expected_version: u64, ) -> Result<()>

fn scan<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, projection: Option<&'life2 [&'life3 str]>, filter: Option<&'life4 str>, order_by: Option<Vec<ColumnOrdering>>, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>>> + Send + 'async_trait>>

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

fn scan_with_row_id<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, projection: Option<&'life2 [&'life3 str]>, filter: Option<&'life4 str>, order_by: Option<Vec<ColumnOrdering>>, with_row_id: bool, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>>> + Send + 'async_trait>>

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

fn scan_batches<'life0, 'life1, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>>> + Send + 'async_trait>>

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

fn scan_batches_for_rewrite<'life0, 'life1, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>>> + Send + 'async_trait>>

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

fn count_rows<'life0, 'life1, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, filter: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

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

fn count_rows_with_staged<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, staged: &'life2 [StagedHandle], filter: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

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

fn scan_with_staged<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, staged: &'life2 [StagedHandle], projection: Option<&'life3 [&'life4 str]>, filter: Option<&'life5 str>, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>>> + Send + 'async_trait>>

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

fn scan_with_pending<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, pending: &'life2 [RecordBatch], pending_schema: Option<SchemaRef>, projection: Option<&'life3 [&'life4 str]>, filter: Option<&'life5 str>, key_column: Option<&'life6 str>, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait, 'life6: 'async_trait,

fn first_row_id_for_filter<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, filter: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<u64>>> + Send + 'async_trait>>

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

fn table_state<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dataset_uri: &'life1 str, snapshot: &'life2 SnapshotHandle, ) -> Pin<Box<dyn Future<Output = Result<TableState>> + Send + 'async_trait>>

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

fn stage_append<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, batch: RecordBatch, prior_stages: &'life2 [StagedHandle], ) -> Pin<Box<dyn Future<Output = Result<StagedHandle>> + Send + 'async_trait>>

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

fn stage_merge_insert<'life0, 'async_trait>( &'life0 self, snapshot: SnapshotHandle, batch: RecordBatch, key_columns: Vec<String>, when_matched: WhenMatched, when_not_matched: WhenNotMatched, ) -> Pin<Box<dyn Future<Output = Result<StagedHandle>> + Send + 'async_trait>>

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

fn commit_staged<'life0, 'async_trait>( &'life0 self, snapshot: SnapshotHandle, staged: StagedHandle, ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>

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

fn stage_overwrite<'life0, 'life1, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, batch: RecordBatch, ) -> Pin<Box<dyn Future<Output = Result<StagedHandle>> + Send + 'async_trait>>

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

Stage an overwrite (Operation::Overwrite). MR-793 Phase 2.

fn stage_create_btree_index<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, columns: &'life2 [&'life3 str], ) -> Pin<Box<dyn Future<Output = Result<StagedHandle>> + Send + 'async_trait>>

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

Stage a BTREE scalar index build. MR-793 Phase 2.

fn stage_create_inverted_index<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, column: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<StagedHandle>> + Send + 'async_trait>>

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

Stage an INVERTED (FTS) scalar index build. MR-793 Phase 2.

fn append_batch<'life0, 'life1, 'async_trait>( &'life0 self, dataset_uri: &'life1 str, snapshot: SnapshotHandle, batch: RecordBatch, ) -> Pin<Box<dyn Future<Output = Result<(SnapshotHandle, TableState)>> + Send + 'async_trait>>

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

fn merge_insert_batches<'life0, 'life1, 'async_trait>( &'life0 self, dataset_uri: &'life1 str, snapshot: SnapshotHandle, batches: Vec<RecordBatch>, key_columns: Vec<String>, when_matched: WhenMatched, when_not_matched: WhenNotMatched, ) -> Pin<Box<dyn Future<Output = Result<TableState>> + Send + 'async_trait>>

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

fn overwrite_batch<'life0, 'life1, 'async_trait>( &'life0 self, dataset_uri: &'life1 str, snapshot: SnapshotHandle, batch: RecordBatch, ) -> Pin<Box<dyn Future<Output = Result<(SnapshotHandle, TableState)>> + Send + 'async_trait>>

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

fn delete_where<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dataset_uri: &'life1 str, snapshot: SnapshotHandle, filter: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(SnapshotHandle, DeleteState)>> + Send + 'async_trait>>

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

fn has_btree_index<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, column: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

fn has_fts_index<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, column: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

fn has_vector_index<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, column: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

fn create_btree_index<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, snapshot: SnapshotHandle, columns: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>

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

fn create_inverted_index<'life0, 'life1, 'async_trait>( &'life0 self, snapshot: SnapshotHandle, column: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>

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

fn create_vector_index<'life0, 'life1, 'async_trait>( &'life0 self, snapshot: SnapshotHandle, column: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<SnapshotHandle>> + Send + 'async_trait>>

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

fn root_uri(&self) -> &str

fn dataset_uri(&self, table_path: &str) -> String

fn scan_stream<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, snapshot: &'life1 SnapshotHandle, projection: Option<&'life2 [&'life3 str]>, filter: Option<&'life4 str>, order_by: Option<Vec<ColumnOrdering>>, with_row_id: bool, ) -> Pin<Box<dyn Future<Output = Result<DatasetRecordBatchStream>> + Send + 'async_trait>>

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

Implementors

impl TableStorage for TableStore