armdb 0.1.10

sharded bitcask key-value storage optimized for NVMe
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

#![cfg(feature = "var-collections")]

use armdb::{Config, VarTree};
use tempfile::tempdir;

#[test]
fn test_compaction_var_tree() {
    let dir = tempdir().unwrap();
    let mut config = Config::test();
    config.max_file_size = 4096; // very small file size to force rotation
    config.compaction_threshold = 0.1; // low threshold to force compaction

    let tree = VarTree::<[u8; 8]>::open(dir.path(), config).unwrap();

    // Write some entries
    for i in 0..1000u64 {
        let key = i.to_be_bytes();
        tree.put(&key, &key).unwrap();
    }

    // Overwrite half of them
    for i in 0..500u64 {
        let key = i.to_be_bytes();
        let val = (i + 1).to_be_bytes();
        tree.put(&key, &val).unwrap();
    }

    println!("Tree len before compaction: {}", tree.len());

    // Check data BEFORE compaction
    for i in 0..1000u64 {
        let key = i.to_be_bytes();
        assert!(
            tree.get(&key).is_some(),
            "Key not found BEFORE compaction: {}",
            i
        );
    }

    // Trigger compaction
    let _compacted = tree.compact().unwrap();

    println!("Tree len after compaction: {}", tree.len());

    // Check data integrity
    for i in 0..1000u64 {
        let key = i.to_be_bytes();
        let expected = if i < 500 {
            (i + 1).to_be_bytes()
        } else {
            i.to_be_bytes()
        };
        let val = tree.get(&key).unwrap_or_else(|| {
            let mut keys = Vec::new();
            for k in tree.prefix_iter(&[]).collect_keys() {
                keys.push(u64::from_be_bytes(k));
            }
            keys.sort();
            panic!("Key not found: i={}. All keys: {:?}", i, keys);
        });
        assert_eq!(val.as_bytes(), &expected);
    }
}