shunyadb 0.1.0

A correctness-first embedded storage engine written in Rust, built around WAL, immutable LSM pages, MVCC, and deterministic crash recovery.
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

use std::collections::BTreeMap;
use crate::storage::record::{FieldValue, Record};

#[derive(Debug)]
pub struct MemTable {
  pub data: BTreeMap<String, Vec<Record>>,
}

impl MemTable {
  pub fn new() -> Self {
    Self {
      data: BTreeMap::new(),
    }
  }

  pub fn put(&mut self, record: Record) {
    self.data.entry(record.id.clone()).or_default().push(record);
  }

  pub fn get(&self, id: &str, snapshot_seqno: u64) -> Option<&Record> {
    let versions = self.data.get(id)?;

    for record in versions.iter().rev() {
        if record.seqno <= snapshot_seqno {
            if record.is_tombstone {
                return None;
            } else {
                return Some(record);
            }
        }
    }

    None
  }

  pub fn len(&self) -> usize {
    self.data.len()
  }

  pub fn is_empty(&self) -> bool {
    self.data.is_empty()
  }

  pub fn iter(&self) -> impl Iterator<Item = (&String, &Vec<Record>)> {
    self.data.iter()
  }

  pub fn clear(&mut self) {
    self.data.clear();
  }

  pub fn approx_size_bytes(&self) -> usize {
    let mut size = 0;

    for (key, versions) in &self.data {
      // Key size
      size += key.len();

      // Value Size
      size += std::mem::size_of::<Vec<Record>>();

      for record in versions {
        size += std::mem::size_of::<Record>();

        size += record.id.len();

        for (field, value) in &record.data {
          size += field.len();

          size += match value {
            FieldValue::Str(s) => s.len(),
            FieldValue::Int(_) => std::mem::size_of::<i64>(),
            FieldValue::Bool(_) => std::mem::size_of::<bool>(),
            FieldValue::Float(_) => std::mem::size_of::<f64>(),
            FieldValue::Null => 0,
            FieldValue::UInt(_) => std::mem::size_of::<u64>(),
          };
        }
      }
    }
    size
  }

}

#[cfg(test)]
mod tests;