vantage-table 0.4.0

Table, Column, and operation traits for the Vantage data framework
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

//! Generic operation trait for building conditions from any `Expressive` type.
//!
//! A blanket impl provides `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, and `in_` for
//! every type that implements `Expressive<T>`. This includes table columns, fields,
//! scalar values, and expressions across all backends.

use vantage_expressions::traits::expressive::ExpressiveEnum;
use vantage_expressions::{Expression, Expressive};

/// Trait for building condition expressions.
///
/// Blanket-implemented for all `Expressive<T>` types using standard SQL templates.
pub trait Operation<T>: Expressive<T> {
    /// Creates an equality condition: field = value
    fn eq(&self, value: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} = {}",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(value.expr()),
            ],
        )
    }

    /// Creates a not-equal condition: field != value
    fn ne(&self, value: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} != {}",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(value.expr()),
            ],
        )
    }

    /// Creates a greater-than condition: field > value
    fn gt(&self, value: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} > {}",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(value.expr()),
            ],
        )
    }

    /// Creates a greater-than-or-equal condition: field >= value
    fn gte(&self, value: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} >= {}",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(value.expr()),
            ],
        )
    }

    /// Creates a less-than condition: field < value
    fn lt(&self, value: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} < {}",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(value.expr()),
            ],
        )
    }

    /// Creates a less-than-or-equal condition: field <= value
    fn lte(&self, value: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} <= {}",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(value.expr()),
            ],
        )
    }

    /// Creates a membership condition: field IN (values_expression)
    fn in_(&self, values: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} IN ({})",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(values.expr()),
            ],
        )
    }

    /// Creates a membership condition from a list of scalar values: field IN (a, b, c)
    fn in_list<V: Into<T> + Clone>(&self, values: &[V]) -> Expression<T> {
        let params: Vec<Expression<T>> = values
            .iter()
            .map(|v| Expression::new("{}", vec![ExpressiveEnum::Scalar(v.clone().into())]))
            .collect();
        Expression::new(
            "{} IN ({})",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(Expression::from_vec(params, ", ")),
            ],
        )
    }

    /// Casts the expression to a SQL type: `CAST(expr AS type_name)`
    fn cast(&self, type_name: &str) -> Expression<T> {
        Expression::new(
            format!("CAST({{}} AS {type_name})"),
            vec![ExpressiveEnum::Nested(self.expr())],
        )
    }
}

/// Blanket implementation: any type that implements `Expressive<T>` gets `Operation<T>` for free.
impl<T, S: Expressive<T>> Operation<T> for S {}