coordinode-lsm-tree 5.7.0

Embedded LSM-tree storage engine: BuRR filters, zstd dictionary compression, MVCC, range tombstones, merge operators, K/V separation, AES-256-GCM at rest.
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

use crate::{AbstractTree, Config, MAX_SEQNO, SequenceNumberCounter};
use test_log::test;

#[test]
fn cache_stats_reports_capacity_and_counts_after_reads() -> crate::Result<()> {
    let dir = tempfile::tempdir()?;
    let tree = Config::new(
        dir.path(),
        SequenceNumberCounter::default(),
        SequenceNumberCounter::default(),
    )
    .open()?;

    // Empty cache: a configured capacity, but nothing loaded yet.
    let before = tree.cache_stats();
    assert!(
        before.capacity_bytes > 0,
        "the default block cache has a capacity",
    );
    assert_eq!(
        before.hits + before.misses,
        0,
        "no block has been loaded yet",
    );
    assert!(
        (before.hit_rate - 1.0).abs() < f64::EPSILON,
        "no miss yet, so the rate is 1.0",
    );

    // Flush an SST and read every key back so data / index / filter blocks flow
    // through the cache.
    for i in 0..200u32 {
        tree.insert(format!("k{i:04}"), "v", 0);
    }
    tree.flush_active_memtable(0)?;
    for i in 0..200u32 {
        assert!(tree.get(format!("k{i:04}"), MAX_SEQNO)?.is_some());
    }

    let after = tree.cache_stats();
    assert!(
        after.hits + after.misses > 0,
        "reads should have loaded blocks through the cache",
    );
    assert!(
        after.size_bytes <= after.capacity_bytes,
        "resident size stays within capacity",
    );
    assert_eq!(
        after.capacity_bytes, before.capacity_bytes,
        "capacity is stable across reads",
    );

    Ok(())
}

#[test]
fn cache_stats_works_for_kv_separated_tree() -> crate::Result<()> {
    // A KV-separated (blob) tree dispatches cache_stats to BlobTree, which
    // delegates to its index tree. Large values land in blob files.
    let dir = tempfile::tempdir()?;
    let tree = Config::new(
        dir.path(),
        SequenceNumberCounter::default(),
        SequenceNumberCounter::default(),
    )
    .with_kv_separation(Some(crate::KvSeparationOptions::default()))
    .open()?;
    for i in 0..50u32 {
        tree.insert(format!("k{i:04}"), vec![0u8; 4096], 0);
    }
    tree.flush_active_memtable(0)?;
    for i in 0..50u32 {
        assert!(tree.get(format!("k{i:04}"), MAX_SEQNO)?.is_some());
    }

    let cs = tree.cache_stats();
    assert!(cs.capacity_bytes > 0, "the block cache has a capacity");
    assert!(
        cs.size_bytes <= cs.capacity_bytes,
        "resident size stays within capacity",
    );
    Ok(())
}