sql-orm 0.2.0-rc.1

Public API crate for the sql-orm workspace.
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

use sql_orm_query::Predicate;

pub trait PredicateCompositionExt {
    fn and(self, other: Predicate) -> Predicate;

    fn or(self, other: Predicate) -> Predicate;

    fn not(self) -> Predicate;
}

impl PredicateCompositionExt for Predicate {
    fn and(self, other: Predicate) -> Predicate {
        match (self, other) {
            (Predicate::And(mut left), Predicate::And(right)) => {
                left.extend(right);
                Predicate::and(left)
            }
            (Predicate::And(mut left), right) => {
                left.push(right);
                Predicate::and(left)
            }
            (left, Predicate::And(mut right)) => {
                let mut predicates = vec![left];
                predicates.append(&mut right);
                Predicate::and(predicates)
            }
            (left, right) => Predicate::and(vec![left, right]),
        }
    }

    fn or(self, other: Predicate) -> Predicate {
        match (self, other) {
            (Predicate::Or(mut left), Predicate::Or(right)) => {
                left.extend(right);
                Predicate::or(left)
            }
            (Predicate::Or(mut left), right) => {
                left.push(right);
                Predicate::or(left)
            }
            (left, Predicate::Or(mut right)) => {
                let mut predicates = vec![left];
                predicates.append(&mut right);
                Predicate::or(predicates)
            }
            (left, right) => Predicate::or(vec![left, right]),
        }
    }

    fn not(self) -> Predicate {
        Predicate::negate(self)
    }
}

#[cfg(test)]
mod tests {
    use super::PredicateCompositionExt;
    use sql_orm_core::SqlValue;
    use sql_orm_query::{Expr, Predicate};

    #[test]
    fn and_combines_two_predicates() {
        let left = Predicate::eq(
            Expr::value(SqlValue::Bool(true)),
            Expr::value(SqlValue::Bool(true)),
        );
        let right = Predicate::gt(
            Expr::value(SqlValue::I64(10)),
            Expr::value(SqlValue::I64(5)),
        );

        assert_eq!(
            left.clone().and(right.clone()),
            Predicate::and(vec![left, right])
        );
    }

    #[test]
    fn and_flattens_existing_and_groups() {
        let first = Predicate::eq(Expr::value(SqlValue::I64(1)), Expr::value(SqlValue::I64(1)));
        let second = Predicate::eq(Expr::value(SqlValue::I64(2)), Expr::value(SqlValue::I64(2)));
        let third = Predicate::eq(Expr::value(SqlValue::I64(3)), Expr::value(SqlValue::I64(3)));

        assert_eq!(
            Predicate::and(vec![first.clone(), second.clone()]).and(third.clone()),
            Predicate::and(vec![first, second, third])
        );
    }

    #[test]
    fn or_combines_and_flattens_predicates() {
        let first = Predicate::eq(Expr::value(SqlValue::I64(1)), Expr::value(SqlValue::I64(1)));
        let second = Predicate::eq(Expr::value(SqlValue::I64(2)), Expr::value(SqlValue::I64(2)));
        let third = Predicate::eq(Expr::value(SqlValue::I64(3)), Expr::value(SqlValue::I64(3)));

        assert_eq!(
            Predicate::or(vec![first.clone(), second.clone()]).or(third.clone()),
            Predicate::or(vec![first, second, third])
        );
    }

    #[test]
    fn not_wraps_predicate_in_negation() {
        let predicate = Predicate::eq(
            Expr::value(SqlValue::Bool(true)),
            Expr::value(SqlValue::Bool(false)),
        );

        assert_eq!(predicate.clone().not(), Predicate::negate(predicate));
    }
}