Struct LanceDbBackend 

pub struct LanceDbBackend { /* private fields */ }

Lance implementation of StorageBackend.

Built directly on lance::Dataset via LanceDirectory; the lancedb layer it once wrapped has been removed. All Lance-specific code is confined to this module and its siblings (lance_branch, lance_directory).

Implementations

impl LanceDbBackend

pub async fn connect( uri: &str, storage_options: Option<HashMap<String, String>>, ) -> Result<Self>

Connect to a LanceDB database at the given URI.

Trait Implementations

impl StorageBackend for LanceDbBackend

fn invalidate_cache(&self, _table_name: &str)

No-op, as before the lancedb removal.

These only ever cleared the lancedb::Table cache, which was never populated (a cached handle is version-pinned and would drop rows committed later), so both calls were already no-ops. That is preserved verbatim rather than quietly extended to schema_cache: changing what an explicit invalidation does is a behavior change, not a port. Worth revisiting — schema_cache is now the only cache, so a caller asking to invalidate currently gets nothing — but as its own piece of work.

fn clear_cache(&self)

No-op — see Self::invalidate_cache.

fn table_names<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>

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

List all table names in the backend.

fn table_exists<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

Check if a table exists.

fn create_table<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, batches: Vec<RecordBatch>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Create a new table with initial data batches.

fn create_empty_table<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, schema: Arc<ArrowSchema>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Create a new empty table with the given schema.

fn open_or_create_table<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, schema: Arc<ArrowSchema>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Open a table if it exists, or create it with the given schema.

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

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

Drop a table by name.

fn notify_table_created<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

Notify the backend that a table now exists, even though no create_table / create_empty_table / open_or_create_table went through this trait. The default implementation is a no-op; backends that cache existence (e.g. LanceDbBackend’s existence_cache from issue #55) override to invalidate the stale negative entry. Used by BranchedBackend after it creates a fork-side dataset directly through the Lance branch primitives — that path does not call create_table on the inner backend, so without this hook the inner backend’s existence cache silently keeps reporting false for the just-created table.

fn scan<'life0, 'async_trait>( &'life0 self, request: ScanRequest, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordBatch>>> + Send + 'async_trait>>

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

Scan a table, collecting all matching rows into batches.

fn scan_stream<'life0, 'async_trait>( &'life0 self, request: ScanRequest, ) -> Pin<Box<dyn Future<Output = Result<RecordBatchStream>> + Send + 'async_trait>>

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

Scan a table, returning a streaming iterator over record batches.

fn get_table_schema<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Arc<ArrowSchema>>>> + Send + 'async_trait>>

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

Get the Arrow schema for a table. Returns None if the table doesn’t exist.

fn count_rows<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, table_name: &'life1 str, filter: Option<&'life2 FilterExpr>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

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

Count rows in a table, optionally with a filter.

fn write<'life0, 'life1, 'async_trait>( &'life0 self, table_name: &'life1 str, batches: Vec<RecordBatch>, mode: WriteMode, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Write record batches to a table.

fn merge_insert<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, table_name: &'life1 str, on: &'life2 [&'life3 str], batches: Vec<RecordBatch>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Upsert via Lance MergeInsert. Source rows are joined to the target on the columns in on; matched rows have UpdateAll applied (i.e. every column present in the source overrides the target’s value for that column; columns not in the source are preserved). Unmatched source rows are DROPPED — partial writes never INSERT (CREATE goes through write with WriteMode::Append).

fn delete_rows<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, table_name: &'life1 str, filter: &'life2 FilterExpr, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Delete rows matching a filter expression.

fn replace_table_atomic<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, batches: Vec<RecordBatch>, schema: Arc<ArrowSchema>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Atomically replace a table’s contents.

fn lock_table_for_write<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = TableWriteGuard> + Send + 'async_trait>>

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

Acquire the per-table write lock, returning a guard held until dropped.

fn get_table_version<'life0, 'life1, 'async_trait>( &'life0 self, table_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<u64>>> + Send + 'async_trait>>

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

Get the current version of a table. Returns None if the table doesn’t exist.

fn rollback_table<'life0, 'life1, 'async_trait>( &'life0 self, table_name: &'life1 str, target_version: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Roll back a table to a specific version.

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

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

Optimize a table (compaction, cleanup, etc.).

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

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

Recover a table from crash state (incomplete staging writes, etc.).

fn base_uri(&self) -> &str

Get the base URI for this backend’s storage location.

fn branching(&self) -> Option<Arc<dyn ForkBranching>>

Copy-on-write branching support, if this backend provides it.

fn supports_vector_search(&self) -> bool

Whether this backend supports vector similarity search.

fn supports_full_text_search(&self) -> bool

Whether this backend supports full-text search.

fn supports_scalar_index(&self) -> bool

Whether this backend supports scalar indexes.

fn vector_search<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, table: &'life1 str, column: &'life2 str, query: &'life3 [f32], k: usize, metric: DistanceMetric, filter: FilterExpr, opts: VectorQueryOpts, ) -> 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,

Perform a vector similarity search.

fn multivector_search<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, table: &'life1 str, column: &'life2 str, query: &'life3 [Vec<f32>], k: usize, metric: DistanceMetric, filter: FilterExpr, opts: VectorQueryOpts, ) -> 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,

Late-interaction (ColBERT / MaxSim) search over a multi-vector column.

fn full_text_search<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, table: &'life1 str, column: &'life2 str, query: &'life3 str, k: usize, filter: FilterExpr, ) -> 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,

Perform a full-text search.

fn create_vector_index<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, table: &'life1 str, column: &'life2 str, name: &'life3 str, params: VectorIndexParams, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Create a named vector (ANN) index on a column with the given parameters.

fn create_scalar_index<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, table: &'life1 str, columns: &'life2 [&'life3 str], index_type: ScalarIndexType, name: Option<&'life4 str>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Create a scalar index over one or more columns.

fn create_fts_index<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, table: &'life1 str, columns: &'life2 [&'life3 str], name: Option<&'life4 str>, tokenizer: &'life5 TokenizerConfig, with_positions: bool, ) -> Pin<Box<dyn Future<Output = Result<()>> + 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,

Create a full-text search index over one or more columns.

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

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

Drop an index by name.

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

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

List all indexes on a table.