tank 0.41.0

Tank (Table Abstraction and Navigation Kit): the Rust data layer. Simple and flexible ORM that allows to manage in a unified way data from different sources.
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

#[cfg(test)]
mod tests {
    use tank::{
        Entity, Expression, FindOrder, GenericSqlWriter, IsAggregateFunction, IsAlias, IsAsterisk,
        IsConstant, IsFalse, IsQuestionMark, IsTrue, Order, expr,
    };

    #[derive(Entity)]
    struct Table {
        pub col_a: i64,
        #[tank(name = "second_column")]
        pub col_b: i128,
        pub str_column: String,
    }

    const WRITER: GenericSqlWriter = GenericSqlWriter {};

    #[test]
    fn visitor_is_true() {
        let mut out = Default::default();
        let mut ctx = Default::default();
        let error = expr!(true);
        assert!(error.accept_visitor(&mut IsTrue, &WRITER, &mut ctx, &mut out));
        let e = expr!(false);
        assert!(!e.accept_visitor(&mut IsTrue, &WRITER, &mut ctx, &mut out));
        let e = expr!(42);
        assert!(!e.accept_visitor(&mut IsTrue, &WRITER, &mut ctx, &mut out));
    }

    #[test]
    fn visitor_is_false() {
        let mut out = Default::default();
        let mut ctx = Default::default();
        let e = expr!(false);
        assert!(e.accept_visitor(&mut IsFalse, &WRITER, &mut ctx, &mut out));
        let e = expr!(true);
        assert!(!e.accept_visitor(&mut IsFalse, &WRITER, &mut ctx, &mut out));
    }

    #[test]
    fn visitor_is_constant() {
        let mut out = Default::default();
        let mut ctx = Default::default();
        let e = expr!(42);
        assert!(e.accept_visitor(&mut IsConstant, &WRITER, &mut ctx, &mut out));
        let e = expr!(NULL);
        assert!(e.accept_visitor(&mut IsConstant, &WRITER, &mut ctx, &mut out));
        let e = expr!("hello");
        assert!(e.accept_visitor(&mut IsConstant, &WRITER, &mut ctx, &mut out));
        let e = expr!(3.14);
        assert!(e.accept_visitor(&mut IsConstant, &WRITER, &mut ctx, &mut out));
        let e = expr!(true);
        assert!(e.accept_visitor(&mut IsConstant, &WRITER, &mut ctx, &mut out));
        // Column reference is not constant
        let e = expr!(Table::col_a);
        assert!(!e.accept_visitor(&mut IsConstant, &WRITER, &mut ctx, &mut out));
    }

    #[test]
    fn visitor_is_aggregate() {
        let mut out = Default::default();
        let mut ctx = Default::default();
        let e = expr!(COUNT(*));
        assert!(e.accept_visitor(&mut IsAggregateFunction, &WRITER, &mut ctx, &mut out));
        let e = expr!(SUM(Table::col_a));
        assert!(e.accept_visitor(&mut IsAggregateFunction, &WRITER, &mut ctx, &mut out));
        let e = expr!(AVG(Table::col_a));
        assert!(e.accept_visitor(&mut IsAggregateFunction, &WRITER, &mut ctx, &mut out));
        let e = expr!(MIN(Table::col_a));
        assert!(e.accept_visitor(&mut IsAggregateFunction, &WRITER, &mut ctx, &mut out));
        let e = expr!(MAX(Table::col_a));
        assert!(e.accept_visitor(&mut IsAggregateFunction, &WRITER, &mut ctx, &mut out));

        // Non-aggregate
        let e = expr!(ABS(Table::col_a));
        assert!(!e.accept_visitor(&mut IsAggregateFunction, &WRITER, &mut ctx, &mut out));
        let e = expr!(Table::col_a);
        assert!(!e.accept_visitor(&mut IsAggregateFunction, &WRITER, &mut ctx, &mut out));
        let e = expr!(42);
        assert!(!e.accept_visitor(&mut IsAggregateFunction, &WRITER, &mut ctx, &mut out));
    }

    #[test]
    fn visitor_is_asterisk() {
        let mut out = Default::default();
        let mut ctx = Default::default();
        let e = expr!(*);
        assert!(e.accept_visitor(&mut IsAsterisk, &WRITER, &mut ctx, &mut out));
        let e = expr!(42);
        assert!(!e.accept_visitor(&mut IsAsterisk, &WRITER, &mut ctx, &mut out));
    }

    #[test]
    fn visitor_is_question_mark() {
        let mut out = Default::default();
        let mut ctx = Default::default();
        let e = expr!(?);
        assert!(e.accept_visitor(&mut IsQuestionMark, &WRITER, &mut ctx, &mut out));
        let e = expr!(42);
        assert!(!e.accept_visitor(&mut IsQuestionMark, &WRITER, &mut ctx, &mut out));
    }

    #[test]
    fn visitor_is_alias() {
        let mut out = Default::default();
        let mut ctx = Default::default();
        let mut alias_visitor = IsAlias::default();
        let e = expr!(Table::col_a as my_alias);
        assert!(e.accept_visitor(&mut alias_visitor, &WRITER, &mut ctx, &mut out));
        // Non-alias
        let mut alias_visitor2 = IsAlias::default();
        let e = expr!(Table::col_a);
        assert!(!e.accept_visitor(&mut alias_visitor2, &WRITER, &mut ctx, &mut out));
    }

    #[test]
    fn visitor_find_order() {
        use tank::cols;
        let mut out = Default::default();
        let mut ctx = Default::default();
        {
            let mut finder = FindOrder::default();
            let binding = cols!(Table::col_a ASC);
            let ordered = &binding[0];
            assert!(ordered.accept_visitor(&mut finder, &WRITER, &mut ctx, &mut out));
            assert_eq!(finder.order, Order::ASC);
        }
        {
            let mut finder = FindOrder::default();
            let binding = cols!(Table::col_b DESC);
            let ordered = &binding[0];
            assert!(ordered.accept_visitor(&mut finder, &WRITER, &mut ctx, &mut out));
            assert_eq!(finder.order, Order::DESC);
        }
    }
}