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

use microrm::prelude::*;

// very simple schema with a bunch of strings and blobs
mod schema {
    use microrm::prelude::*;

    #[derive(Entity, PartialEq, Clone)]
    pub struct KVEntry {
        #[key]
        pub key: String,

        pub value: Vec<u8>,
    }

    #[derive(Schema)]
    pub struct KVSchema {
        pub kvs: microrm::IDMap<KVEntry>,
    }
}

#[global_allocator]
static ALLOCATOR: alloc_tracker::Allocator<std::alloc::System> = alloc_tracker::Allocator::system();

fn main() {
    let (cp, schema): (_, schema::KVSchema) =
        microrm::ConnectionPool::open(":memory:").expect("could not open in-memory database?");

    cp.run_transaction(1, |txn| {
        schema.kvs.insert_ref(
            txn,
            schema::KVEntryRef {
                key: "keyA",
                value: &[],
            },
        )?;

        schema.kvs.insert_ref(
            txn,
            schema::KVEntryRef {
                key: "keyB",
                value: &[1, 2, 3],
            },
        )?;

        schema.kvs.insert_ref(
            txn,
            schema::KVEntryRef {
                key: "keyC",
                value: &[3, 2, 1],
            },
        )?;

        Ok(())
    })
    .expect("could not insert initial data");

    let session = alloc_tracker::Session::new();

    // do a query warmup with both methods, because each query type requires caching a sqlite
    // statement.
    cp.run_transaction(1, |txn| {
        schema.kvs.iter(txn)?.for_each(|_| ());
        schema
            .kvs
            .iter_refs(txn, |_| std::ops::ControlFlow::Continue(()))?;
        Ok(())
    })
    .expect("warmup failed");

    // now iterate and print things out with both iteration methods
    {
        println!("iter():");
        let operation = session.operation("iter()");
        let _span = operation.measure_thread();
        cp.run_transaction(1, |txn| {
            for kv in schema.kvs.iter(txn)? {
                let kv = kv?;
                println!("kv entry: key = {}, values = {:?}", kv.key, kv.value);
            }
            Ok(())
        })
        .expect("could not iterate over data");
    }

    {
        println!("iter_refs():");
        let operation = session.operation("iter_refs()");
        let _span = operation.measure_thread();
        cp.run_transaction(1, |txn| {
            schema.kvs.iter_refs(txn, |kv| {
                println!("kv entry: key = {}, values = {:?}", kv.key, kv.value);
                std::ops::ControlFlow::Continue(())
            })
        })
        .expect("could not iterate over data");
    }

    // should show zero allocations for the iter_refs() version.
    session.print_to_stdout();
}