icydb-core 0.144.10

IcyDB — A schema-first typed query engine and persistence runtime for Internet Computer canisters
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

use crate::{
    db::{
        data::{DataKey, RawRow, StorageKey},
        direction::Direction,
        index::{
            IndexStore, RawIndexEntry, RawIndexKey, SealedStructuralIndexEntryReader,
            SealedStructuralPrimaryRowReader, StructuralIndexEntryReader,
            StructuralPrimaryRowReader,
        },
        registry::StoreHandle,
    },
    error::InternalError,
    model::index::IndexModel,
    types::EntityTag,
};
use std::{cell::RefCell, ops::Bound, thread::LocalKey};

impl StructuralPrimaryRowReader for StoreHandle {
    fn read_primary_row_structural(&self, key: &DataKey) -> Result<Option<RawRow>, InternalError> {
        let raw_key = key.to_raw()?;

        Ok(self.with_data(|store| store.get(&raw_key)))
    }
}

impl SealedStructuralPrimaryRowReader for StoreHandle {}

impl StructuralIndexEntryReader for StoreHandle {
    fn read_index_entry_structural(
        &self,
        store: &'static LocalKey<RefCell<IndexStore>>,
        key: &RawIndexKey,
    ) -> Result<Option<RawIndexEntry>, InternalError> {
        Ok(store.with_borrow(|index_store| index_store.get(key)))
    }

    fn read_index_keys_in_raw_range_structural(
        &self,
        _entity_path: &'static str,
        _entity_tag: EntityTag,
        store: &'static LocalKey<RefCell<IndexStore>>,
        index: &IndexModel,
        bounds: (&Bound<RawIndexKey>, &Bound<RawIndexKey>),
        limit: usize,
    ) -> Result<Vec<StorageKey>, InternalError> {
        let mut out = Vec::with_capacity(limit.min(32));
        store.with_borrow(|index_store| {
            index_store.visit_raw_entries_in_range(bounds, Direction::Asc, |_, raw_entry| {
                push_index_entry_storage_keys(index, raw_entry, &mut out, limit)
            })
        })?;

        Ok(out)
    }
}

impl SealedStructuralIndexEntryReader for StoreHandle {}

// Decode one raw index entry into structural storage keys for non-executor
// preflight readers.
fn push_index_entry_storage_keys(
    index: &IndexModel,
    raw_entry: &RawIndexEntry,
    out: &mut Vec<StorageKey>,
    limit: usize,
) -> Result<bool, InternalError> {
    raw_entry.push_membership_storage_keys_limited(
        index.is_unique(),
        out,
        limit,
        |err| {
            InternalError::index_plan_index_corruption(format!(
                "index corrupted: ({}) -> {}",
                index.fields().join(", "),
                err
            ))
        },
        InternalError::unique_index_entry_single_key_required,
    )
}