Struct LanceStore 

pub struct LanceStore {
    db_path: PathBuf,
    embedding_dim: usize,
    embedding_model: Option<String>,
    connection: RwLock<Option<Connection>>,
    chunks_table: RwLock<Option<Table>>,
    files_table: RwLock<Option<Table>>,
}

LanceDB-based vector store.

Fields

db_path: PathBuf

Path to the LanceDB database

embedding_dim: usize

Embedding dimension

embedding_model: Option<String>

Embedder model id that should match this index, when known.

connection: RwLock<Option<Connection>>

Database connection (lazy initialized)

chunks_table: RwLock<Option<Table>>

Chunks table handle

files_table: RwLock<Option<Table>>

Files table handle

Implementations

impl LanceStore

pub fn new(db_path: PathBuf, embedding_dim: usize) -> Self

Create a new LanceStore.

embedding_dim must come from Embedder::dimension at the call site. Opening an existing index whose vector column width differs fails in init.

pub fn with_embedding_model(self, model: impl Into<String>) -> Self

Record the embedder model id in the schema sidecar.

pub fn db_path(&self) -> &Path

Get the database path.

pub fn embedding_dim(&self) -> usize

Get the embedding dimension.

fn stored_embedding_dim(schema: &Schema) -> Result<usize, StoreError>

Width of the chunks vector FixedSizeList.

fn ensure_embedding_dim_matches( &self, schema: &Schema, ) -> Result<(), StoreError>

pub(crate) fn should_build_ann_index(row_count: usize) -> bool

Whether the table is large enough for Lance IVF-PQ training.

pub(crate) fn should_refresh_ann_index(unindexed_rows: usize) -> bool

Refresh IVF-PQ once the unindexed tail is large enough to train another sample.

pub(crate) fn ann_index_covers_metric(metric: DistanceMetric) -> bool

ANN is trained as cosine; other metrics must not use the index.

pub(crate) fn ann_index_is_cosine(distance_type: Option<DistanceType>) -> bool

Reuse/refresh only a cosine-trained vector index.

async fn vector_index_name(table: &Table) -> Option<String>

async fn refresh_vector_index(table: &Table, index_name: &str)

async fn ensure_vector_index(&self) -> Result<(), StoreError>

Best-effort IVF-PQ on vector. Small tables keep exact scan. Existing cosine indexes are incrementally refreshed after large appends. A non-cosine vector index is dropped and replaced when the table is large enough.

async fn get_connection(&self) -> Result<Connection, StoreError>

Get or create connection.

fn chunks_schema(&self) -> Schema

Build chunks table schema.

fn files_schema(&self) -> Schema

Build files table schema.

async fn get_chunks_table(&self) -> Result<Table, StoreError>

Get or open chunks table.

async fn get_files_table(&self) -> Result<Table, StoreError>

Get or open files table.

fn schema_sidecar_path(&self) -> PathBuf

async fn read_schema_sidecar(&self) -> Option<u32>

async fn write_schema_sidecar(&self, version: u32) -> Result<(), StoreError>

fn schema_migration_failed_message( db_path: &Path, error: &impl Display, ) -> String

async fn ensure_chunks_schema_v2(&self) -> Result<(), StoreError>

Detect a pre-v2 chunks table, add scope columns, and backfill from file_path.

--force rewrites index-root-relative dir_path on new upserts; it cannot add Lance columns. This path is what existing indexes need on upgrade.

async fn backfill_scope_columns(&self) -> Result<(), StoreError>

fn chunks_to_batch(&self, chunks: &[Chunk]) -> Result<RecordBatch, StoreError>

Convert chunks to Arrow RecordBatch.

fn file_to_batch(&self, record: &FileRecord) -> Result<RecordBatch, StoreError>

Convert file record to Arrow RecordBatch.

async fn chunk_filter_sql( &self, filters: &[SearchFilter], ) -> Result<Option<String>, StoreError>

Combine chunk-column filters with source-file modified_at constraints.

async fn modified_at_path_predicate( &self, filters: &[SearchFilter], ) -> Result<Option<String>, StoreError>

Resolve ModifiedAfter / ModifiedBefore against the files table.

Trait Implementations

impl VectorStore for LanceStore

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

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

Initialize the store.

fn upsert_chunks<'life0, 'life1, 'async_trait>( &'life0 self, chunks: &'life1 [Chunk], ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Insert or update chunks.

fn search<'life0, 'async_trait>( &'life0 self, query: SearchQuery, ) -> Pin<Box<dyn Future<Output = Result<Vec<SearchResult>, StoreError>> + Send + 'async_trait>>

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

Search for similar chunks.

fn hybrid_search<'life0, 'async_trait>( &'life0 self, query: SearchQuery, ) -> Pin<Box<dyn Future<Output = Result<Vec<SearchResult>, StoreError>> + Send + 'async_trait>>

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

Hybrid search (vector + full-text).

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

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

Delete all chunks for a file.

fn update_file_path<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, from: &'life1 Path, to: &'life2 Path, ) -> Pin<Box<dyn Future<Output = Result<u64, StoreError>> + Send + 'async_trait>>

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

Update file path for all chunks (for renames).

fn get_chunks_for_file<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<Chunk>, StoreError>> + Send + 'async_trait>>

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

Get all chunks for a file.

fn get_file<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Option<FileRecord>, StoreError>> + Send + 'async_trait>>

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

Get file record.

fn upsert_file<'life0, 'life1, 'async_trait>( &'life0 self, record: &'life1 FileRecord, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Upsert file record.

fn stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<StoreStats, StoreError>> + Send + 'async_trait>>

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

Get store statistics.

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

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

Get all chunks in the store.

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

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

Get all file records in the store.