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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use super::super::scanner::Scanner;
use super::*;
use crate::{Slice, fs::StdFs, vlog::blob_file::writer::Writer as BlobFileWriter};
use tempfile::tempdir;
use test_log::test;

#[test]
fn blob_file_merger_seqno() -> crate::Result<()> {
    let dir = tempdir()?;

    let blob_file_path = dir.path().join("0");
    {
        {
            let mut writer = BlobFileWriter::new(&blob_file_path, 0, 0, &StdFs)?;

            writer.write(b"a", 1, &b"1".repeat(100))?;
            writer.write(b"a", 0, &b"0".repeat(100))?;

            writer.finish()?;
        }
    }

    {
        let mut merger = MergeScanner::new(vec![Scanner::new(&blob_file_path, &StdFs, 0)?]);

        assert_eq!(
            (Slice::from(b"a"), Slice::from(b"1".repeat(100))),
            merger
                .next()
                .map(|result| result.map(|(entry, _)| (entry.key, entry.value)))
                .unwrap()?,
        );
        assert_eq!(
            (Slice::from(b"a"), Slice::from(b"0".repeat(100))),
            merger
                .next()
                .map(|result| result.map(|(entry, _)| (entry.key, entry.value)))
                .unwrap()?,
        );

        assert!(merger.next().is_none());
    }

    Ok(())
}

#[test]
fn blob_file_merger() -> crate::Result<()> {
    let dir = tempdir()?;

    let blob_file_0_path = dir.path().join("0");
    let blob_file_1_path = dir.path().join("1");

    {
        let keys = [b"a", b"c", b"e"];

        {
            let mut writer = BlobFileWriter::new(&blob_file_0_path, 0, 0, &StdFs)?;

            for key in keys {
                writer.write(key, 0, &key.repeat(100))?;
            }

            writer.finish()?;
        }
    }

    {
        let keys = [b"b", b"d"];

        {
            let mut writer = BlobFileWriter::new(&blob_file_1_path, 1, 0, &StdFs)?;

            for key in keys {
                writer.write(key, 1, &key.repeat(100))?;
            }

            writer.finish()?;
        }
    }

    {
        let mut merger = MergeScanner::new(vec![
            Scanner::new(&blob_file_0_path, &StdFs, 0)?,
            Scanner::new(&blob_file_1_path, &StdFs, 1)?,
        ]);

        let merged_keys = [b"a", b"b", b"c", b"d", b"e"];

        for key in merged_keys {
            assert_eq!(
                (Slice::from(key), Slice::from(key.repeat(100))),
                merger
                    .next()
                    .map(|result| result.map(|(entry, _)| (entry.key, entry.value)))
                    .unwrap()?,
            );
        }

        assert!(merger.next().is_none());
    }

    Ok(())
}