coordinode-lsm-tree 7.4.1

Embedded LSM-tree storage engine in pure Rust, no C/C++ dependency. MVCC snapshots, BuRR filters, zstd dictionary compression, columnar PAX blocks, AES-256-GCM at rest, self-healing per-block ECC, compaction on a near-full disk, no_std support.
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

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026-present, Dmitry Prudnikov

use super::take_versions;
use crate::{InternalValue, ValueType};

fn version(seqno: u64, value_type: ValueType) -> InternalValue {
    InternalValue::from_components(b"k" as &[u8], b"v" as &[u8], seqno, value_type)
}

/// A source's versions are taken down to its first base; the older ones it
/// hides are left unread.
#[test]
fn take_versions_stops_at_the_first_base() -> crate::Result<()> {
    let mut entries = Vec::new();
    let read = core::cell::Cell::new(0);
    take_versions(
        [
            version(9, ValueType::MergeOperand),
            version(8, ValueType::MergeOperand),
            version(7, ValueType::Tombstone),
            version(6, ValueType::Value),
        ]
        .into_iter()
        .inspect(|_| read.set(read.get() + 1))
        .map(Ok),
        4,
        &mut entries,
    )?;
    let seqnos: Vec<u64> = entries.iter().map(|(_, e)| e.key.seqno).collect();
    assert_eq!(seqnos, [9, 8, 7]);
    assert!(
        entries.iter().all(|&(rank, _)| rank == 4),
        "each version keeps its source's rank"
    );
    assert_eq!(read.get(), 3, "the version below the base is not read");
    Ok(())
}

/// A source holding only operands is taken whole.
#[test]
fn take_versions_takes_every_operand_without_a_base() -> crate::Result<()> {
    let mut entries = Vec::new();
    take_versions(
        [
            version(3, ValueType::MergeOperand),
            version(2, ValueType::MergeOperand),
        ]
        .into_iter()
        .map(Ok),
        0,
        &mut entries,
    )?;
    assert_eq!(entries.len(), 2);
    Ok(())
}

/// A failed read ends the take with its error, keeping what came before.
#[test]
fn take_versions_returns_the_error_of_a_failed_read() {
    let mut entries = Vec::new();
    let result = take_versions(
        [
            Ok(version(5, ValueType::MergeOperand)),
            Err(crate::Error::Unrecoverable),
            Ok(version(3, ValueType::Value)),
        ]
        .into_iter(),
        0,
        &mut entries,
    );
    assert!(matches!(result, Err(crate::Error::Unrecoverable)));
    assert_eq!(entries.len(), 1);
}