icydb-core 0.98.1

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

//! Module: db::access::tests::canonical
//! Covers access-canonicalization regressions that must stay aligned with the
//! wider access/fingerprint contract.
//! Does not own: leaf-local canonical comparator helpers.
//! Boundary: keeps owner-level access identity regressions in the access
//! subsystem `tests/` boundary.

use crate::{
    db::{
        MissingRowPolicy,
        access::{AccessPath, AccessPlan, normalize_access_plan_value},
        query::plan::AccessPlannedQuery,
    },
    model::index::IndexModel,
    value::Value,
};
use std::ops::Bound;

const TEST_INDEX_FIELDS: [&str; 2] = ["group", "rank"];
const TEST_INDEX: IndexModel = IndexModel::generated(
    "canonical::group_rank",
    "canonical::store",
    &TEST_INDEX_FIELDS,
    false,
);
const TEST_INDEX_FIELDS_ALT: [&str; 2] = ["group", "score"];
const TEST_INDEX_SAME_NAME_ALT_FIELDS: IndexModel = IndexModel::generated(
    "canonical::group_rank",
    "canonical::store",
    &TEST_INDEX_FIELDS_ALT,
    false,
);

fn index_range_path(
    index: IndexModel,
    lower: Bound<Value>,
    upper: Bound<Value>,
) -> AccessPath<Value> {
    AccessPath::index_range(index, vec![Value::Uint(7)], lower, upper)
}

#[test]
fn canonical_and_fingerprint_align_for_index_range_bound_discriminants() {
    let included = index_range_path(
        TEST_INDEX,
        Bound::Included(Value::Uint(100)),
        Bound::Excluded(Value::Uint(200)),
    );
    let excluded = index_range_path(
        TEST_INDEX,
        Bound::Excluded(Value::Uint(100)),
        Bound::Excluded(Value::Uint(200)),
    );

    assert_ne!(
        normalize_access_plan_value(AccessPlan::path(included.clone())),
        normalize_access_plan_value(AccessPlan::path(excluded.clone())),
        "access canonicalization must keep index-range bound discriminants distinct",
    );

    let included_plan: AccessPlannedQuery =
        AccessPlannedQuery::new(included, MissingRowPolicy::Ignore);
    let excluded_plan: AccessPlannedQuery =
        AccessPlannedQuery::new(excluded, MissingRowPolicy::Ignore);

    assert_ne!(
        included_plan.fingerprint(),
        excluded_plan.fingerprint(),
        "fingerprints must stay aligned with canonical bound discriminants",
    );
}

#[test]
fn canonical_and_fingerprint_align_for_index_field_identity() {
    let path_a = index_range_path(
        TEST_INDEX,
        Bound::Included(Value::Uint(100)),
        Bound::Excluded(Value::Uint(200)),
    );
    let path_b = index_range_path(
        TEST_INDEX_SAME_NAME_ALT_FIELDS,
        Bound::Included(Value::Uint(100)),
        Bound::Excluded(Value::Uint(200)),
    );

    assert_ne!(
        normalize_access_plan_value(AccessPlan::path(path_a.clone())),
        normalize_access_plan_value(AccessPlan::path(path_b.clone())),
        "access canonicalization must keep index field identity in the semantic shape",
    );

    let plan_a: AccessPlannedQuery = AccessPlannedQuery::new(path_a, MissingRowPolicy::Ignore);
    let plan_b: AccessPlannedQuery = AccessPlannedQuery::new(path_b, MissingRowPolicy::Ignore);

    assert_ne!(
        plan_a.fingerprint(),
        plan_b.fingerprint(),
        "fingerprints must stay aligned with canonical index identity",
    );
}