microrm 0.6.3

Lightweight ORM using sqlite as a backend
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

use microrm::prelude::*;
use test_log::test;

mod common;

struct CR;
impl Relation for CR {
    type Domain = Customer;
    type Range = Receipt;

    const NAME: &'static str = "CR";
}

#[derive(Entity)]
struct Customer {
    name: String,
    receipts: microrm::RelationDomain<CR>,
}

#[derive(Entity)]
struct Receipt {
    value: usize,
    customers: microrm::RelationRange<CR>,
}

#[derive(Schema)]
struct ReceiptDB {
    customers: microrm::IDMap<Customer>,
    receipts: microrm::IDMap<Receipt>,
}

#[test]
fn check_schema_creation() {
    let (_pool, _db): (_, ReceiptDB) = common::open_test_db!();
}

#[test]
fn simple_operations() {
    let (pool, db): (_, ReceiptDB) = common::open_test_db!();
    let mut txn = pool.start().unwrap();

    let ca = db
        .customers
        .insert(
            &mut txn,
            Customer {
                name: "customer A".to_string(),
                receipts: Default::default(),
            },
        )
        .expect("couldn't insert customer record");

    let ra = db
        .receipts
        .insert(
            &mut txn,
            Receipt {
                value: 32usize,
                customers: Default::default(),
            },
        )
        .expect("couldn't insert receipt record");

    let rb = db
        .receipts
        .insert(
            &mut txn,
            Receipt {
                value: 64usize,
                customers: Default::default(),
            },
        )
        .expect("couldn't insert receipt record");

    let e_ca = db
        .customers
        .by_id(&mut txn, ca)
        .expect("couldn't retrieve customer record")
        .expect("no customer record");

    log::trace!(
        "connecting customer a (ID {:?}) to receipt a (ID {:?})",
        ca,
        ra
    );
    e_ca.receipts
        .connect_to(&mut txn, ra)
        .expect("couldn't relationiate customer with receipt a");
    log::trace!(
        "connecting customer a (ID {:?}) to receipt b (ID {:?})",
        ca,
        rb
    );
    e_ca.receipts
        .connect_to(&mut txn, rb)
        .expect("couldn't relationiate customer with receipt b");

    log::trace!("connected!");

    // technically this can fail if sqlite gives ra and rb back in the opposite order, which is
    // valid behaviour
    assert_eq!(
        e_ca.receipts
            .get(&mut txn)
            .expect("couldn't get receipts related with customer")
            .into_iter()
            .map(|x| x.id())
            .collect::<Vec<_>>(),
        vec![ra, rb]
    );

    // check that the reverse direction was also added
    let e_ra = db
        .receipts
        .by_id(&mut txn, ra)
        .expect("couldn't retreieve receipt record")
        .expect("no receipt record");

    assert_eq!(
        e_ra.customers
            .get(&mut txn)
            .expect("couldn't get related customers")
            .into_iter()
            .map(|x| x.id())
            .collect::<Vec<_>>(),
        vec![ca]
    );
}