linkrs-storage 0.1.0

Storage engine with CSR and memory-mapped containers
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

use super::{CsrWithProperties, RowVisibility};
use linkrs_core::types::{EdgeId, Timestamp};

/// Row-stamp projection for reclamation probing only.
///
/// Query visibility never consults these stamps; every query filters through
/// the version authority (`EdgeStore::is_visible`). These helpers exist so
/// garbage collection can probe row liveness without a second authority
/// lookup.
impl RowVisibility {
    pub(crate) fn new(create_ts: Timestamp) -> Self {
        Self {
            create_ts,
            delete_ts: None,
        }
    }

    #[cfg(test)]
    pub(crate) fn is_visible_at(&self, query_ts: Timestamp) -> bool {
        crate::mvcc_visibility::Visibility::is_visible(query_ts, self.create_ts, self.delete_ts)
    }

    pub(crate) fn mark_deleted(&mut self, ts: Timestamp) {
        if self.delete_ts.is_none() {
            self.delete_ts = Some(ts);
        }
    }
}

impl CsrWithProperties {
    pub fn mark_deleted(&mut self, edge_id: EdgeId, ts: Timestamp) -> bool {
        if self.inline {
            return false;
        }
        if let Some(pos) = self.mapped_row(edge_id) {
            if let Some(vis) = self.visibility.get_mut(pos) {
                if vis.delete_ts.is_some() {
                    return false;
                }
                vis.mark_deleted(ts);
                return true;
            }
        }
        false
    }

    pub(crate) fn is_deleted_at_row(&self, row_idx: usize) -> bool {
        if let Some(vis) = self.visibility.get(row_idx) {
            return vis.delete_ts.is_some();
        }
        false
    }

    pub fn revert_deletion_at_row(&mut self, row_idx: usize) -> bool {
        if let Some(vis) = self.visibility.get_mut(row_idx) {
            if vis.delete_ts.is_some() {
                vis.delete_ts = None;
                return true;
            }
        }
        false
    }

    pub fn revert_deletion_for_edge(&mut self, edge_id: EdgeId) -> bool {
        if self.inline {
            return false;
        }
        if let Some(pos) = self.mapped_row(edge_id) {
            return self.revert_deletion_at_row(pos);
        }
        false
    }
}