holocron 0.5.0

Declarative schema & query compiler — one YAML as the source of truth for SQL schema and a type-checked query catalog.
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

use crate::catalog::CatalogType;

/// A filter expression tree: logical AND/OR combinators around comparison leaves.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Filter {
    And(Vec<Filter>),
    Or(Vec<Filter>),
    Leaf(Comparison),
}

/// A single comparison against a column. The shape of the value is fixed by
/// the variant — illegal states (e.g. `In` with one value) are unrepresentable.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Comparison {
    /// A column-to-value comparison: equality, ordering, or text pattern.
    Compare {
        column: String,
        op: CompareOp,
        value: String,
    },
    /// Membership in a set of values.
    Set {
        column: String,
        op: SetOp,
        values: Vec<String>,
    },
    /// A null check: `true` for IS NULL, `false` for IS NOT NULL.
    NullCheck { column: String, is_null: bool },
}

/// Column-to-value comparison operators.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CompareOp {
    Eq,
    NotEq,
    Gt,
    Gte,
    Lt,
    Lte,
    Like,
    StartsWith,
    EndsWith,
}

/// Set-membership operators.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SetOp {
    In,
    NotIn,
}

impl CompareOp {
    /// Whether this operator is valid for the given column type.
    pub fn supported_by(&self, data_type: &CatalogType) -> bool {
        match self {
            Self::Eq | Self::NotEq => data_type.supports_equality(),
            Self::Gt | Self::Gte | Self::Lt | Self::Lte => data_type.supports_ordering(),
            Self::Like | Self::StartsWith | Self::EndsWith => data_type.supports_text_pattern(),
        }
    }

    /// Surface-syntax name, used in diagnostics.
    pub fn name(&self) -> &'static str {
        match self {
            Self::Eq => "==",
            Self::NotEq => "!=",
            Self::Gt => "=gt=",
            Self::Gte => "=ge=",
            Self::Lt => "=lt=",
            Self::Lte => "=le=",
            Self::Like => "=like=",
            Self::StartsWith => "=starts=",
            Self::EndsWith => "=ends=",
        }
    }
}

impl SetOp {
    /// Whether this operator is valid for the given column type.
    pub fn supported_by(&self, data_type: &CatalogType) -> bool {
        data_type.supports_set()
    }

    /// Surface-syntax name, used in diagnostics.
    pub fn name(&self) -> &'static str {
        match self {
            Self::In => "=in=",
            Self::NotIn => "=out=",
        }
    }
}