sqlitex 0.2.4

An ergonomic sqlite library with compile time guarantees
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

#[warn(unused)]
use sqlitex::sqlitex;

#[sqlitex]
pub struct NestedTxDao {
    create_table: sql!(
        "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY NOT NULL, val TEXT NOT NULL)"
    ),
    insert: sql!("INSERT INTO test (id, val) VALUES (?, ?)"),
    count: sql!("SELECT COUNT(*) as count FROM test"),
    clear: sql!("DELETE FROM test"),
}

#[cfg(test)]
mod nested_tests {
    use std::sync::Arc;

    use super::*;

    fn setup() -> (NestedTxDao, Arc<sqlitex::Connection>) {
        let conn = sqlitex::Connection::open_memory().unwrap();
        let runtime_conn = conn.clone();
        let mut db = NestedTxDao::new(conn);
        db.create_table().unwrap();
        (db, runtime_conn)
    }

    #[test]
    fn test_macro_tx_inner_fails_outer_succeeds() -> Result<(), Box<dyn std::error::Error>> {
        let (mut db, _) = setup();

        db.transaction(|tx1| {
            tx1.insert(1, "Outer layer")?;

            let inner_result = tx1.transaction(|tx2| {
                tx2.insert(2, "Inner layer")?;
                tx2.insert(2, "Duplicate - will crash!")?;
                Ok(())
            });

            assert!(inner_result.is_err());
            Ok(())
        })?;

        let count = db.count()?.first()?.unwrap().count;
        assert_eq!(count, 1);
        Ok(())
    }

    #[test]
    fn test_insert_bulk_inside_macro_tx() -> Result<(), Box<dyn std::error::Error>> {
        let (mut db, _) = setup();

        db.transaction(|tx| {
            tx.insert(1, "Singular insert")?;
            tx.insert_bulk(&[
                (2, "Batch item 1".to_string()),
                (3, "Batch item 2".to_string()),
            ])?;
            Ok(())
        })?;

        let count = db.count()?.first()?.unwrap().count;
        assert_eq!(count, 3);
        Ok(())
    }

    #[test]
    fn test_runtime_inner_rollback_outer_commit() -> Result<(), Box<dyn std::error::Error>> {
        let (mut db, runtime_conn) = setup();

        runtime_conn.transaction(|conn1| {
            conn1.execute("INSERT INTO test (id, val) VALUES (1, 'Runtime Outer')")?;

            let inner_result = conn1.transaction(|conn2| {
                conn2.execute("INSERT INTO test (id, val) VALUES (2, 'Runtime Inner')")?;
                conn2.execute("INSERT INTO test (id, val) VALUES (2, 'Duplicate')")?;
                Ok(())
            });

            assert!(inner_result.is_err());
            Ok(())
        })?;

        let count = db.count()?.first()?.unwrap().count;
        assert_eq!(count, 1);
        Ok(())
    }

    #[test]
    fn test_mixed_macro_and_runtime_tx() -> Result<(), Box<dyn std::error::Error>> {
        let (mut db, runtime_conn) = setup();

        db.transaction(|tx| {
            tx.insert(1, "Macro Outer")?;
            runtime_conn.transaction(|conn| {
                conn.execute("INSERT INTO test (id, val) VALUES (2, 'Runtime Inner')")?;
                Ok(())
            })?;
            Ok(())
        })?;

        let count = db.count()?.first()?.unwrap().count;
        assert_eq!(count, 2);
        Ok(())
    }

    #[test]
    fn test_four_layer_deep_nesting() -> Result<(), Box<dyn std::error::Error>> {
        let (mut db, runtime_conn) = setup();

        db.transaction(|t1| {
            t1.insert(1, "L1")?;

            t1.transaction(|t2| {
                t2.insert(2, "L2")?;

                runtime_conn.transaction(|conn| {
                    conn.execute("INSERT INTO test (id, val) VALUES (3, 'L3')")?;
                    t2.insert_bulk(&[(4, "L4A".to_string()), (5, "L4B".to_string())])?;
                    Ok(())
                })?;
                Ok(())
            })?;
            Ok(())
        })?;

        let count = db.count()?.first()?.unwrap().count;
        assert_eq!(count, 5);
        Ok(())
    }
}