lsm 0.4.1

An implementation of log-structured merge trees in pure Rust
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

#[cfg(feature = "async-io")]
use tokio_uring::test as async_test;

#[cfg(not(feature = "async-io"))]
use tokio::test as async_test;

use super::*;

use tempfile::{Builder, TempDir};

async fn test_init() -> (TempDir, ValueLog) {
    let tmp_dir = Builder::new()
        .prefix("lsm-value-log-test-")
        .tempdir()
        .unwrap();
    let _ = env_logger::builder().is_test(true).try_init();

    let params = Params {
        db_path: tmp_dir.path().to_path_buf(),
        ..Default::default()
    };

    let params = Arc::new(params);
    let manifest = Arc::new(Manifest::new(params.clone()).await);

    (tmp_dir, ValueLog::new(params, manifest).await)
}

#[async_test]
async fn delete_value() {
    const SIZE: usize = 1_000;

    let (_tmpdir, values) = test_init().await;

    let mut builder = values.make_batch().await;

    let mut data = vec![];
    data.resize(SIZE, b'a');

    let _ = builder.add_value(data.clone()).await;
    let vid2 = builder.add_value(data.clone()).await;

    let batch_id = builder.finish().await.unwrap();

    let batch = values.get_batch(batch_id).await.unwrap();
    assert_eq!(batch.num_active_values(), 2);
    assert_eq!(batch.total_num_values(), 2);

    values.mark_value_deleted(vid2).await.unwrap();
    let batch = values.get_batch(batch_id).await.unwrap();

    assert_eq!(batch.num_active_values(), 1);
    assert_eq!(batch.total_num_values(), 2);
}

#[async_test]
async fn delete_batch() {
    const SIZE: usize = 1_000;

    let (_tmpdir, values) = test_init().await;
    let mut builder = values.make_batch().await;

    let mut data = vec![];
    data.resize(SIZE, b'a');

    let vid = builder.add_value(data).await;

    let batch_id = builder.finish().await.unwrap();
    let batch = values.get_batch(batch_id).await.unwrap();

    assert_eq!(batch.num_active_values(), 1);
    assert_eq!(batch.total_num_values(), 1);

    values.mark_value_deleted(vid).await.unwrap();

    let result = values.get_batch(batch_id).await;
    assert!(result.is_err());
}

#[async_test]
async fn get_put_many() {
    let (_tmpdir, values) = test_init().await;

    let mut builder = values.make_batch().await;
    let mut vids = vec![];

    for pos in 0..1000u32 {
        let value = format!("Number {pos}").into_bytes();
        let vid = builder.add_value(value).await;
        vids.push(vid);
    }

    builder.finish().await.unwrap();

    for (pos, vid) in vids.iter().enumerate() {
        let value = format!("Number {pos}").into_bytes();

        let result = values.get_ref(*vid).await.unwrap();
        assert_eq!(result.get_value(), value);
    }
}

#[async_test]
async fn fold() {
    let (_tmpdir, values) = test_init().await;

    let mut vids = vec![];
    let mut builder = values.make_batch().await;

    for pos in 0..20u32 {
        let value = format!("Number {pos}").into_bytes();
        let vid = builder.add_value(value).await;
        vids.push(vid);
    }

    let batch_id = builder.finish().await.unwrap();

    for value_id in vids.iter().take(19).skip(2) {
        values.mark_value_deleted(*value_id).await.unwrap();
    }

    let batch = values.get_batch(batch_id).await.unwrap();
    assert!(batch.is_folded());
    assert_eq!(batch.num_active_values(), 3);

    for pos in [0u32, 1u32, 19u32] {
        let vid = vids[pos as usize];
        let value = format!("Number {pos}").into_bytes();

        let result = values.get_ref(vid).await.unwrap();
        assert_eq!(result.get_value(), value);
    }
}

#[async_test]
async fn get_put_large_value() {
    let (_tmpdir, values) = test_init().await;

    const SIZE: usize = 1_000_000;
    let mut builder = values.make_batch().await;

    let mut data = vec![];
    data.resize(SIZE, b'a');

    let vid = builder.add_value(data.clone()).await;

    builder.finish().await.unwrap();

    assert!(values.get_ref(vid).await.unwrap().get_value() == data);
}