Struct WalStorage 

pub struct WalStorage<S> { /* private fields */ }

WAL-wrapped storage that logs all mutations

Implementations

impl<S> WalStorage<S>

pub fn new(inner: S, wal_config: WalConfig) -> Result<Self>

Create a new WAL-wrapped storage

pub fn with_snapshots(self, snapshot_config: SnapshotConfig) -> Result<Self>

Enable snapshot-backed checkpointing. With snapshots, snapshot_and_checkpoint can persist inner state and truncate the log to bound its growth; without them the log is retained in full so a volatile inner can always be replayed (DAK-7428).

pub fn wal(&self) -> &WriteAheadLog

Get WAL reference

pub fn inner(&self) -> &S

Get inner storage reference

pub fn checkpoint(&self) -> Result<u64>

Checkpoint the WAL

impl<S: VectorStorage> WalStorage<S>

pub async fn recover_into_inner(&self) -> Result<usize>

Replay the WAL into the inner storage at startup so a volatile inner (e.g. InMemoryStorage) is fully reconstructed after a crash (DAK-7428). Applies every logged mutation not superseded by a checkpoint, in LSN order; returns the number of entries applied.

pub async fn snapshot_and_checkpoint(&self) -> Result<Option<u64>>

Persist inner state to a durable snapshot, checkpoint the WAL, and truncate the now-snapshotted prefix — bounding log growth. The write gate is held exclusively so no mutation is in flight: the snapshot therefore reflects every write up to current_lsn, making the subsequent truncate crash-safe. A crash at any point still recovers (snapshot + idempotent replay of the retained tail). Returns Ok(None) when snapshots are not enabled.

Trait Implementations

impl<S: VectorStorage> VectorStorage for WalStorage<S>

fn upsert<'life0, 'life1, 'async_trait>( &'life0 self, namespace: &'life1 NamespaceId, vectors: Vec<Vector>, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

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

Store or update vectors in a namespace

fn get<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, namespace: &'life1 NamespaceId, ids: &'life2 [VectorId], ) -> Pin<Box<dyn Future<Output = Result<Vec<Vector>>> + Send + 'async_trait>>

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

Get vectors by IDs

fn get_all<'life0, 'life1, 'async_trait>( &'life0 self, namespace: &'life1 NamespaceId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Vector>>> + Send + 'async_trait>>

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

Get all vectors in a namespace (for brute-force search)

fn get_all_meta<'life0, 'life1, 'async_trait>( &'life0 self, namespace: &'life1 NamespaceId, ) -> Pin<Box<dyn Future<Output = Result<Vec<Vector>>> + Send + 'async_trait>>

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

Get all vectors in a namespace WITHOUT their embedding values (DAK-7387).

fn delete<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, namespace: &'life1 NamespaceId, ids: &'life2 [VectorId], ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

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

Delete vectors by IDs

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

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

Check if namespace exists

fn ensure_namespace<'life0, 'life1, 'async_trait>( &'life0 self, namespace: &'life1 NamespaceId, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Create namespace if it doesn’t exist

fn count<'life0, 'life1, 'async_trait>( &'life0 self, namespace: &'life1 NamespaceId, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

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

Get vector count in namespace

fn dimension<'life0, 'life1, 'async_trait>( &'life0 self, namespace: &'life1 NamespaceId, ) -> Pin<Box<dyn Future<Output = Result<Option<usize>>> + Send + 'async_trait>>

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

Get vector dimension for namespace (None if empty)

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

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

List all namespaces

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

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

Delete a namespace and all its vectors

fn cleanup_expired<'life0, 'life1, 'async_trait>( &'life0 self, namespace: &'life1 NamespaceId, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

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

Clean up expired vectors in a namespace Returns the number of vectors removed

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

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

Clean up expired vectors in all namespaces Returns total number of vectors removed

fn get_page<'life0, 'life1, 'async_trait>( &'life0 self, namespace: &'life1 NamespaceId, offset: usize, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<Vector>>> + Send + 'async_trait>>

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

Retrieve a page of vectors from a namespace for memory-bounded iteration (DAK-5716).

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

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

Best-effort release of derived cache layers held by this storage stack (e.g. the Moka L1 vector cache), called under memory pressure before new work is shed (DAK-7337). Durable data MUST NOT be dropped — only layers that can be transparently repopulated from the source of truth. Default: no-op for backends with no derived layers.