welds 0.5.0

An async ORM for (postgres, mssql, mysql, sqlite)
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

use super::*;

// Test Object that can be used to write SQL
use crate::WeldsModel;

#[derive(Debug, WeldsModel)]
#[welds(schema = "da_schemaname", table = "da_tablename")]
#[welds_path(crate)] // needed only within the welds crate.
struct Product {
    #[welds(rename = "dbname")]
    pub name: String,
}

// Tests

#[test]
fn should_write_basic_select() {
    let q = QueryBuilder::<Product>::new();
    assert_eq!(
        "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1",
        q.to_sql(Syntax::Postgres)
    );
}

#[test]
fn should_exec_basic_select() {
    let q = QueryBuilder::<Product>::new();
    let ran_sql = futures::executor::block_on(async move {
        let client = welds_connections::noop::build(Syntax::Postgres);
        q.run(&client).await.unwrap();
        client.last_sql()
    })
    .unwrap();
    assert_eq!(
        "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1",
        &ran_sql
    );
}

#[test]
fn should_write_basic_count() {
    let q = QueryBuilder::<Product>::new();
    assert_eq!(
        "SELECT CAST( COUNT(t1.*) as BIGINT ) FROM da_schemaname.da_tablename t1",
        q.to_sql_count(Syntax::Postgres)
    );
}

#[test]
fn should_exec_basic_count() {
    let q = QueryBuilder::<Product>::new();
    let ran_sql = futures::executor::block_on(async move {
        let client = welds_connections::noop::build(Syntax::Postgres);
        let _ = q.count(&client).await;
        client.last_sql()
    })
    .unwrap();
    assert_eq!(
        "SELECT CAST( COUNT(t1.*) as BIGINT ) FROM da_schemaname.da_tablename t1",
        &ran_sql
    );
}

#[test]
fn should_be_able_to_add_basic_where() {
    //making sure it compiles, and doesn't barf when running
    let _q = QueryBuilder::<Product>::new().where_col(|c| c.name.equal("bla"));
}

#[test]
fn should_be_able_to_write_sql_with_basic_where() {
    let q = QueryBuilder::<Product>::new().where_col(|c| c.name.equal("bla"));
    let sql = q.to_sql(Syntax::Sqlite);
    assert_eq!(
        "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.\"dbname\" = ? )",
        &sql
    );
}

#[test]
fn should_be_able_to_write_sql_count_with_basic_where() {
    let q = QueryBuilder::<Product>::new().where_col(|c| c.name.equal("bla"));
    let sql = q.to_sql_count(Syntax::Sqlite);
    assert_eq!(
        "SELECT CAST( COUNT(*) as BIGINT ) FROM da_schemaname.da_tablename t1 WHERE ( t1.\"dbname\" = ? )",
        &sql
    );
}

#[test]
fn should_exec_basic_with_where() {
    let q = QueryBuilder::<Product>::new().where_col(|c| c.name.equal("bla"));
    let ran_sql = futures::executor::block_on(async move {
        let client = welds_connections::noop::build(Syntax::Mssql);
        q.run(&client).await.unwrap();
        client.last_sql()
    })
    .unwrap();
    assert_eq!(
        "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.\"dbname\" = @p1 )",
        &ran_sql
    );
}

#[test]
fn sqlite_syntax_should_be_translated_to_like() {
    let q = QueryBuilder::<Product>::new().where_col(|c| c.name.ilike("bla"));
    let ran_sql = futures::executor::block_on(async move {
        let client = welds_connections::noop::build(Syntax::Sqlite);
        q.run(&client).await.unwrap();
        client.last_sql()
    })
    .unwrap();
    assert_eq!(
        "SELECT t1.\"dbname\" FROM da_schemaname.da_tablename t1 WHERE ( t1.\"dbname\" like ? )",
        &ran_sql
    );
}