sqlmodel 0.2.2

SQL databases in Rust, designed to be intuitive and type-safe
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

#![cfg(feature = "c-sqlite-tests")]

use asupersync::runtime::RuntimeBuilder;
use asupersync::{Cx, Outcome};

use sqlmodel::SchemaBuilder;
use sqlmodel::prelude::*;
use sqlmodel_sqlite::SqliteConnection;

fn unwrap_outcome<T>(outcome: Outcome<T, Error>) -> std::result::Result<T, String> {
    match outcome {
        Outcome::Ok(v) => Ok(v),
        Outcome::Err(e) => Err(format!("unexpected error: {e}")),
        Outcome::Cancelled(r) => Err(format!("cancelled: {r:?}")),
        Outcome::Panicked(p) => Err(format!("panicked: {p:?}")),
    }
}

#[derive(sqlmodel::Model, Debug, Clone, PartialEq)]
#[sqlmodel(table)]
struct User {
    #[sqlmodel(primary_key)]
    id: i64,
    name: String,
}

#[test]
fn sqlite_select_one_enforces_exactly_one_row() {
    let rt = RuntimeBuilder::current_thread()
        .build()
        .expect("create asupersync runtime");
    let cx = Cx::for_testing();

    rt.block_on(async {
        let conn = SqliteConnection::open_memory().expect("open sqlite memory db");

        let stmts = SchemaBuilder::new().create_table::<User>().build();
        for stmt in stmts {
            unwrap_outcome(conn.execute(&cx, &stmt, &[]).await).expect("execute ddl");
        }

        unwrap_outcome(
            conn.execute(
                &cx,
                "INSERT INTO users (id, name) VALUES (?1, ?2)",
                &[Value::BigInt(1), Value::Text("Alice".to_string())],
            )
            .await,
        )
        .expect("insert alice");
        unwrap_outcome(
            conn.execute(
                &cx,
                "INSERT INTO users (id, name) VALUES (?1, ?2)",
                &[Value::BigInt(2), Value::Text("Bob".to_string())],
            )
            .await,
        )
        .expect("insert bob");

        let alice = unwrap_outcome(
            select!(User)
                .filter(Expr::col("id").eq(1_i64))
                .one(&cx, &conn)
                .await,
        )
        .expect("one should return alice");
        assert_eq!(
            alice,
            User {
                id: 1,
                name: "Alice".to_string()
            }
        );

        let none = select!(User)
            .filter(Expr::col("id").eq(999_i64))
            .one(&cx, &conn)
            .await;
        assert!(matches!(none, Outcome::Err(Error::Custom(_))));
        if let Outcome::Err(Error::Custom(msg)) = none {
            assert!(msg.contains("found none"));
        }

        let many = select!(User).one(&cx, &conn).await;
        assert!(matches!(many, Outcome::Err(Error::Custom(_))));
        if let Outcome::Err(Error::Custom(msg)) = many {
            assert!(
                msg.contains("Expected zero or one row, found 2"),
                "unexpected message: {msg}"
            );
        }

        let one_or_none_hit = unwrap_outcome(
            select!(User)
                .filter(Expr::col("id").eq(1_i64))
                .one_or_none(&cx, &conn)
                .await,
        )
        .expect("one_or_none should return alice");
        assert_eq!(
            one_or_none_hit,
            Some(User {
                id: 1,
                name: "Alice".to_string()
            })
        );

        let one_or_none_missing = unwrap_outcome(
            select!(User)
                .filter(Expr::col("id").eq(999_i64))
                .one_or_none(&cx, &conn)
                .await,
        )
        .expect("one_or_none should return none");
        assert!(one_or_none_missing.is_none());

        let one_or_none_many = select!(User).one_or_none(&cx, &conn).await;
        assert!(matches!(one_or_none_many, Outcome::Err(Error::Custom(_))));
        if let Outcome::Err(Error::Custom(msg)) = one_or_none_many {
            assert!(
                msg.contains("Expected zero or one row, found 2"),
                "unexpected message: {msg}"
            );
        }
    });
}