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

mod common;
use test_log::test;

use microrm::prelude::*;

#[derive(Entity)]
struct Object {
    written: String,
}

#[derive(Entity)]
struct Subject {
    written: String,
}

#[derive(Entity)]
struct Verb {
    written: String,
}

#[derive(Schema)]
struct DictionarySchema {
    objects: microrm::IDMap<Object>,
    subjects: microrm::IDMap<Subject>,
    verbs: microrm::IDMap<Verb>,
}

#[derive(Entity)]
struct Sentence {
    object: ObjectID,
    subject: SubjectID,
    verb: VerbID,
}

#[derive(Schema)]
struct SentenceSchema {
    sentences: microrm::IDMap<Sentence>,
}

#[derive(Schema)]
struct CombinedSchema {
    dictionary: DictionarySchema,
    sentence: SentenceSchema,
}

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

    let obj_id = db
        .dictionary
        .objects
        .insert(
            &mut txn,
            Object {
                written: String::from("an_object"),
            },
        )
        .expect("couldn't insert object");

    let subj_id = db
        .dictionary
        .subjects
        .insert(
            &mut txn,
            Subject {
                written: String::from("a_subject"),
            },
        )
        .expect("couldn't insert subject");

    let verb_id = db
        .dictionary
        .verbs
        .insert(
            &mut txn,
            Verb {
                written: String::from("verb1"),
            },
        )
        .expect("couldn't insert verb");

    db.sentence
        .sentences
        .insert(
            &mut txn,
            Sentence {
                object: obj_id,
                subject: subj_id,
                verb: verb_id,
            },
        )
        .expect("couldn't insert sentence");
}