Struct TableStore 

pub struct TableStore { /* private fields */ }

Implementations

impl TableStore

pub fn new(root_uri: &str) -> Self

pub fn root_uri(&self) -> &str

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

pub async fn open_snapshot_table( &self, snapshot: &Snapshot, table_key: &str, ) -> Result<Dataset>

pub async fn open_at_entry(&self, entry: &SubTableEntry) -> Result<Dataset>

pub async fn open_dataset_head( &self, dataset_uri: &str, branch: Option<&str>, ) -> Result<Dataset>

pub async fn open_dataset_head_for_write( &self, table_key: &str, dataset_uri: &str, branch: Option<&str>, ) -> Result<Dataset>

pub async fn delete_branch(&self, dataset_uri: &str, branch: &str) -> Result<()>

pub async fn list_branches(&self, dataset_uri: &str) -> Result<Vec<String>>

List the named Lance branches present on the dataset at dataset_uri. The cleanup orphan reconciler diffs this against the manifest branch set to find orphaned per-table forks. main/default is not a named branch and never appears here.

pub async fn force_delete_branch( &self, dataset_uri: &str, branch: &str, ) -> Result<()>

Idempotently drop branch from the dataset at dataset_uri.

Unlike delete_branch, this tolerates an already-absent branch — both a missing contents ref (Lance’s force_delete_branch handles that) and a missing tree/{branch}/ directory (the local-store NotFound quirk pinned by lance_surface_guards::force_delete_branch_semantics). Safe to call on a possibly-orphaned or already-reclaimed fork.

A branch that still has referencing descendants (RefConflict) is NOT tolerated: that is a real ordering error and surfaces as OmniError::Lance. Used by the eager best-effort reclaim in cleanup_deleted_branch_tables and the cleanup orphan reconciler.

pub async fn open_dataset_at_state( &self, table_path: &str, branch: Option<&str>, version: u64, ) -> Result<Dataset>

pub fn ensure_expected_version( &self, ds: &Dataset, table_key: &str, expected_version: u64, ) -> Result<()>

pub async fn reopen_for_mutation( &self, dataset_uri: &str, branch: Option<&str>, table_key: &str, expected_version: u64, ) -> Result<Dataset>

pub async fn fork_branch_from_state( &self, dataset_uri: &str, source_branch: Option<&str>, table_key: &str, source_version: u64, target_branch: &str, ) -> Result<ForkOutcome<Dataset>>

pub async fn scan_batches(&self, ds: &Dataset) -> Result<Vec<RecordBatch>>

pub async fn scan_batches_for_rewrite( &self, ds: &Dataset, ) -> Result<Vec<RecordBatch>>

pub async fn scan_stream( ds: &Dataset, projection: Option<&[&str]>, filter: Option<&str>, order_by: Option<Vec<ColumnOrdering>>, with_row_id: bool, ) -> Result<DatasetRecordBatchStream>

pub async fn scan_stream_with<F>( ds: &Dataset, projection: Option<&[&str]>, filter: Option<&str>, order_by: Option<Vec<ColumnOrdering>>, with_row_id: bool, configure: F, ) -> Result<DatasetRecordBatchStream>

where F: FnOnce(&mut Scanner) -> Result<()>,

pub async fn scan( &self, ds: &Dataset, projection: Option<&[&str]>, filter: Option<&str>, order_by: Option<Vec<ColumnOrdering>>, ) -> Result<Vec<RecordBatch>>

pub async fn scan_with<F>( &self, ds: &Dataset, projection: Option<&[&str]>, filter: Option<&str>, order_by: Option<Vec<ColumnOrdering>>, with_row_id: bool, configure: F, ) -> Result<Vec<RecordBatch>>

where F: FnOnce(&mut Scanner) -> Result<()>,

pub async fn scan_edges_by_endpoint( ds: &Dataset, key_col: &str, opposite_col: &str, keys: &[String], ) -> Result<Vec<RecordBatch>>

Indexed neighbor lookup for graph traversal. Given an edge dataset and a set of endpoint keys on key_col ("src" for out-traversal, "dst" for in-traversal), return the matching edge rows projected to [key_col, opposite_col].

