tonbo 0.4.0-a1

Embedded database for serverless and edge runtimes, storing data as Parquet on S3
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Composite `(key, timestamp)` helpers used by MVCC-aware structures.

use std::{
    cmp::Ordering,
    hash::{Hash, Hasher},
};

use super::{KeyOwned, KeyRow};
use crate::mvcc::Timestamp;

/// Borrowed composite key pairing a raw key view with its commit timestamp.
#[derive(Clone, Debug)]
pub struct KeyTsViewRaw {
    key: KeyRow,
    ts: Timestamp,
}

impl KeyTsViewRaw {
    /// Build a new `(key, timestamp)` view from a key row.
    pub(crate) fn new(key: KeyRow, ts: Timestamp) -> Self {
        Self { key, ts }
    }

    /// Build a raw view derived from an owned key. Safe because the owned key
    /// retains the backing buffers.
    pub(crate) fn from_owned(key: &KeyOwned, ts: Timestamp) -> Self {
        let key_row =
            KeyRow::from_owned(key).expect("KeyOwned should only contain supported key components");
        Self::new(key_row, ts)
    }

    /// Borrow the key component.
    pub(crate) fn key(&self) -> &KeyRow {
        &self.key
    }

    /// Commit timestamp carried by the entry.
    pub(crate) fn timestamp(&self) -> Timestamp {
        self.ts
    }

    /// Decompose the view.
    pub(crate) fn into_parts(self) -> (KeyRow, Timestamp) {
        (self.key, self.ts)
    }
}

impl PartialEq for KeyTsViewRaw {
    fn eq(&self, other: &Self) -> bool {
        self.ts == other.ts && self.key == other.key
    }
}

impl Eq for KeyTsViewRaw {}

impl PartialOrd for KeyTsViewRaw {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for KeyTsViewRaw {
    fn cmp(&self, other: &Self) -> Ordering {
        match self.key.cmp(&other.key) {
            Ordering::Equal => other.ts.cmp(&self.ts),
            ordering => ordering,
        }
    }
}

impl Hash for KeyTsViewRaw {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.key.hash(state);
        self.ts.hash(state);
    }
}

/// Owned `(key, timestamp)` pair.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct KeyTsOwned {
    key: KeyOwned,
    ts: Timestamp,
}

impl KeyTsOwned {
    /// Construct an owned composite key.
    pub(crate) fn new(key: KeyOwned, ts: Timestamp) -> Self {
        Self { key, ts }
    }

    /// Borrow the owned key.
    pub(crate) fn key(&self) -> &KeyOwned {
        &self.key
    }

    /// Commit timestamp carried by the entry.
    pub(crate) fn timestamp(&self) -> Timestamp {
        self.ts
    }

    /// Visit as a borrowed raw view.
    pub(crate) fn as_raw_view(&self) -> KeyTsViewRaw {
        KeyTsViewRaw::from_owned(&self.key, self.ts)
    }
}

impl PartialOrd for KeyTsOwned {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for KeyTsOwned {
    fn cmp(&self, other: &Self) -> Ordering {
        match self.key.cmp(&other.key) {
            Ordering::Equal => other.ts.cmp(&self.ts),
            ordering => ordering,
        }
    }
}

impl From<(KeyOwned, Timestamp)> for KeyTsOwned {
    fn from((key, ts): (KeyOwned, Timestamp)) -> Self {
        KeyTsOwned::new(key, ts)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn view_orders_descending_timestamps_per_key() {
        let key = KeyOwned::from("a");
        let v1 = KeyTsViewRaw::from_owned(&key, Timestamp::new(1));
        let v0 = KeyTsViewRaw::from_owned(&key, Timestamp::new(0));

        assert!(v1 < v0);
    }

    #[test]
    fn owned_orders_key_then_timestamp() {
        let a1 = KeyTsOwned::new(KeyOwned::from("a"), Timestamp::new(1));
        let a0 = KeyTsOwned::new(KeyOwned::from("a"), Timestamp::new(0));
        let b1 = KeyTsOwned::new(KeyOwned::from("b"), Timestamp::new(1));

        assert!(a1 < a0);
        assert!(a0 < b1);
    }
}