Struct LanceDbStore 

pub struct LanceDbStore { /* private fields */ }

Wrapper around LanceDB connection for Uni storage.

This provides a unified interface for all table operations, replacing direct Lance Dataset usage.

Implementations

impl LanceDbStore

pub async fn connect(uri: &str) -> Result<Self>

Connect to a LanceDB database at the given URI.

Supported URIs:

• /path/to/database - local filesystem
• s3://bucket/path - AWS S3
• gs://bucket/path - Google Cloud Storage

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

Connect to a LanceDB database with explicit storage options.

pub fn base_uri(&self) -> &str

Get the base URI for this store.

pub async fn table_names(&self) -> Result<Vec<String>>

List all table names in the database.

pub async fn table_exists(&self, name: &str) -> Result<bool>

Check if a table exists.

pub async fn open_table(&self, name: &str) -> Result<Table>

Open an existing table.

pub async fn create_table( &self, name: &str, batches: Vec<RecordBatch>, ) -> Result<Table>

Create a new table with initial data.

If the table already exists, this will fail.

pub async fn create_empty_table( &self, name: &str, schema: Arc<ArrowSchema>, ) -> Result<Table>

Create a new empty table with a schema.

pub async fn open_or_create_table( &self, name: &str, schema: Arc<ArrowSchema>, ) -> Result<Table>

Open a table, creating it if it doesn’t exist.

pub async fn drop_table(&self, name: &str) -> Result<()>

Drop a table by name.

pub async fn drop_all_tables(&self) -> Result<()>

Drop all tables in the database.

pub async fn append_to_table( &self, table: &Table, batches: Vec<RecordBatch>, ) -> Result<()>

Append data to an existing table.

pub fn main_vertex_table_name() -> &'static str

Get the table name for the main vertices table.

The main vertices table contains all vertices regardless of label, enabling fast ID-based lookups without knowing the label.

pub fn main_edge_table_name() -> &'static str

Get the table name for the main edges table.

The main edges table contains all edges regardless of type, enabling fast ID-based lookups without knowing the edge type.

pub async fn open_main_vertex_table(&self) -> Result<Table>

Open the main vertices table.

Errors

Returns an error if the table does not exist.

pub async fn open_main_edge_table(&self) -> Result<Table>

Open the main edges table.

Errors

Returns an error if the table does not exist.

pub async fn main_vertex_table_exists(&self) -> Result<bool>

Check if the main vertices table exists.

pub async fn main_edge_table_exists(&self) -> Result<bool>

Check if the main edges table exists.

pub fn vertex_table_name(label: &str) -> String

Get the table name for a vertex label.

pub async fn open_or_create_vertex_table( &self, label: &str, schema: Arc<ArrowSchema>, ) -> Result<Table>

Open or create a vertex table for a label.

pub async fn open_vertex_table(&self, label: &str) -> Result<Table>

Open a vertex table for a label.

pub async fn vertex_table_exists(&self, label: &str) -> Result<bool>

Check if a vertex table exists for a label.

pub fn delta_table_name(edge_type: &str, direction: &str) -> String

Get the table name for edge deltas.

pub async fn open_or_create_delta_table( &self, edge_type: &str, direction: &str, schema: Arc<ArrowSchema>, ) -> Result<Table>

Open or create a delta table.

pub async fn open_delta_table( &self, edge_type: &str, direction: &str, ) -> Result<Table>

Open a delta table.

pub fn adjacency_table_name(edge_type: &str, direction: &str) -> String

Get the table name for adjacency data.

pub async fn open_or_create_adjacency_table( &self, edge_type: &str, direction: &str, schema: Arc<ArrowSchema>, ) -> Result<Table>

Open or create an adjacency table.

pub async fn open_adjacency_table( &self, edge_type: &str, direction: &str, ) -> Result<Table>

Open an adjacency table.

pub async fn get_table_version(&self, table_name: &str) -> Result<Option<u64>>

Get the current version of a table.

Returns None if the table does not exist.

Errors

Returns an error if the table exists but version query fails.

pub async fn rollback_table( &self, table_name: &str, target_version: u64, ) -> Result<()>

Roll back a table to a specific version.

This uses LanceDB’s checkout and restore APIs to create a new version that matches the state at target_version.

Errors

Returns an error if the table cannot be opened or rollback fails.

pub async fn replace_table_atomic( &self, name: &str, batches: Vec<RecordBatch>, schema: Arc<ArrowSchema>, ) -> Result<Table>

Replace a table’s contents atomically using Lance’s overwrite mode.

When the table already exists, this uses add().mode(Overwrite) to create a new dataset version without dropping the table. This is critical for concurrency safety: the old data files remain on disk (referenced by older versions) until Prune runs, so concurrent readers can finish without hitting “file not found” errors.

When the table does not exist, it creates a new table normally.

Arguments

• name - The table name to replace
• batches - The new data (can be empty)
• schema - The Arrow schema for the table

Errors

Returns an error if table operations fail.

pub async fn recover_staging(&self, name: &str) -> Result<()>

Recover a table from its staging table if needed.

This method handles crash recovery scenarios:

• If {name}_staging exists AND {name} exists → drop staging (leftover)
• If {name}_staging exists AND {name} missing → restore main from staging

Call this on startup for all known table patterns to recover from crashes.

Arguments

• name - The table name to recover

Errors

Returns an error if recovery operations fail.