mmdb 4.2.3

The storage engine behind vsdb — a pure-Rust LSM-Tree key-value store
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

//! Canonical MMDB usage: open, write, read, batch, snapshot, iterate, delete.
//!
//! Run with: `cargo run --example basic`

use mmdb::{DB, DbOptions, ErrorKind, ReadOptions, WriteBatch, WriteOptions};

fn main() -> mmdb::Result<()> {
    let dir = tempfile::tempdir().expect("tempdir");

    // --- Open (presets: DbOptions::balanced/write_heavy/read_heavy) ---
    let opts = DbOptions {
        create_if_missing: true,
        ..DbOptions::balanced()
    };
    let db = DB::open(opts, dir.path())?;

    // --- Point writes & reads ---
    db.put(b"user:alice", b"1000")?;
    db.put(b"user:bob", b"2000")?;
    assert_eq!(db.get(b"user:alice")?, Some(b"1000".to_vec()));

    // Durable write: fsync WAL before acknowledging.
    let sync_opts = WriteOptions {
        sync: true,
        ..Default::default()
    };
    db.put_with_options(&sync_opts, b"user:carol", b"3000")?;

    // --- Atomic batch ---
    let mut batch = WriteBatch::new();
    batch.put(b"acct:1", b"open");
    batch.put(b"acct:2", b"open");
    batch.delete(b"user:bob");
    db.write(batch)?;
    assert_eq!(db.get(b"user:bob")?, None);

    // --- Snapshot: consistent point-in-time reads (RAII guard) ---
    let snap = db.snapshot();
    db.put(b"user:alice", b"9999")?;
    assert_eq!(
        db.get_with_options(&snap.read_options(), b"user:alice")?,
        Some(b"1000".to_vec()),
        "snapshot sees the old value"
    );
    assert_eq!(db.get(b"user:alice")?, Some(b"9999".to_vec()));
    drop(snap); // releases the snapshot so compaction may reclaim old versions

    // --- Prefix iteration (bloom-filter pruned) ---
    let mut user_iter = db.iter_with_prefix(b"user:", &ReadOptions::default())?;
    let users: Vec<_> = user_iter.by_ref().collect();
    if let Some(error) = user_iter.error() {
        return Err(mmdb::Error::io(std::io::Error::other(error)));
    }
    println!("{} keys under user:", users.len());

    // --- Range iteration [acct:1, acct:9) with SST pruning ---
    // fill_cache=false keeps a one-shot scan from evicting hot blocks.
    let scan_opts = ReadOptions {
        fill_cache: false,
        ..Default::default()
    };
    let mut range_iter = db.iter_with_range(&scan_opts, Some(b"acct:1"), Some(b"acct:9"))?;
    for (k, v) in range_iter.by_ref() {
        println!("{} = {}", String::from_utf8_lossy(&k), v.len());
    }
    if let Some(error) = range_iter.error() {
        return Err(mmdb::Error::io(std::io::Error::other(error)));
    }

    // --- Range deletion ---
    db.delete_range(b"acct:1", b"acct:9")?;
    assert_eq!(db.get(b"acct:1")?, None);

    // --- Typed error handling ---
    match DB::open(
        DbOptions {
            num_levels: 0, // invalid on purpose
            ..Default::default()
        },
        dir.path().join("bad"),
    ) {
        Err(e) if e.kind() == ErrorKind::InvalidArgument => {
            println!("rejected as expected:\n{e}");
        }
        Err(e) => panic!("expected InvalidArgument, got {e:?}"),
        Ok(_) => panic!("expected InvalidArgument, got Ok"),
    }

    db.flush()?;
    Ok(())
}