candystore 1.0.0

A lean, efficient and fast persistent in-process 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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

mod common;

use candystore::{CandyStore, Config, Error, SetStatus};
use tempfile::tempdir;

#[test]
fn test_many_inserts_trigger_splits() -> Result<(), Error> {
    const KEYS: usize = 5000;

    let dir = tempdir().unwrap();
    let db = CandyStore::open(dir.path(), Config::default())?;

    for key_idx in 0..KEYS {
        let key = format!("split_key_{key_idx:05}");
        let value = format!("split_val_{key_idx:05}");
        assert!(matches!(db.set(&key, &value)?, SetStatus::CreatedNew));
    }

    for key_idx in 0..KEYS {
        let key = format!("split_key_{key_idx:05}");
        let value = format!("split_val_{key_idx:05}");
        assert_eq!(db.get(&key)?, Some(value.into()));
    }

    Ok(())
}

#[test]
fn test_rotation_preserves_reads() -> Result<(), Error> {
    let dir = tempdir().unwrap();
    let db = CandyStore::open(dir.path(), common::small_file_config())?;

    for key_idx in 0..512 {
        let key = format!("rotate_key_{key_idx:04}");
        let value = format!("rotate_val_{key_idx:04}_{}", "x".repeat(64));
        assert!(matches!(db.set(&key, &value)?, SetStatus::CreatedNew));
    }

    for key_idx in 0..512 {
        let key = format!("rotate_key_{key_idx:04}");
        assert!(db.get(&key)?.is_some(), "missing key after rotation: {key}");
    }

    Ok(())
}

#[test]
fn test_new_data_files_are_preallocated() -> Result<(), Error> {
    let dir = tempdir().unwrap();
    let config = common::small_file_config();
    let db = CandyStore::open(dir.path(), config)?;

    let file_len = std::fs::metadata(dir.path().join("data_0000"))
        .map_err(Error::IOError)?
        .len();
    assert_eq!(file_len, 4096 + config.max_data_file_size as u64);

    db.set("prealloc", [7u8; 128])?;
    drop(db);

    let reopened_len = std::fs::metadata(dir.path().join("data_0000"))
        .map_err(Error::IOError)?
        .len();
    assert_eq!(reopened_len, 4096 + config.max_data_file_size as u64);

    Ok(())
}

#[test]
fn test_splits_and_rotation_with_small_files() -> Result<(), Error> {
    const KEYS: usize = 5000;

    let dir = tempdir().unwrap();
    let db = CandyStore::open(dir.path(), common::small_file_config())?;

    for key_idx in 0..KEYS {
        let key = format!("split_rotate_key_{key_idx:05}");
        let value = format!("split_rotate_val_{key_idx:05}_{}", "x".repeat(48));
        assert!(matches!(db.set(&key, &value)?, SetStatus::CreatedNew));
    }

    for key_idx in 0..KEYS {
        let key = format!("split_rotate_key_{key_idx:05}");
        let value = format!("split_rotate_val_{key_idx:05}_{}", "x".repeat(48));
        assert_eq!(db.get(&key)?, Some(value.into()));
    }

    let data_file_count = std::fs::read_dir(dir.path())
        .map_err(Error::IOError)?
        .filter_map(|entry| entry.ok())
        .filter(|entry| {
            entry
                .file_name()
                .to_str()
                .is_some_and(|name| name.starts_with("data_"))
        })
        .count();
    assert!(
        data_file_count > 1,
        "expected rotation to create multiple data files"
    );

    let index_rows_size = std::fs::metadata(dir.path().join("rows"))
        .map_err(Error::IOError)?
        .len();
    assert!(
        index_rows_size > 4 * 4096,
        "expected index rows growth after row splitting, got rows size {index_rows_size}"
    );

    Ok(())
}

#[test]
fn test_splits_rotation_and_reopen_with_small_files() -> Result<(), Error> {
    const KEYS: usize = 5000;

    let dir = tempdir().unwrap();

    {
        let db = CandyStore::open(dir.path(), common::small_file_config())?;
        for key_idx in 0..KEYS {
            let key = format!("reopen_split_rotate_key_{key_idx:05}");
            let value = format!("reopen_split_rotate_val_{key_idx:05}_{}", "x".repeat(48));
            assert!(matches!(db.set(&key, &value)?, SetStatus::CreatedNew));
        }
    }

    let db = CandyStore::open(dir.path(), common::small_file_config())?;
    for key_idx in 0..KEYS {
        let key = format!("reopen_split_rotate_key_{key_idx:05}");
        let value = format!("reopen_split_rotate_val_{key_idx:05}_{}", "x".repeat(48));
        assert_eq!(db.get(&key)?, Some(value.into()));
    }

    let data_file_count = std::fs::read_dir(dir.path())
        .map_err(Error::IOError)?
        .filter_map(|entry| entry.ok())
        .filter(|entry| {
            entry
                .file_name()
                .to_str()
                .is_some_and(|name| name.starts_with("data_"))
        })
        .count();
    assert!(
        data_file_count > 1,
        "expected rotation to persist multiple data files after reopen"
    );

    Ok(())
}