Struct StorageManager 

pub struct StorageManager {
    pub config: UniConfig,
    pub compaction_status: Arc<Mutex<CompactionStatus>>,
    /* private fields */
}

Fields

config: UniConfig

compaction_status: Arc<Mutex<CompactionStatus>>

Implementations

impl StorageManager

pub async fn new_with_backend( base_uri: &str, store: Arc<dyn ObjectStore>, backend: Arc<dyn StorageBackend>, schema_manager: Arc<SchemaManager>, config: UniConfig, ) -> Result<StorageManager, Error>

Create a new StorageManager with a pre-configured backend.

pub async fn new( base_uri: &str, schema_manager: Arc<SchemaManager>, ) -> Result<StorageManager, Error>

Create a new StorageManager with LanceDB integration.

pub async fn new_with_cache( base_uri: &str, schema_manager: Arc<SchemaManager>, adjacency_cache_size: usize, ) -> Result<StorageManager, Error>

Create a new StorageManager with custom cache size.

pub async fn new_with_config( base_uri: &str, schema_manager: Arc<SchemaManager>, config: UniConfig, ) -> Result<StorageManager, Error>

Create a new StorageManager with custom configuration.

pub async fn new_with_store_and_config( base_uri: &str, store: Arc<dyn ObjectStore>, schema_manager: Arc<SchemaManager>, config: UniConfig, ) -> Result<StorageManager, Error>

Create a new StorageManager using an already-constructed object store.

pub async fn new_with_store_and_storage_options( base_uri: &str, store: Arc<dyn ObjectStore>, schema_manager: Arc<SchemaManager>, config: UniConfig, lancedb_storage_options: Option<HashMap<String, String>>, ) -> Result<StorageManager, Error>

Create a new StorageManager with LanceDB storage options.

pub fn pinned(&self, snapshot: SnapshotManifest) -> StorageManager

pub fn get_edge_version_by_id(&self, edge_type_id: u32) -> Option<u64>

pub fn version_high_water_mark(&self) -> Option<u64>

Returns the version_high_water_mark from the pinned snapshot if present.

This is used for time-travel queries to filter data by version. When a snapshot is pinned, only rows with _version <= version_high_water_mark should be considered visible.

pub fn apply_version_filter(&self, base_filter: String) -> String

Apply version filtering to a base filter expression.

If a snapshot is pinned, wraps base_filter with an additional _version <= hwm clause. Otherwise returns base_filter unchanged.

pub fn store(&self) -> Arc<dyn ObjectStore>

pub fn compaction_status(&self) -> Result<CompactionStatus, LockPoisonedError>

Get current compaction status.

Errors

