iridium_core 0.1.11

SQL Server-compatible Rust engine core for Iridium SQL
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::error::DbError;
use crate::storage::{BTreeIndex, IndexStorage};
use crate::types::Value;

use super::redb_storage::RedbStorage;

impl IndexStorage for RedbStorage {
    fn register_index(
        &mut self,
        index_id: u32,
        column_ids: Vec<u32>,
        is_unique: bool,
        is_clustered: bool,
    ) {
        self.indexes.insert(
            index_id,
            BTreeIndex::new(column_ids, is_unique, is_clustered),
        );
    }

    fn get_index(&self, index_id: u32) -> Option<&BTreeIndex> {
        self.indexes.get(&index_id)
    }

    fn get_index_mut(&mut self, index_id: u32) -> Option<&mut BTreeIndex> {
        self.indexes.get_mut(&index_id)
    }

    fn seek_index(&self, index_id: u32, key: &Value) -> Result<Vec<usize>, DbError> {
        let index = self
            .indexes
            .get(&index_id)
            .ok_or_else(|| DbError::Storage(format!("index {} not found", index_id)))?;

        let result = index.seek(key).cloned().unwrap_or_default();
        Ok(result)
    }

    fn seek_index_range(
        &self,
        index_id: u32,
        lower: Option<&Value>,
        upper: Option<&Value>,
    ) -> Result<Vec<(Value, Vec<usize>)>, DbError> {
        let index = self
            .indexes
            .get(&index_id)
            .ok_or_else(|| DbError::Storage(format!("index {} not found", index_id)))?;

        let entries = index.seek_range(lower, upper);
        let mut result = Vec::new();
        for (key, indices) in entries {
            if let Some(first_val) = key.as_values().first() {
                result.push((first_val.clone(), indices));
            }
        }
        Ok(result)
    }

    fn insert_index_entry(
        &mut self,
        index_id: u32,
        _key: Value,
        _row_index: usize,
    ) -> Result<(), DbError> {
        let _index = self
            .indexes
            .get_mut(&index_id)
            .ok_or_else(|| DbError::Storage(format!("index {} not found", index_id)))?;

        Ok(())
    }

    fn delete_index_entry(
        &mut self,
        index_id: u32,
        _key: &Value,
        _row_index: usize,
    ) -> Result<(), DbError> {
        let _index = self
            .indexes
            .get_mut(&index_id)
            .ok_or_else(|| DbError::Storage(format!("index {} not found", index_id)))?;

        Ok(())
    }

    fn rebuild_index(
        &mut self,
        index_id: u32,
        entries: Vec<(Value, usize)>,
    ) -> Result<(), DbError> {
        let index = self
            .indexes
            .get_mut(&index_id)
            .ok_or_else(|| DbError::Storage(format!("index {} not found", index_id)))?;

        index.clear();
        for (key, row_index) in entries {
            index.insert(row_index, &[key])?;
        }
        Ok(())
    }
}