The key_col IN (keys) predicate is built as a structured DataFusion Expr and applied via Scanner::filter_expr, so Lance routes it through the persisted BTREE on key_col (index-search → take). Cost scales with the frontier size, not |E| — the basis for serving selective traversals without building the whole in-memory CSR. Empty keys returns empty without scanning.

Note: like any indexed scan, this observes only fragments the BTREE covers plus an unindexed-fragment scan fallback; it reads the committed snapshot ds was opened at.

pub async fn key_column_index_coverage( ds: &Dataset, column: &str, ) -> Result<IndexCoverage>

Metadata-only check (no IO) of whether scan_edges_by_endpoint — a key_col IN (...) filter — on ds will be served by the persisted BTREE on column, or silently fall back to a full filtered scan. Mirrors Lance’s own decision: scalar indices are disabled for the whole scan if ANY fragment lacks physical_rows (lance dataset/scanner.rs create_filter_plan), and are obviously unused if no BTREE on the column exists. The scan is correct (returns all rows) either way — this only surfaces the perf cliff so the indexed traversal can warn on it.

pub async fn has_unindexed_fragments(ds: &Dataset) -> Result<bool>

True if any non-system index on ds leaves at least one current fragment uncovered, i.e. rows that the index does not yet account for (appended after the index was built, or rewritten by compaction). Such fragments are scanned unindexed until a reindex (optimize_indices) folds them in. Returns false when every index covers every fragment, or when the table has no (non-system) indices to optimize. A None fragment_bitmap means Lance cannot report coverage for that index, so we do not treat it as uncovered (mirrors key_column_index_coverage).

Used by optimize to decide whether an otherwise-already-compacted table still has index work to do.

pub async fn count_rows( &self, ds: &Dataset, filter: Option<String>, ) -> Result<usize>

pub fn dataset_version(&self, ds: &Dataset) -> u64

pub async fn table_state( &self, dataset_uri: &str, ds: &Dataset, ) -> Result<TableState>

pub async fn append_or_create_batch( dataset_uri: &str, dataset: Option<Dataset>, batch: RecordBatch, ) -> Result<Dataset>

pub async fn stage_append( &self, ds: &Dataset, batch: RecordBatch, prior_stages: &[StagedWrite], ) -> Result<StagedWrite>

Stage an append: write fragment files for batch, return the uncommitted Lance transaction plus the new fragments for read-your-writes.

prior_stages is the slice of staged writes already accumulated against the same dataset in the same query. Pass &[] for the first call; pass the accumulated stages for subsequent calls. The primitive uses this to offset row-ID assignment so chained stage_append calls don’t produce overlapping _rowid ranges. Mirrors scan_with_staged’s &[StagedWrite] shape — the same slice gets passed to both.

On stable-row-id datasets we manually populate row_id_meta on the cloned new_fragments we expose for scan_with_staged. Lance’s InsertBuilder::execute_uncommitted produces fragments with row_id_meta = None; row IDs are normally assigned by Transaction::assign_row_ids during commit. Because scan_with_staged reads the staged fragments before commit, the scanner trips on a stable-row-id dataset (Error::internal("Missing row id meta") from dataset/rowids.rs:22). The transaction’s internal fragment copy stays untouched — Lance assigns IDs there independently at commit time, and the two ID assignments don’t have to agree because no caller threads _rowid from the staged scan into the commit path.

Contract: prior_stages must contain only previous stage_append results against the same dataset. Mixing stage_merge_insert into prior_stages would over-count because merge_insert’s new_fragments include rewrites that don’t add rows. The engine’s parse-time D₂′ check (per touched table: all stage_append OR exactly one stage_merge_insert) guarantees this upstream; on the primitive layer it’s the caller’s responsibility.

pub async fn stage_merge_insert( &self, ds: Dataset, batch: RecordBatch, key_columns: Vec<String>, when_matched: WhenMatched, when_not_matched: WhenNotMatched, ) -> Result<StagedWrite>

Stage a merge_insert (upsert): write fragment files describing the merge result, return the uncommitted transaction plus the new fragments. The transaction’s Operation::Update carries the fragments-to-remove and fragments-to-add; for read-your-writes we expose new_fragments (rows that will be visible after commit).

