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
105
106
107
108
109
110
111
112
113
114
115
116

//! Schema evolution, context and recovery operations.

use linkrs_core::metadata::{IndexMetadataManager, SchemaManager};
use linkrs_core::types::{EdgeTypeInfo, Index, LabelId, PropertyDef, SpaceInfo, TagInfo};
use linkrs_core::{StorageError, StorageResult};
use linkrs_transaction::wal::recovery::{RecoveryConfig, RecoveryStats};
use std::sync::Arc;

/// Schema/space/tag/edge-type/index DDL operations.
pub trait StorageSchemaOps: Send + Sync + std::fmt::Debug {
    fn create_space(&mut self, space: &mut SpaceInfo) -> Result<bool, StorageError>;
    fn drop_space(&mut self, space: &str) -> Result<bool, StorageError>;
    fn clear_space(&mut self, space: &str) -> Result<bool, StorageError>;

    fn create_tag(&mut self, space: &str, tag: &TagInfo) -> Result<u32, StorageError>;
    fn create_tag_with_estimate(
        &mut self,
        space: &str,
        tag: &TagInfo,
        estimated_rows: Option<u64>,
    ) -> Result<u32, StorageError> {
        let _ = estimated_rows;
        self.create_tag(space, tag)
    }
    fn alter_tag(
        &mut self,
        space: &str,
        tag: &str,
        additions: Vec<PropertyDef>,
        deletions: Vec<String>,
        new_comment: Option<String>,
    ) -> Result<bool, StorageError>;
    fn rename_vertex_property(
        &mut self,
        label: LabelId,
        old_name: &str,
        new_name: &str,
    ) -> Result<(), StorageError>;
    fn rename_tag_property(
        &mut self,
        space: &str,
        tag: &str,
        old_name: &str,
        new_name: &str,
    ) -> Result<bool, StorageError>;
    fn rename_tag(
        &mut self,
        space: &str,
        old_name: &str,
        new_name: &str,
    ) -> Result<bool, StorageError>;
    fn drop_tag(&mut self, space: &str, tag: &str) -> Result<bool, StorageError>;

    fn create_edge_type(&mut self, space: &str, edge: &EdgeTypeInfo) -> Result<u32, StorageError>;
    fn alter_edge_type(
        &mut self,
        space: &str,
        edge_type: &str,
        additions: Vec<PropertyDef>,
        deletions: Vec<String>,
        new_comment: Option<String>,
    ) -> Result<bool, StorageError>;
    fn rename_edge_property(
        &mut self,
        space: &str,
        edge_type: &str,
        old_name: &str,
        new_name: &str,
    ) -> Result<bool, StorageError>;
    fn rename_edge_type(
        &mut self,
        space: &str,
        old_name: &str,
        new_name: &str,
    ) -> Result<bool, StorageError>;
    fn update_edge_endpoints(
        &mut self,
        space: &str,
        edge_type: &str,
        src_tag_name: &str,
        dst_tag_name: &str,
    ) -> Result<bool, StorageError>;
    fn drop_edge_type(&mut self, space: &str, edge_type: &str) -> Result<bool, StorageError>;

    fn create_tag_index(&mut self, space: &str, info: &Index) -> Result<bool, StorageError>;
    fn drop_tag_index(&mut self, space: &str, index: &str) -> Result<bool, StorageError>;
    fn rebuild_tag_index(&mut self, space: &str, index: &str) -> Result<bool, StorageError>;

    fn create_edge_index(&mut self, space: &str, info: &Index) -> Result<bool, StorageError>;
    fn drop_edge_index(&mut self, space: &str, index: &str) -> Result<bool, StorageError>;
    fn rebuild_edge_index(&mut self, space: &str, index: &str) -> Result<bool, StorageError>;
}

/// Access to persistent schema context shared with higher-level components.
pub trait StorageSchemaContextOps: Send + Sync + std::fmt::Debug {
    fn get_schema_manager(&self) -> Option<Arc<SchemaManager>>;
    fn get_index_metadata_manager(&self) -> Option<Arc<dyn IndexMetadataManager>>;
}

/// WAL recovery operations.
pub trait StorageRecoveryOps: Send + Sync + std::fmt::Debug {
    fn needs_recovery(&self) -> bool;

    fn recover_from_wal(&self) -> StorageResult<RecoveryStats>;

    fn recover_from_wal_with_config(&self, config: RecoveryConfig) -> StorageResult<RecoveryStats>;

    fn init_with_recovery(&self) -> StorageResult<Option<RecoveryStats>> {
        if self.needs_recovery() {
            let stats = self.recover_from_wal()?;
            Ok(Some(stats))
        } else {
            Ok(None)
        }
    }
}