Returns error if the compaction status lock is poisoned (see issue #18/#150).

pub async fn compact(&self) -> Result<CompactionStats, Error>

pub async fn compact_label(&self, label: &str) -> Result<CompactionStats, Error>

pub async fn compact_edge_type( &self, edge_type: &str, ) -> Result<CompactionStats, Error>

pub async fn wait_for_compaction(&self) -> Result<(), Error>

pub fn start_background_compaction( self: Arc<StorageManager>, shutdown_rx: Receiver<()>, ) -> JoinHandle<()>

pub fn invalidate_table_cache(&self, label: &str)

Open a LanceDB table for a label.

Invalidate cached table state (call after writes).

pub fn base_path(&self) -> &str

pub fn schema_manager(&self) -> &SchemaManager

pub fn schema_manager_arc(&self) -> Arc<SchemaManager>

pub fn adjacency_manager(&self) -> Arc<AdjacencyManager>

Get the adjacency manager for the dual-CSR architecture.

pub async fn warm_adjacency( &self, edge_type_id: u32, direction: Direction, version: Option<u64>, ) -> Result<(), Error>

Warm the adjacency manager for a specific edge type and direction.

Builds the Main CSR from L2 adjacency + L1 delta data in storage. Called lazily on first access per edge type or at startup.

pub async fn warm_adjacency_coalesced( &self, edge_type_id: u32, direction: Direction, version: Option<u64>, ) -> Result<(), Error>

Coalesced warm_adjacency() to prevent cache stampede (Issue #13).

Uses double-checked locking to ensure only one concurrent warm() per (edge_type, direction) key. Subsequent callers wait for the first to complete.

pub fn has_adjacency_csr(&self, edge_type_id: u32, direction: Direction) -> bool

Check whether the adjacency manager has a CSR for the given edge type and direction.

pub fn get_neighbors_at_version( &self, vid: Vid, edge_type: u32, direction: Direction, version: u64, ) -> Vec<(Vid, Eid)>

Get neighbors at a specific version for snapshot queries.

pub fn backend(&self) -> &(dyn StorageBackend + 'static)

Get the storage backend.

pub fn backend_arc(&self) -> Arc<dyn StorageBackend>

Get the storage backend as an Arc.

pub fn get_labels_from_index(&self, vid: Vid) -> Option<Vec<String>>

Get labels for a VID from the in-memory index. Returns None if the index is disabled or the VID is not found.

pub fn update_vid_labels_index(&self, vid: Vid, labels: Vec<String>)

Update the VID-to-labels mapping in the index. No-op if the index is disabled.

pub fn remove_from_vid_labels_index(&self, vid: Vid)

Remove a VID from the labels index. No-op if the index is disabled.

pub async fn load_subgraph_cached( &self, start_vids: &[Vid], edge_types: &[u32], max_hops: usize, direction: Direction, _l0: Option<Arc<RwLock<RawRwLock, L0Buffer>>>, ) -> Result<SimpleGraph, Error>

pub fn snapshot_manager(&self) -> &SnapshotManager

pub fn index_manager(&self) -> IndexManager

pub async fn scan_vertex_table( &self, label: &str, columns: &[&str], additional_filter: Option<&str>, ) -> Result<Option<RecordBatch>, Error>

Scan a per-label vertex table. Returns None if the table doesn’t exist.

Internally opens the table, filters requested columns to those that physically exist, and applies the version HWM filter for snapshot isolation.

pub async fn scan_delta_table( &self, edge_type: &str, direction: &str, columns: &[&str], additional_filter: Option<&str>, ) -> Result<Option<RecordBatch>, Error>

Scan a delta table for an edge type + direction. Returns None if the table doesn’t exist.

pub async fn scan_main_vertex_table( &self, columns: &[&str], filter: Option<&str>, ) -> Result<Option<RecordBatch>, Error>

Scan the unified main vertex table. Returns None if table doesn’t exist.

Applies version HWM filter internally for snapshot isolation, combined with any caller-provided filter (label conditions, etc.).

pub async fn scan_main_edge_table_stream( &self, filter: Option<&str>, ) -> Result<Option<Pin<Box<dyn Stream<Item = Result<RecordBatch, Error>> + Send>>>, Error>

Scan the main edge table as a stream. Returns None if table doesn’t exist.

pub async fn scan_vertex_table_stream( &self, label: &str, ) -> Result<Option<Pin<Box<dyn Stream<Item = Result<RecordBatch, Error>> + Send>>>, Error>

Scan a per-label vertex table as a stream. Returns None if table doesn’t exist.

pub async fn find_vertex_by_ext_id( &self, ext_id: &str, ) -> Result<Option<Vid>, Error>

Find a vertex VID by external ID. Uses pinned snapshot HWM if present.

pub async fn find_vertex_labels_by_vid( &self, vid: Vid, ) -> Result<Option<Vec<String>>, Error>

Find labels for a vertex by VID. Uses pinned snapshot HWM if present.

pub async fn find_edges_by_type_names( &self, type_names: &[&str], ) -> Result<Vec<(Eid, Vid, Vid, String, HashMap<String, Value>)>, Error>

Find edges from the main edge table by type names.

pub async fn scan_vertex_candidates( &self, label: &str, filter: Option<&str>, ) -> Result<Vec<Vid>, Error>

Scan vertex candidates matching a filter. Returns VIDs where _deleted = false.

pub fn vertex_dataset(&self, label: &str) -> Result<VertexDataset, Error>

pub fn edge_dataset( &self, edge_type: &str, src_label: &str, dst_label: &str, ) -> Result<EdgeDataset, Error>

pub fn delta_dataset( &self, edge_type: &str, direction: &str, ) -> Result<DeltaDataset, Error>

pub fn adjacency_dataset( &self, edge_type: &str, label: &str, direction: &str, ) -> Result<AdjacencyDataset, Error>

pub fn main_vertex_dataset(&self) -> MainVertexDataset

Get the main vertex dataset for unified vertex storage.

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

pub fn main_edge_dataset(&self) -> MainEdgeDataset

Get the main edge dataset for unified edge storage.

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

pub fn uid_index(&self, label: &str) -> Result<UidIndex, Error>

pub async fn inverted_index( &self, label: &str, property: &str, ) -> Result<InvertedIndex, Error>

pub async fn vector_search( &self, label: &str, property: &str, query: &[f32], k: usize, filter: Option<&str>, ctx: Option<&QueryContext>, ) -> Result<Vec<(Vid, f32)>, Error>

pub async fn fts_search( &self, label: &str, property: &str, query: &str, k: usize, filter: Option<&str>, ctx: Option<&QueryContext>, ) -> Result<Vec<(Vid, f32)>, Error>

Perform a full-text search with BM25 scoring.

Returns vertices matching the search query along with their BM25 scores. Results are sorted by score descending (most relevant first).

Arguments

• label - The label to search within
• property - The property column to search (must have FTS index)
• query - The search query text
• k - Maximum number of results to return
• filter - Optional Lance filter expression
• ctx - Optional query context for visibility checks

Returns

Vector of (Vid, score) tuples, where score is the BM25 relevance score.

pub async fn get_vertex_by_uid( &self, uid: &UniId, label: &str, ) -> Result<Option<Vid>, Error>

pub async fn insert_vertex_with_uid( &self, label: &str, vid: Vid, uid: UniId, ) -> Result<(), Error>

pub async fn load_subgraph( &self, start_vids: &[Vid], edge_types: &[u32], max_hops: usize, direction: Direction, l0: Option<&L0Buffer>, ) -> Result<SimpleGraph, Error>