Contract: do not chain stage_merge_insert calls on the same table within one query. Each call’s MergeInsertBuilder runs against the supplied dataset’s committed view — it does not see fragments produced by a previous staged merge on the same table. Two chained stage_merge_inserts whose source rows share keys will each independently produce Operation::Update transactions whose new_fragments contain a row for the shared key. scan_with_staged (and count_rows_with_staged) will then return both — i.e. duplicates by key.

This is intrinsic to the underlying Lance API: there is no public way to make MergeInsertBuilder see uncommitted fragments. The engine’s MutationStaging accumulator works around this by concatenating per-table batches in memory and issuing exactly one stage_merge_insert per touched table at end-of-query (with last-write-wins dedupe by id) — see exec/staging.rs. Direct callers of this primitive must respect the contract themselves.

Lift path: either a Lance API extension that lets MergeInsertBuilder accept additional staged fragments, or an in-memory pre-merge here that folds prior staged batches into the input stream. See docs/dev/writes.md.

pub async fn commit_staged( &self, ds: Arc<Dataset>, transaction: Transaction, ) -> Result<Dataset>

Commit a previously-staged transaction onto ds, returning the new dataset (with HEAD advanced). Wraps CommitBuilder::execute. Used by the publisher at end-of-query to materialize all staged writes before the meta-manifest commit.

pub async fn stage_overwrite( &self, ds: &Dataset, batch: RecordBatch, ) -> Result<StagedWrite>

Stage an overwrite (write_fragments + Operation::Overwrite { schema, fragments }). Returns a StagedWrite carrying the replacement fragments. HEAD does NOT advance.

Lance shape: InsertBuilder::with_params(WriteParams { mode: Overwrite, .. }) .execute_uncommitted(vec![batch]) produces a Transaction whose Operation::Overwrite carries the new schema + fragments. The transaction is committed via commit_staged (same call as stage_append).

MR-793 Phase 2: introduces this for the schema_apply rewrite path. Lance API verified in .context/mr-793-design.md Appendix A.1.

pub async fn stage_create_btree_index( &self, ds: &Dataset, columns: &[&str], ) -> Result<StagedWrite>

Stage a BTREE scalar index build. Returns a StagedWrite whose transaction commits via commit_staged. HEAD does NOT advance.

Lance shape: CreateIndexBuilder::execute_uncommitted returns IndexMetadata; we manually wrap it in Operation::CreateIndex { new_indices, removed_indices } via the public TransactionBuilder, replicating the simple (non-segment-commit-path) branch of Lance’s CreateIndexBuilder::execute (lance-6.0.1 src/index/create.rs:502-512).

removed_indices mirrors execute() lines 466-476: when the build replaces an existing same-named index, those entries are listed for tombstoning by the manifest commit.

MR-793 Phase 2: scalar index types (BTree, Inverted) are stage-able. Vector indices are NOT (segment-commit-path requires build_index_metadata_from_segments which is pub(crate) in lance-6.0.1); see create_vector_index and Appendix A.3.

pub async fn stage_create_inverted_index( &self, ds: &Dataset, column: &str, ) -> Result<StagedWrite>

Stage an INVERTED (FTS) scalar index build. Same shape as stage_create_btree_index; see its docs for the Lance API citation and contract notes.

pub async fn scan_with_staged( &self, ds: &Dataset, staged: &[StagedWrite], projection: Option<&[&str]>, filter: Option<&str>, ) -> Result<Vec<RecordBatch>>

Run a scan with optional uncommitted staged writes visible alongside the committed snapshot. When staged is empty this is identical to scan(...).

Composes the visible fragment list as committed - removed + new: the committed manifest’s fragments, minus any fragment IDs that staged Operation::Updates (merge_insert rewrites) have superseded, plus the staged new/updated fragments. Without the removed filter, a merge_insert that rewrites an existing fragment would surface twice — once via the original committed fragment, once via the rewrite in new_fragments.

