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( base_uri: &str, schema_manager: Arc<SchemaManager>, ) -> Result<Self>

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

Create a new StorageManager with custom cache size.

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

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

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

This is used by higher layers that need explicit store configuration (for example custom S3 endpoints in hybrid/cloud modes).

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

Create a new StorageManager using an already-constructed object store and explicit LanceDB storage options.

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

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>

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

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

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

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

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

Get or open a cached table for a label

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

Invalidate cached table (call after writes)

pub fn clear_table_cache(&self)

Clear all cached tables

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<()>

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<()>

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 lancedb_store(&self) -> &LanceDbStore

Get the LanceDB store.

pub fn lancedb_store_arc(&self) -> Arc<LanceDbStore>

Get the LanceDB store 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: GraphDirection, _l0: Option<Arc<RwLock<L0Buffer>>>, ) -> Result<WorkingGraph>

pub fn snapshot_manager(&self) -> &SnapshotManager

pub fn index_manager(&self) -> IndexManager

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

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

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

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

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>

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

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

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

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

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

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