Struct DurableStorage 

pub struct DurableStorage { /* private fields */ }

Durable storage engine with full ACID support

Implementations

impl DurableStorage

pub fn open<P: AsRef<Path>>(path: P) -> Result<Self>

Open or create durable storage at path

pub fn open_with_config<P: AsRef<Path>>( path: P, enable_ordered_index: bool, ) -> Result<Self>

Open with configurable ordered index

When enable_ordered_index is false, saves ~134 ns/op on writes but scan_prefix becomes O(N) instead of O(log N + K)

pub fn open_with_arena<P: AsRef<Path>>(path: P) -> Result<Self>

Open with arena-backed memtable for write-heavy workloads

Uses ArenaMvccMemTable which reduces per-write allocations from 3 to 1. Best for workloads with:

• High write throughput
• Large keys (reduces allocation overhead)
• Minimal concurrent reads during writes

pub fn open_with_full_config<P: AsRef<Path>>( path: P, enable_ordered_index: bool, memtable_type: MemTableType, ) -> Result<Self>

Open with full configuration options

Arguments

• path - Storage directory path
• enable_ordered_index - Enable ordered index for O(log N) scans
• memtable_type - Type of memtable to use (Standard or Arena)

Locking

Acquires an exclusive advisory lock on the database directory. This prevents concurrent multi-process access which would corrupt data. If another process has the database open, returns Err(DatabaseLocked).

pub fn open_with_group_commit<P: AsRef<Path>>(path: P) -> Result<Self>

Open with group commit enabled

pub fn open_with_group_commit_and_config<P: AsRef<Path>>( path: P, enable_ordered_index: bool, ) -> Result<Self>

Open with group commit and configurable ordered index

pub fn open_with_policy<P: AsRef<Path>>( path: P, policy: IndexPolicy, group_commit: bool, ) -> Result<Self>

Open with IndexPolicy for automatic memtable/index configuration

This is the recommended constructor for new code. The policy determines:

• Whether to use ordered index (ScanOptimized only)
• Whether to use arena-backed memtable (WriteOptimized, AppendOnly)
• Default settings optimized for the workload pattern

Arguments

• path - Storage directory path
• policy - Index policy determining write/scan tradeoffs
• group_commit - Whether to enable group commit for throughput

pub fn open_for_concurrent<P: AsRef<Path>>( path: P, policy: IndexPolicy, ) -> Result<Self>

Open storage for concurrent mode (multi-reader, single-writer)

This method opens the storage WITHOUT acquiring the exclusive file lock. Coordination is handled by the concurrent MVCC layer instead.

Safety

This must ONLY be called from Database::open_concurrent() which manages the concurrent MVCC coordination. Direct use will cause data corruption.

pub fn memtable_type(&self) -> MemTableType

Get the memtable type being used

pub fn recover(&self) -> Result<RecoveryStats>

Perform crash recovery

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

Begin a new transaction

pub fn begin_with_mode(&self, mode: TransactionMode) -> Result<u64>

Begin a transaction with a specific mode (ReadOnly/WriteOnly/ReadWrite)

This enables mode-aware optimizations:

• ReadOnly: Skip SSI tracking, 2.6x faster reads
• WriteOnly: Skip read tracking, faster bulk inserts
• ReadWrite: Full SSI for serializable isolation

pub fn read(&self, txn_id: u64, key: &[u8]) -> Result<Option<Vec<u8>>>

Read a key within a transaction

pub fn write(&self, txn_id: u64, key: Vec<u8>, value: Vec<u8>) -> Result<()>

Write a key-value pair within a transaction

Writes are buffered and only flushed to disk on commit. This provides ~10× better throughput for batched inserts.

pub fn write_refs(&self, txn_id: u64, key: &[u8], value: &[u8]) -> Result<()>

Write from references - zero allocation hot path

Avoids cloning key/value by writing to WAL from refs directly, then only allocating once for memtable storage.

pub fn delete(&self, txn_id: u64, key: Vec<u8>) -> Result<()>

Delete a key within a transaction

pub fn write_batch_refs( &self, txn_id: u64, writes: &[(&[u8], &[u8])], ) -> Result<()>

Batch write multiple key-value pairs with reduced overhead

This API amortizes fixed costs over the batch:

• Single DashMap entry lookup for TxnWalBuffer
• Single MVCC write set update
• Batch memtable operations

Performance: ~2-3x faster than individual write_refs calls for batches of 100+ entries.

Arguments

• txn_id - Transaction ID
• writes - Slice of (key, value) pairs

pub fn commit(&self, txn_id: u64) -> Result<u64>

Commit a transaction

With sync_mode:

• 0 (OFF): No sync, risk of data loss
• 1 (NORMAL): Adaptive sync using Little’s Law: W* = √(τ/λ)
• 2 (FULL): Sync every commit (safest, slowest)

pub fn set_sync_mode(&self, mode: u64)

Set synchronous mode

• 0: OFF - No fsync (risk of data loss)
• 1: NORMAL - Periodic fsync (balanced)
• 2: FULL - Fsync every commit (safest)

pub fn flush_group_commit(&self)

Force a group commit flush (useful for benchmarking or testing)

pub fn abort(&self, txn_id: u64) -> Result<()>

Abort a transaction

pub fn scan( &self, txn_id: u64, prefix: &[u8], ) -> Result<Vec<(Vec<u8>, Vec<u8>)>>

Scan keys with prefix

pub fn scan_range( &self, txn_id: u64, start: &[u8], end: &[u8], ) -> Result<Vec<(Vec<u8>, Vec<u8>)>>

Scan keys in range

pub fn scan_range_iter<'a>( &'a self, txn_id: u64, start: &'a [u8], end: &'a [u8], ) -> impl Iterator<Item = (Vec<u8>, Vec<u8>)> + 'a

Streaming scan for very large result sets

Returns an iterator that yields (key, value) pairs without materializing the entire result set in memory.

pub fn fsync(&self) -> Result<()>

Force fsync to disk

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

Write checkpoint

pub fn stats(&self) -> StorageStats

Get storage statistics

pub fn gc(&self) -> usize

Garbage collect old versions

pub fn shutdown(&self) -> Result<()>

Clean shutdown

Trait Implementations

impl Drop for DurableStorage

fn drop(&mut self)

Executes the destructor for this type.