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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use super::*;
use crate::model_traits::Column;
use crate::model_traits::HasSchema;
use crate::model_traits::TableColumns;
use crate::model_traits::TableInfo;
use crate::query::clause::Numeric;
use crate::query::clause::NumericOpt;

// Testing that the tail end of the SQL is correct
// Limits / skips / orders

#[allow(dead_code)]
struct Product {
    pub a: i32,
    pub b: i32,
}

impl TryFrom<Row> for Product {
    type Error = crate::WeldsError;
    fn try_from(_value: Row) -> std::result::Result<Self, Self::Error> {
        Ok(Product { a: 0, b: 0 })
    }
}

pub struct ProductSchema {
    a: Numeric<i32>,
    b: NumericOpt<i32>,
}

impl Default for ProductSchema {
    fn default() -> Self {
        Self {
            a: Numeric::new("a", "a"),
            b: NumericOpt::new("b", "b"),
        }
    }
}

impl TableInfo for ProductSchema {
    fn identifier() -> &'static [&'static str] {
        &["nums"]
    }
}

impl TableColumns for ProductSchema {
    type ColumnStruct = Self;

    fn select_columns() -> Vec<Column> {
        vec![
            Column::new("a", "i32", false),
            Column::new("b", "i32", true),
        ]
    }
    fn update_columns() -> Vec<Column> {
        vec![
            Column::new("a", "i32", false),
            Column::new("b", "i32", true),
        ]
    }
    fn insert_columns() -> Vec<Column> {
        vec![
            Column::new("a", "i32", false),
            Column::new("b", "i32", true),
        ]
    }

    fn primary_keys() -> Vec<Column> {
        vec![]
    }
}

impl HasSchema for Product {
    type Schema = ProductSchema;
}

// Tests

#[test]
fn should_order_by_asc() {
    let q = QueryBuilder::<Product>::new().order_by_asc(|x| x.a);
    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.\"a\", t1.\"b\" FROM nums t1 ORDER BY t1.\"a\" ASC",
        &ran_sql
    );
}

#[test]
fn should_order_by_two_columns() {
    let q = QueryBuilder::<Product>::new()
        .order_by_asc(|x| x.a)
        .order_by_desc(|x| x.b);
    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.\"a\", t1.\"b\" FROM nums t1 ORDER BY t1.\"a\" ASC, t1.\"b\" DESC",
        &ran_sql
    );
}

#[test]
fn should_be_able_to_limit() {
    let q = QueryBuilder::<Product>::new().limit(10);
    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.\"a\", t1.\"b\" FROM nums t1 ORDER BY 1 LIMIT 10 OFFSET 0 ",
        &ran_sql
    );
}

#[test]
fn should_be_able_to_offset() {
    let q = QueryBuilder::<Product>::new().limit(4).offset(15);
    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.\"a\", t1.\"b\" FROM nums t1 ORDER BY 1 OFFSET 15 LIMIT 4",
        &ran_sql
    );
}