aeternusdb 1.0.1

An embeddable, persistent key-value store built on an LSM-tree architecture.
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 crate::encoding::{self, EncodingError};
use crate::wal::{Wal, WalData, WalError};
use tracing_subscriber::EnvFilter;

/// WAL header CRC32 size in bytes.
pub const WAL_CRC32_SIZE: usize = std::mem::size_of::<u32>();

/// WAL header size in bytes (everything before records start).
pub const WAL_HDR_SIZE: usize = 20;

/// Dummy record that models a memtable entry — used to verify WAL
/// round-trips of record types with `Option` fields.
#[derive(Debug, PartialEq)]
pub struct MemTableRecord {
    pub key: Vec<u8>,
    pub value: Option<Vec<u8>>,
    pub timestamp: u64,
    pub deleted: bool,
}

impl encoding::Encode for MemTableRecord {
    fn encode_to(&self, buf: &mut Vec<u8>) -> Result<(), EncodingError> {
        encoding::Encode::encode_to(&self.key, buf)?;
        encoding::Encode::encode_to(&self.value, buf)?;
        encoding::Encode::encode_to(&self.timestamp, buf)?;
        encoding::Encode::encode_to(&self.deleted, buf)?;
        Ok(())
    }
}

impl encoding::Decode for MemTableRecord {
    fn decode_from(buf: &[u8]) -> Result<(Self, usize), EncodingError> {
        let mut offset = 0;
        let (key, n) = <Vec<u8>>::decode_from(&buf[offset..])?;
        offset += n;
        let (value, n) = <Option<Vec<u8>>>::decode_from(&buf[offset..])?;
        offset += n;
        let (timestamp, n) = u64::decode_from(&buf[offset..])?;
        offset += n;
        let (deleted, n) = bool::decode_from(&buf[offset..])?;
        offset += n;
        Ok((
            Self {
                key,
                value,
                timestamp,
                deleted,
            },
            offset,
        ))
    }
}

/// Dummy record that models a manifest entry — used to verify WAL
/// round-trips of a structurally different record type.
#[derive(Debug, PartialEq)]
pub struct ManifestRecord {
    pub id: u64,
    pub path: String,
    pub creation_timestamp: u64,
}

impl encoding::Encode for ManifestRecord {
    fn encode_to(&self, buf: &mut Vec<u8>) -> Result<(), EncodingError> {
        encoding::Encode::encode_to(&self.id, buf)?;
        encoding::Encode::encode_to(&self.path, buf)?;
        encoding::Encode::encode_to(&self.creation_timestamp, buf)?;
        Ok(())
    }
}

impl encoding::Decode for ManifestRecord {
    fn decode_from(buf: &[u8]) -> Result<(Self, usize), EncodingError> {
        let mut offset = 0;
        let (id, n) = u64::decode_from(&buf[offset..])?;
        offset += n;
        let (path, n) = String::decode_from(&buf[offset..])?;
        offset += n;
        let (creation_timestamp, n) = u64::decode_from(&buf[offset..])?;
        offset += n;
        Ok((
            Self {
                id,
                path,
                creation_timestamp,
            },
            offset,
        ))
    }
}

/// Initialize tracing subscriber controlled by `RUST_LOG` env var.
/// Safe to call multiple times — only the first call takes effect.
pub fn init_tracing() {
    let _ = tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .with_test_writer()
        .try_init();
}

/// Replay every record from the WAL into a `Vec`.
pub fn collect_iter<T: WalData>(wal: &Wal<T>) -> Result<Vec<T>, WalError> {
    wal.replay_iter()?.collect()
}