dbx-core 0.2.2

High-performance file-based database engine with 5-Tier Hybrid Storage
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

//! WOS (Write-Optimized Store) Variant — supports plain, encrypted, and native implementations

use crate::error::DbxResult;
use crate::storage::StorageBackend;
use crate::storage::encryption::wos::EncryptedWosBackend;
use crate::storage::memory_wos::InMemoryWosBackend;
use crate::storage::native_wos::NativeWosBackend;
use std::sync::Arc;

/// WOS variant — supports both plain and encrypted implementations.
///
/// Note: `StorageBackend::scan` has a generic parameter `R: RangeBounds`
/// which prevents dyn compatibility.
pub enum WosVariant {
    Encrypted(Arc<EncryptedWosBackend>),
    InMemory(Arc<InMemoryWosBackend>),
    Native(Arc<NativeWosBackend>),
}

impl WosVariant {
    pub fn insert(&self, table: &str, key: &[u8], value: &[u8]) -> DbxResult<()> {
        match self {
            Self::Encrypted(wos) => wos.as_ref().insert(table, key, value),
            Self::InMemory(wos) => wos.as_ref().insert(table, key, value),
            Self::Native(wos) => wos.as_ref().insert(table, key, value),
        }
    }

    pub fn insert_batch(&self, table: &str, rows: Vec<(Vec<u8>, Vec<u8>)>) -> DbxResult<()> {
        match self {
            Self::Encrypted(wos) => wos.as_ref().insert_batch(table, rows),
            Self::InMemory(wos) => wos.as_ref().insert_batch(table, rows),
            Self::Native(wos) => wos.as_ref().insert_batch(table, rows),
        }
    }

    pub fn get(&self, table: &str, key: &[u8]) -> DbxResult<Option<Vec<u8>>> {
        match self {
            Self::Encrypted(wos) => wos.as_ref().get(table, key),
            Self::InMemory(wos) => wos.as_ref().get(table, key),
            Self::Native(wos) => wos.as_ref().get(table, key),
        }
    }

    pub fn delete(&self, table: &str, key: &[u8]) -> DbxResult<bool> {
        match self {
            Self::Encrypted(wos) => wos.as_ref().delete(table, key),
            Self::InMemory(wos) => wos.as_ref().delete(table, key),
            Self::Native(wos) => wos.as_ref().delete(table, key),
        }
    }

    pub fn scan<R: std::ops::RangeBounds<Vec<u8>> + Clone>(
        &self,
        table: &str,
        range: R,
    ) -> DbxResult<Vec<(Vec<u8>, Vec<u8>)>> {
        match self {
            Self::Encrypted(wos) => wos.as_ref().scan(table, range),
            Self::InMemory(wos) => wos.as_ref().scan(table, range),
            Self::Native(wos) => wos.as_ref().scan(table, range),
        }
    }

    pub fn scan_one<R: std::ops::RangeBounds<Vec<u8>> + Clone>(
        &self,
        table: &str,
        range: R,
    ) -> DbxResult<Option<(Vec<u8>, Vec<u8>)>> {
        match self {
            Self::Encrypted(wos) => wos.as_ref().scan_one(table, range),
            Self::InMemory(wos) => wos.as_ref().scan_one(table, range),
            Self::Native(wos) => wos.as_ref().scan_one(table, range),
        }
    }

    pub fn flush(&self) -> DbxResult<()> {
        match self {
            Self::Encrypted(wos) => wos.as_ref().flush(),
            Self::InMemory(wos) => wos.as_ref().flush(),
            Self::Native(wos) => wos.as_ref().flush(),
        }
    }

    pub fn count(&self, table: &str) -> DbxResult<usize> {
        match self {
            Self::Encrypted(wos) => wos.as_ref().count(table),
            Self::InMemory(wos) => wos.as_ref().count(table),
            Self::Native(wos) => wos.as_ref().count(table),
        }
    }

    pub fn table_names(&self) -> DbxResult<Vec<String>> {
        match self {
            Self::Encrypted(wos) => wos.as_ref().table_names(),
            Self::InMemory(wos) => wos.as_ref().table_names(),
            Self::Native(wos) => wos.as_ref().table_names(),
        }
    }

    // ════════════════════════════════════════════
    // Metadata Persistence Helpers
    // ════════════════════════════════════════════

    /// Save schema metadata (only for Plain WOS, no-op for encrypted/in-memory)
    pub fn save_schema_metadata(
        &self,
        table: &str,
        schema: &arrow::datatypes::Schema,
    ) -> DbxResult<()> {
        match self {
            Self::Native(wos) => crate::engine::metadata::save_schema(wos.as_ref(), table, schema),
            Self::Encrypted(_) | Self::InMemory(_) => Ok(()),
        }
    }

    /// Delete schema metadata (only for Plain WOS)
    pub fn delete_schema_metadata(&self, table: &str) -> DbxResult<()> {
        match self {
            Self::Native(wos) => crate::engine::metadata::delete_schema(wos.as_ref(), table),
            Self::Encrypted(_) | Self::InMemory(_) => Ok(()),
        }
    }

    /// Save index metadata (only for Plain WOS)
    pub fn save_index_metadata(
        &self,
        index_name: &str,
        table: &str,
        column: &str,
    ) -> DbxResult<()> {
        match self {
            Self::Native(wos) => {
                crate::engine::metadata::save_index(wos.as_ref(), index_name, table, column)
            }
            Self::Encrypted(_) | Self::InMemory(_) => Ok(()),
        }
    }

    /// Delete index metadata (only for Plain WOS)
    pub fn delete_index_metadata(&self, index_name: &str) -> DbxResult<()> {
        match self {
            Self::Native(wos) => crate::engine::metadata::delete_index(wos.as_ref(), index_name),
            Self::Encrypted(_) | Self::InMemory(_) => Ok(()),
        }
    }
}