debil 0.5.0

Lightweight ORM for Rust
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

#[cfg(feature = "sqlite")]
mod tests {
    use anyhow::Result;
    use debil::sqlite::*;
    use debil::*;

    #[tokio::test(flavor = "multi_thread")]
    async fn test_create_table() -> Result<(), Error> {
        #[derive(Table, PartialEq, Debug)]
        #[sql(table_name = "test", sql_type = "SqliteValue", primary_key = "id")]
        struct Test {
            id: i64,
            name: String,
        }

        let mut conn = DebilConn::new(rusqlite::Connection::open_in_memory().unwrap());
        conn.sql_exec(
            "CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)".to_string(),
            Params(vec![]),
        )
        .await?;

        conn.sql_exec(
            "INSERT INTO test VALUES (:id, :name)".to_string(),
            Params(vec![
                (":id".to_string(), SqlValue::serialize(100)),
                (":name".to_string(), SqlValue::serialize("foo".to_string())),
            ]),
        )
        .await?;

        let rs = conn
            .sql_query::<Test>(
                "SELECT * FROM test WHERE id = :id".to_string(),
                Params(vec![(":id".to_string(), SqlValue::serialize(100))]),
            )
            .await?;
        assert_eq!(
            rs,
            vec![Test {
                id: 100,
                name: "foo".to_string(),
            }]
        );

        Ok(())
    }

    #[tokio::test]
    async fn test_create_and_drop_index() -> Result<()> {
        let conn = rusqlite::Connection::open_in_memory()?;
        conn.execute(
            "CREATE TABLE person (
            id INTEGER PRIMARY KEY,
            name TEXT NOT NULL,
            age INTEGER NOT NULL
        )",
            [],
        )?;

        // test: create_index should be executed
        conn.execute(&create_index("person", "name", &["name"]), [])?;

        // test: create_index should be executed even if the index already exists
        conn.execute(&create_index("person", "name", &["name"]), [])?;

        // test: drop_index should be executed
        conn.execute(&drop_index("person", "name"), [])?;

        // test: drop_index should be executed even if the index does not exists
        conn.execute(&drop_index("person", "name"), [])?;

        Ok(())
    }
}