Filter contract is incomplete on staged fragments. When filter is Some(...), Lance pushes the predicate to per-fragment scans with stats-based pruning. Uncommitted fragments produced by write_fragments_internal lack the per-column statistics that committed fragments carry; Lance’s optimizer drops them from the filtered scan even when their data would match. Staged-fragment rows are silently absent from the result. scanner.use_stats(false) does not fix this in lance 6.0.1. Callers needing correct filtered reads against staged data should use a different strategy — the engine’s MutationStaging accumulator unions in-memory pending batches with the committed scan via DataFusion MemTable (see scan_with_pending).

This method remains on the surface for primitive-level testing (basic stage + scan correctness without filters works) and for callers that don’t need filter pushdown.

pub async fn scan_with_pending( &self, committed_ds: &Dataset, pending_batches: &[RecordBatch], pending_schema: Option<SchemaRef>, projection: Option<&[&str]>, filter: Option<&str>, key_column: Option<&str>, ) -> Result<Vec<RecordBatch>>

Scan committed via Lance + apply the same filter to in-memory pending batches via DataFusion MemTable, concat the two result streams. The replacement for scan_with_staged in engine code: the staged-write writer accumulates input batches in memory and unions them with the committed snapshot at read time, sidestepping the Scanner::with_fragments filter-pushdown limitation documented on scan_with_staged.

committed_ds should be opened at the pre-mutation expected_version (the same version captured in MutationStaging::expected_versions at first touch of the table). pending_batches are the per-table accumulator’s batches in their input shape. pending_schema is the schema of the accumulated batches; passing None falls back to the schema of the first pending batch.

filter is the Lance / DataFusion SQL predicate. It is applied to both sides — Lance pushes it down on the committed side; the pending side runs it through a fresh DataFusion SessionContext with the batches registered as a MemTable named pending.

key_column controls how committed and pending are unioned:

• None (union semantics): every committed row that matches the filter and every pending row that matches the filter is returned. Correct when committed and pending cannot share a primary key — e.g., Append-mode loads with ULID-generated ids, or any read where pending hasn’t been used to update committed rows.
• Some(col) (merge / shadow semantics): committed rows whose col value appears in any pending batch are EXCLUDED from the result; only pending’s view of those rows is returned. Required for Merge-mode reads (e.g., execute_update on the engine path) so a chained update doesn’t see stale committed values that a prior op already updated in pending. Without this, a predicate like where age > 30 can match a row that an earlier set age = 20 already moved out of range.

When pending_batches is empty this delegates to the regular scan path.

pub async fn count_rows_with_staged( &self, ds: &Dataset, staged: &[StagedWrite], filter: Option<String>, ) -> Result<usize>

count_rows variant that respects staged writes. Used for edge-cardinality validation that needs to see staged edges before commit. Same committed - removed + new composition as scan_with_staged.

pub async fn has_btree_index(&self, ds: &Dataset, column: &str) -> Result<bool>

pub async fn has_fts_index(&self, ds: &Dataset, column: &str) -> Result<bool>

pub async fn has_vector_index(&self, ds: &Dataset, column: &str) -> Result<bool>

pub async fn create_empty_dataset( dataset_uri: &str, schema: &SchemaRef, ) -> Result<Dataset>

pub async fn first_row_id_for_filter( &self, ds: &Dataset, filter: &str, ) -> Result<Option<u64>>

pub async fn write_dataset( dataset_uri: &str, batch: RecordBatch, ) -> Result<Dataset>

Trait Implementations

impl Clone for TableStore

fn clone(&self) -> TableStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TableStore

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

Formats the value using the given formatter.

impl TableStorage for TableStore

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<ForkOutcome<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 force_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,

Idempotent variant of delete_branch used by the best-effort fork reclaim under branch delete (db/omnigraph.rs::cleanup_deleted_branch_tables) and by the orphan-fork reconciler in optimize. Tolerates an already-absent branch (both Lance’s RefNotFound and the local-store NotFound quirk on a missing tree/{branch}/ dir). A still-referenced branch (RefConflict) still surfaces as OmniError::Lance.

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

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

List the named Lance branches present on the dataset at dataset_uri. The cleanup orphan reconciler diffs this against the manifest branch set to find orphaned per-table forks. main/default is not a named branch and never appears here.

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 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 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,