velarixdb 0.0.17

An LSM Storage Engine focused on reduced IO amplification
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

use crate::db::DataStore;
use crate::err::Error;
use crate::memtable::Entry;
use crate::types::{Key, ValOffset, Value};
use crate::vlog::ValueLog;

#[derive(Debug, Clone)]
pub struct FetchedEntry {
    pub key: Key,
    pub val: Value,
}

#[derive(Debug, Clone)]
pub struct RangeIterator<'a> {
    pub start: &'a [u8],
    pub current: usize,
    pub end: &'a [u8],
    pub allow_prefetch: bool,
    pub prefetch_entries_size: usize,
    pub prefetch_entries: Vec<FetchedEntry>,
    pub keys: Vec<Entry<Key, ValOffset>>,
    pub v_log: ValueLog,
}

impl<'a> RangeIterator<'a> {
    fn new(
        start: &'a [u8],
        end: &'a [u8],
        allow_prefetch: bool,
        prefetch_entries_size: usize,
        keys: Vec<Entry<Key, ValOffset>>,
        v_log: ValueLog,
    ) -> Self {
        Self {
            start,
            current: 0,
            end,
            allow_prefetch,
            prefetch_entries_size,
            prefetch_entries: Vec::new(),
            keys,
            v_log,
        }
    }
}

impl<'a> DataStore<'a, Key> {
    // TODO: range query, add next and previous method
    pub async fn seek(&self, _: &'a [u8], _: &'a [u8]) -> Result<RangeIterator, Error> {
        let range_iterator = RangeIterator::<'a>::new(
            &[1],
            &[2],
            self.config.allow_prefetch,
            self.config.prefetch_size,
            Merger::new().entries,
            self.val_log.clone(),
        );
        Ok(range_iterator)
    }
}
pub struct Merger {
    entries: Vec<Entry<Key, ValOffset>>,
}
impl Merger {
    fn new() -> Self {
        Self { entries: Vec::new() }
    }
}