oql 1.0.0

Readable, declarative query syntax for Rust iterators
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

//! Tests for the `join` clause.
//!
//! Covers inner-join semantics: hit → emit, miss → drop, N matches → N emits.

use oql::oql;

#[test]
fn basic_join_on_id() {
    #[derive(Clone)]
    struct Order { id: u32, customer_id: u32, amount: f64 }
    #[derive(Clone)]
    struct Customer { id: u32, name: &'static str }

    let orders = vec![
        Order { id: 1, customer_id: 10, amount: 50.0 },
        Order { id: 2, customer_id: 20, amount: 75.0 },
        Order { id: 3, customer_id: 10, amount: 30.0 },
    ];
    let customers = vec![
        Customer { id: 10, name: "Anna" },
        Customer { id: 20, name: "Ben" },
    ];

    let out: Vec<(u32, &'static str, f64)> = oql! {
        from o in orders
        join c in customers on o.customer_id == c.id
        select (o.id, c.name, o.amount)
    }
    .collect();

    assert_eq!(
        out,
        vec![
            (1, "Anna", 50.0),
            (2, "Ben", 75.0),
            (3, "Anna", 30.0),
        ]
    );
}

#[test]
fn join_drops_non_matching_outer() {
    // Order 2 has customer_id 99 which is not in the customers list; it must
    // disappear entirely (inner-join semantics).
    #[derive(Clone)]
    struct Order { id: u32, customer_id: u32 }
    #[derive(Clone)]
    struct Customer { id: u32, name: &'static str }

    let orders = vec![
        Order { id: 1, customer_id: 10 },
        Order { id: 2, customer_id: 99 },
        Order { id: 3, customer_id: 10 },
    ];
    let customers = vec![Customer { id: 10, name: "Anna" }];

    let out: Vec<(u32, &'static str)> = oql! {
        from o in orders
        join c in customers on o.customer_id == c.id
        select (o.id, c.name)
    }
    .collect();

    assert_eq!(out, vec![(1, "Anna"), (3, "Anna")]);
}

#[test]
fn join_emits_n_per_outer_on_n_matches() {
    // Two customer records share the same id; each matching order must
    // produce two output rows (one per matching customer).
    #[derive(Clone)]
    struct Order { id: u32, customer_id: u32 }
    #[derive(Clone)]
    struct Customer { id: u32, name: &'static str }

    let orders = vec![Order { id: 1, customer_id: 10 }];
    let customers = vec![
        Customer { id: 10, name: "Anna" },
        Customer { id: 10, name: "Ann" },
    ];

    let out: Vec<(u32, &'static str)> = oql! {
        from o in orders
        join c in customers on o.customer_id == c.id
        select (o.id, c.name)
    }
    .collect();

    assert_eq!(out, vec![(1, "Anna"), (1, "Ann")]);
}

#[test]
fn join_then_where() {
    #[derive(Clone)]
    struct Order { id: u32, customer_id: u32, amount: f64 }
    #[derive(Clone)]
    struct Customer { id: u32, country: &'static str }

    let orders = vec![
        Order { id: 1, customer_id: 10, amount: 50.0 },
        Order { id: 2, customer_id: 20, amount: 75.0 },
        Order { id: 3, customer_id: 10, amount: 200.0 },
    ];
    let customers = vec![
        Customer { id: 10, country: "DE" },
        Customer { id: 20, country: "US" },
    ];

    let out: Vec<u32> = oql! {
        from o in orders
        join c in customers on o.customer_id == c.id
        where c.country == "DE"
        where o.amount > 100.0
        select o.id
    }
    .collect();

    assert_eq!(out, vec![3]);
}

#[test]
fn two_joins_in_a_row() {
    #[derive(Clone)]
    struct A { k1: u32, v: &'static str }
    #[derive(Clone)]
    struct B { k1: u32, k2: u32 }
    #[derive(Clone)]
    struct C { k2: u32, w: &'static str }

    let aa = vec![A { k1: 1, v: "a1" }];
    let bb = vec![B { k1: 1, k2: 10 }];
    let cc = vec![C { k2: 10, w: "c1" }];

    let out: Vec<(&'static str, &'static str)> = oql! {
        from a in aa
        join b in bb on a.k1 == b.k1
        join c in cc on b.k2 == c.k2
        select (a.v, c.w)
    }
    .collect();

    assert_eq!(out, vec![("a1", "c1")]);
}

#[test]
fn join_with_string_key() {
    #[derive(Clone)]
    struct User { id: u32, name: String }
    #[derive(Clone)]
    struct Greeting { who: String, text: &'static str }

    let users = vec![
        User { id: 1, name: "alice".to_string() },
        User { id: 2, name: "bob".to_string() },
    ];
    let greetings = vec![
        Greeting { who: "alice".to_string(), text: "hi" },
        Greeting { who: "bob".to_string(), text: "hey" },
    ];

    let out: Vec<(u32, &'static str)> = oql! {
        from u in users
        join g in greetings on u.name == g.who
        select (u.id, g.text)
    }
    .collect();

    assert_eq!(out, vec![(1, "hi"), (2, "hey")]);
}