icydb-core 0.284.2

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

//! Borrowed predicate components retain byte ordering and short-circuit errors.

use super::*;
use crate::{
    db::{
        index::{IndexId, decode_index_key_frame},
        test_support::index::nat64_index_key,
    },
    types::EntityTag,
};

#[test]
fn borrowed_predicates_preserve_comparisons_and_short_circuit_refusals() {
    let raw = nat64_index_key(&IndexId::new(EntityTag::new(7), 1), b"bb", 7)
        .to_raw()
        .unwrap();
    let frame = decode_index_key_frame(&raw).unwrap();
    for (op, expected) in [
        (IndexCompareOp::Eq, [false, true, false]),
        (IndexCompareOp::Ne, [true, false, true]),
        (IndexCompareOp::Lt, [false, false, true]),
        (IndexCompareOp::Lte, [false, true, true]),
        (IndexCompareOp::Gt, [true, false, false]),
        (IndexCompareOp::Gte, [true, true, false]),
    ] {
        for (literal, expected) in [b"b".as_slice(), b"bb", b"bbb"].into_iter().zip(expected) {
            let program = IndexPredicateProgram::Compare {
                component_index: 0,
                op,
                literal: IndexLiteral::One(literal.to_vec()),
            };
            assert_eq!(
                eval_index_program_on_frame(&frame, &program).unwrap(),
                expected
            );
        }
    }
    for literal in [
        IndexLiteral::Many(vec![b"bb".to_vec(), b"a".to_vec()]),
        IndexLiteral::ManySorted(vec![b"a".to_vec(), b"bb".to_vec()]),
    ] {
        for (op, expected) in [(IndexCompareOp::In, true), (IndexCompareOp::NotIn, false)] {
            let program = IndexPredicateProgram::Compare {
                component_index: 0,
                op,
                literal: literal.clone(),
            };
            assert_eq!(
                eval_index_program_on_frame(&frame, &program).unwrap(),
                expected
            );
        }
    }
    let missing = IndexPredicateProgram::Compare {
        component_index: 1,
        op: IndexCompareOp::Eq,
        literal: IndexLiteral::One(vec![1]),
    };
    let error = eval_index_program_on_frame(&frame, &missing).unwrap_err();
    let expected = InternalError::index_only_predicate_component_required();
    assert_eq!(error.diagnostic(), expected.diagnostic());
    assert_eq!(error.diagnostic_facts(), expected.diagnostic_facts());
    for (program, expected) in [
        (
            IndexPredicateProgram::And(vec![IndexPredicateProgram::False, missing.clone()]),
            false,
        ),
        (
            IndexPredicateProgram::Or(vec![IndexPredicateProgram::True, missing]),
            true,
        ),
        (
            IndexPredicateProgram::Not(Box::new(IndexPredicateProgram::False)),
            true,
        ),
    ] {
        assert_eq!(
            eval_index_program_on_frame(&frame, &program).unwrap(),
            expected
        );
    }
}