icydb-core 0.94.0

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
133
134
135
136
137
138
139
140
141
142

//! Module: predicate::resolved
//! Responsibility: canonical executable predicate representation for runtime execution.
//! Does not own: field-name schema mapping itself.
//! Boundary: produced once at predicate compile time and consumed by runtime and index execution.

use crate::{
    db::predicate::{coercion::CoercionSpec, model::CompareOp},
    value::Value,
};

///
/// ExecutableCompareOperand
///
/// One compiled compare operand carried by the canonical executable predicate
/// tree. Operands are either pre-resolved field slots or embedded literal
/// payloads.
///

#[derive(Clone, Debug, Eq, PartialEq)]
pub(in crate::db) enum ExecutableCompareOperand {
    FieldSlot(Option<usize>),
    Literal(Value),
}

///
/// ExecutableComparePredicate
///
/// One canonical executable comparison node with compiled operands.
/// Runtime filtering and index-only compilation both consume this single
/// compare shape instead of carrying separate field-vs-literal and
/// field-vs-field execution nodes.
///

#[derive(Clone, Debug, Eq, PartialEq)]
pub(in crate::db) struct ExecutableComparePredicate {
    pub(in crate::db) left: ExecutableCompareOperand,
    pub(in crate::db) op: CompareOp,
    pub(in crate::db) right: ExecutableCompareOperand,
    pub(in crate::db) coercion: CoercionSpec,
}

impl ExecutableComparePredicate {
    /// Construct one field-vs-literal executable compare node.
    #[must_use]
    pub(in crate::db) const fn field_literal(
        field_slot: Option<usize>,
        op: CompareOp,
        value: Value,
        coercion: CoercionSpec,
    ) -> Self {
        Self {
            left: ExecutableCompareOperand::FieldSlot(field_slot),
            op,
            right: ExecutableCompareOperand::Literal(value),
            coercion,
        }
    }

    /// Construct one field-vs-field executable compare node.
    #[must_use]
    pub(in crate::db) const fn field_field(
        left_field_slot: Option<usize>,
        op: CompareOp,
        right_field_slot: Option<usize>,
        coercion: CoercionSpec,
    ) -> Self {
        Self {
            left: ExecutableCompareOperand::FieldSlot(left_field_slot),
            op,
            right: ExecutableCompareOperand::FieldSlot(right_field_slot),
            coercion,
        }
    }

    /// Return the left operand when it is a field slot.
    #[must_use]
    pub(in crate::db) const fn left_field_slot(&self) -> Option<usize> {
        match self.left {
            ExecutableCompareOperand::FieldSlot(slot) => slot,
            ExecutableCompareOperand::Literal(_) => None,
        }
    }

    /// Return the right operand when it is a field slot.
    #[must_use]
    pub(in crate::db) const fn right_field_slot(&self) -> Option<usize> {
        match self.right {
            ExecutableCompareOperand::FieldSlot(slot) => slot,
            ExecutableCompareOperand::Literal(_) => None,
        }
    }

    /// Borrow the right operand when it is a literal payload.
    #[must_use]
    pub(in crate::db) const fn right_literal(&self) -> Option<&Value> {
        match &self.right {
            ExecutableCompareOperand::Literal(value) => Some(value),
            ExecutableCompareOperand::FieldSlot(_) => None,
        }
    }
}

///
/// ExecutablePredicate
///
/// Canonical predicate execution tree emitted by planning-time compilation.
/// Runtime row filtering and index-only compilation both consume this one
/// structural form instead of maintaining parallel execution representations.
///

#[derive(Clone, Debug, Eq, PartialEq)]
pub(in crate::db) enum ExecutablePredicate {
    True,
    False,
    And(Vec<Self>),
    Or(Vec<Self>),
    Not(Box<Self>),
    Compare(ExecutableComparePredicate),
    IsNull {
        field_slot: Option<usize>,
    },
    IsNotNull {
        field_slot: Option<usize>,
    },
    IsMissing {
        field_slot: Option<usize>,
    },
    IsEmpty {
        field_slot: Option<usize>,
    },
    IsNotEmpty {
        field_slot: Option<usize>,
    },
    TextContains {
        field_slot: Option<usize>,
        value: Value,
    },
    TextContainsCi {
        field_slot: Option<usize>,
        value: Value,
    },
}