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
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

//! Module: db::executor::tests::stale_secondary
//! Covers stale secondary-index handling and recovery behavior.
//! Does not own: unrelated executor behavior outside missing-row reconciliation.
//! Boundary: exposes this module API while keeping implementation details internal.

use super::support::*;
use crate::{
    db::{
        data::DataKey,
        predicate::{CoercionId, CompareOp, ComparePredicate, Predicate},
        query::explain::ExplainAccessPath,
    },
    value::Value,
};

// Remove one pushdown row from the primary store while keeping index entries.
fn remove_pushdown_row_data(id: u128) {
    let raw_key = DataKey::try_new::<PushdownParityEntity>(Ulid::from_u128(id))
        .expect("pushdown data key should build")
        .to_raw()
        .expect("pushdown data key should encode");

    DATA_STORE.with(|store| {
        let removed = store.borrow_mut().remove(&raw_key);
        assert!(
            removed.is_some(),
            "expected pushdown row to exist before data-only removal"
        );
    });
}

#[test]
fn load_secondary_index_missing_ok_skips_stale_keys_by_reading_primary_rows() {
    init_commit_store_for_tests().expect("commit store init should succeed");
    reset_store();

    let save = SaveExecutor::<PushdownParityEntity>::new(DB, false);
    for (id, group, rank) in [(7101_u128, 7_u32, 10_u32), (7102, 7, 20), (7103, 7, 30)] {
        save.insert(PushdownParityEntity {
            id: Ulid::from_u128(id),
            group,
            rank,
            label: format!("g{group}-r{rank}"),
        })
        .expect("seed pushdown row save should succeed");
    }

    remove_pushdown_row_data(7101);

    let predicate = Predicate::Compare(ComparePredicate::with_coercion(
        "group",
        CompareOp::Eq,
        Value::Uint(7),
        CoercionId::Strict,
    ));
    let explain = Query::<PushdownParityEntity>::new(MissingRowPolicy::Ignore)
        .filter_predicate(predicate.clone())
        .order_term(crate::db::asc("rank"))
        .explain()
        .expect("missing-ok stale-secondary explain should build");
    assert!(
        matches!(explain.access(), ExplainAccessPath::IndexPrefix { .. }),
        "group equality with rank order should plan as secondary index-prefix access",
    );

    let load = LoadExecutor::<PushdownParityEntity>::new(DB, false);
    let plan = Query::<PushdownParityEntity>::new(MissingRowPolicy::Ignore)
        .filter_predicate(predicate)
        .order_term(crate::db::asc("rank"))
        .plan()
        .map(crate::db::executor::PreparedExecutionPlan::from)
        .expect("missing-ok stale-secondary load plan should build");
    let response = load
        .execute(plan)
        .expect("missing-ok stale-secondary load should succeed");
    let ids: Vec<Ulid> = response
        .into_iter()
        .map(|row| row.entity_ref().id)
        .collect();

    assert_eq!(
        ids,
        vec![Ulid::from_u128(7102), Ulid::from_u128(7103)],
        "Ignore must filter stale secondary keys instead of materializing missing rows",
    );
}

#[test]
fn load_secondary_index_strict_missing_row_surfaces_corruption() {
    init_commit_store_for_tests().expect("commit store init should succeed");
    reset_store();

    let save = SaveExecutor::<PushdownParityEntity>::new(DB, false);
    for (id, group, rank) in [(7201_u128, 7_u32, 10_u32), (7202, 7, 20), (7203, 7, 30)] {
        save.insert(PushdownParityEntity {
            id: Ulid::from_u128(id),
            group,
            rank,
            label: format!("g{group}-r{rank}"),
        })
        .expect("seed pushdown row save should succeed");
    }

    remove_pushdown_row_data(7201);

    let predicate = Predicate::Compare(ComparePredicate::with_coercion(
        "group",
        CompareOp::Eq,
        Value::Uint(7),
        CoercionId::Strict,
    ));
    let load = LoadExecutor::<PushdownParityEntity>::new(DB, false);
    let plan = Query::<PushdownParityEntity>::new(MissingRowPolicy::Error)
        .filter_predicate(predicate)
        .order_term(crate::db::asc("rank"))
        .plan()
        .map(crate::db::executor::PreparedExecutionPlan::from)
        .expect("strict stale-secondary load plan should build");
    let err = load
        .execute(plan)
        .expect_err("strict stale-secondary load should fail on missing primary row");

    assert_eq!(
        err.class,
        crate::error::ErrorClass::Corruption,
        "strict stale-secondary load must classify missing primary rows as corruption",
    );
    assert!(
        err.message.contains("missing row"),
        "strict stale-secondary failure should report missing-row corruption",
    );
}