Struct ConstMap 

pub struct ConstMap<K: Key + Send + Sync + Hash + Eq, const V: usize, D: Durability = Bitcask, H: WriteHook<K> = NoHook> { /* private fields */ }

A map with fixed-size keys and values. All values are stored inline in a per-shard HashMap. Reads never touch disk — zero I/O reads. O(1) lookup instead of O(log n) SkipList. No ordered iteration — use ConstTree if you need prefix/range scans.

Generic over D: Durability (default: Bitcask). Use Fixed backend for frequent updates without compaction (FixedMap is a type alias for ConstMap<K, V, Fixed>).

Each ConstMap owns its storage engine — one map = one database directory.

Write hooks

Uses WriteHook<K>. on_write fires on put/insert/delete/cas/update. Does not fire inside atomic(). on_init fires once per live entry during migrate() or replay_init(). Old value is always provided in on_write — NEEDS_OLD_VALUE is ignored (value is inline, zero cost).

Implementations

impl<K: Key + Send + Sync + Hash + Eq, const V: usize> ConstMap<K, V, Bitcask>

pub fn open(path: impl AsRef<Path>, config: Config) -> DbResult<Self>

Open or create a ConstMap at the given path. Recovers the index from existing data files on disk.

impl<K: Key + Send + Sync + Hash + Eq, const V: usize, H: WriteHook<K>> ConstMap<K, V, Bitcask, H>

pub fn open_hooked( path: impl AsRef<Path>, config: Config, hook: H, ) -> DbResult<Self>

Open or create a ConstMap with a write hook for secondary index maintenance.

pub fn close(self) -> DbResult<()>

Graceful shutdown: write hint files (if enabled), flush write buffers + fsync.

pub fn flush_buffers(&self) -> DbResult<()>

Flush all shard write buffers to disk (without fsync).

pub fn config(&self) -> &Config

Get the database configuration.

pub fn compact(&self) -> DbResult<usize>

Trigger a compaction pass across all shards.

pub fn sync_hints(&self) -> DbResult<()>

Write hint files for all active shard files. Call during graceful shutdown.

pub fn migrate( &self, f: impl Fn(&K, &[u8; V]) -> MigrateAction<[u8; V]>, ) -> DbResult<usize>

Iterate all entries and optionally mutate them. Call once at startup.

Fires on_init for Keep/Update (if NEEDS_INIT). on_write is never fired during migration. Returns the number of mutated entries.

impl<K: Key + Send + Sync + Hash + Eq, const V: usize> ConstMap<K, V, Fixed>

pub fn open(path: impl AsRef<Path>, config: FixedConfig) -> DbResult<Self>

Open or create a ConstMap with Fixed (fixed-slot) backend. Recovers the index from existing data files on disk.

impl<K: Key + Send + Sync + Hash + Eq, const V: usize, H: WriteHook<K>> ConstMap<K, V, Fixed, H>

pub fn open_with_hook( path: impl AsRef<Path>, config: FixedConfig, hook: H, ) -> DbResult<Self>

Open or create a ConstMap with a write hook, using Fixed (fixed-slot) backend.

pub fn close(self) -> DbResult<()>

Perform a clean shutdown (Fixed backend).

impl<K: Key + Send + Sync + Hash + Eq, const V: usize, D: Durability, H: WriteHook<K>> ConstMap<K, V, D, H>

pub fn get(&self, key: &K) -> Option<[u8; V]>

Get a value by key. O(1) HashMap lookup, zero disk I/O.

pub fn get_or_err(&self, key: &K) -> DbResult<[u8; V]>

Get a value by key, returning Err(KeyNotFound) if absent.

pub fn put(&self, key: &K, value: &[u8; V]) -> DbResult<Option<[u8; V]>>

Insert or update a key-value pair. Returns the old value if the key existed.

pub fn insert(&self, key: &K, value: &[u8; V]) -> DbResult<()>

Insert a key-value pair only if the key does not exist. Returns Err(KeyExists) if the key is already present.

pub fn delete(&self, key: &K) -> DbResult<Option<[u8; V]>>

Delete a key. Returns the old value if the key existed.

pub fn cas( &self, key: &K, expected: &[u8; V], new_value: &[u8; V], ) -> DbResult<()>

Compare-and-swap: if current value == expected, replace with new_value. Returns Ok(()) on success, Err(CasMismatch) if current != expected, Err(KeyNotFound) if key doesn’t exist.

pub fn update( &self, key: &K, f: impl FnOnce(&[u8; V]) -> [u8; V], ) -> DbResult<Option<[u8; V]>>

Atomically read-modify-write. Returns Some(new_value) if key existed, None otherwise. The closure must not be heavy (shard lock is held).

pub fn fetch_update( &self, key: &K, f: impl FnOnce(&[u8; V]) -> [u8; V], ) -> DbResult<Option<[u8; V]>>

Like update(), but returns Some(old_value) instead of the new one.

pub fn contains(&self, key: &K) -> bool

Check if a key exists.

pub fn len(&self) -> usize

Total number of entries across all shards.

pub fn is_empty(&self) -> bool

pub fn atomic<R>( &self, shard_key: &K, f: impl FnOnce(&mut ConstMapShard<'_, K, V, D, H>) -> DbResult<R>, ) -> DbResult<R>

Atomically execute multiple operations on a single shard. All keys must route to the same shard as shard_key. The closure must be short — shard lock is held for its duration.

pub fn shard_for(&self, key: &K) -> usize

pub fn flush(&self) -> DbResult<()>

Flush the durability backend.

Trait Implementations

impl<K: Key + Send + Sync + Hash + Eq, const V: usize, H: WriteHook<K>> CompactionIndex<K> for ConstMap<K, V, Bitcask, H>

fn update_if_match(&self, key: &K, old_loc: DiskLoc, new_loc: DiskLoc) -> bool

If the current index points to old_loc, it is updated to new_loc and returns true.

fn contains_key(&self, key: &K) -> bool

Returns true if the key currently exists in the index (i.e. has a live Put).

fn invalidate_blocks(&self, _shard_id: u8, _file_id: u32, _total_bytes: u64)

Invalidate cached blocks for a file after compaction replaces its contents.

impl<K: Key + Send + Sync + Hash + Eq, const V: usize, H: WriteHook<K>> ReplicationTarget for ConstMap<K, V, Bitcask, H>

Available on crate feature replication only.

fn apply_entry( &self, shard_id: u8, file_id: u32, entry_offset: u64, header: &EntryHeader, key: &[u8], value: &[u8], ) -> DbResult<()>

Apply entry with known key/value split (streaming mode, O(1) routing).

fn try_apply_entry( &self, shard_id: u8, file_id: u32, entry_offset: u64, header: &EntryHeader, raw_after_header: &[u8], ) -> DbResult<bool>

Try to apply entry with CRC matching (catch-up mode). Returns true if CRC matched and entry was applied.

fn key_len(&self) -> usize

The key length (K) for this tree type.