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
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::index::traits::IndexGcOps;
use crate::index::types::GcStats;
use crate::index::IndexDataManagerImpl;
use linkrs_core::types::Timestamp;
use linkrs_core::{StorageError, StorageResult};

impl IndexDataManagerImpl {
    pub(crate) fn gc_runtime(
        &self,
        _safe_ts: Timestamp,
        _batch_size: usize,
    ) -> StorageResult<GcStats> {
        // Tombstone cleanup is handled by generation retirement + compaction.
        // Per-entry tombstone removal is no longer needed because clear paths
        // now publish delta generations (tombstones live in sub-generations).
        Ok(GcStats::default())
    }
}

impl IndexGcOps for IndexDataManagerImpl {
    fn gc_tombstones(&self, safe_ts: Timestamp) -> Result<GcStats, StorageError> {
        self.gc_runtime(safe_ts, usize::MAX)
    }

    fn gc_tombstones_incremental(
        &self,
        safe_ts: Timestamp,
        batch_size: usize,
    ) -> Result<GcStats, StorageError> {
        self.gc_runtime(safe_ts, batch_size)
    }

    fn tombstone_count(&self) -> usize {
        self.resync_tombstone_count();
        self.cached_tombstone_count() as usize
    }
}

#[cfg(test)]
mod tests {
    use crate::index::traits::{IndexGcOps, VertexIndexOps};
    use crate::index::IndexDataManagerImpl;
    use linkrs_core::types::{Index, IndexConfig, IndexField, IndexType};
    use linkrs_core::Value;

    #[test]
    fn tombstone_count_zero_for_empty_manager() {
        let manager = IndexDataManagerImpl::new();
        assert_eq!(manager.tombstone_count(), 0);
    }

    #[test]
    fn tombstones_are_published_as_delta_generations() {
        let manager = IndexDataManagerImpl::new();

        let index = Index::new(IndexConfig {
            id: 1,
            name: "idx".to_string(),
            space_id: 1,
            schema_name: "person".to_string(),
            fields: vec![IndexField::new(
                "name".to_string(),
                Value::string(""),
                false,
            )],
            properties: vec![],
            index_type: IndexType::TagIndex,
            is_unique: false,
            covering: false,
            partial_condition: None,
        });
        manager.register_native_index(1, &index).expect("register");
        manager
            .update_vertex_indexes_mvcc(
                1,
                &Value::Int(1),
                "idx",
                &[("name".into(), Value::string("Alice"))],
                10,
            )
            .expect("write");
        manager
            .delete_vertex_indexes_mvcc(1, &Value::Int(1), &["idx".to_string()], 20)
            .expect("delete");

        assert!(
            manager.tombstone_count() > 0,
            "expected tombstones after delete"
        );

        // With delta generation approach, per-entry tombstone removal is
        // replaced by generation retirement + compaction.
        // gc_runtime returns 0 — tombstones live in sub-generations until
        // compaction or the entire generation is retired.
        let stats = manager
            .gc_tombstones_incremental(25, 100)
            .expect("gc should succeed");
        assert_eq!(stats.total_removed(), 0, "per-entry GC is a no-op");
        assert!(
            manager.tombstone_count() > 0,
            "tombstones remain until compaction retires the delta generation"
        );
    }
}