xql 0.2.4

SQL query builder
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
139
140
141
142
143
144
145
146
147
148
149

# xql

> An SQL query builder for [sqlx][sqlx]. **Work in progress**

# example usages

Suppose you have a table like this:

```sql
CREATE TABLE book(
  id      INTEGER   NOT NULL PRIMARY KEY,
  title   TEXT      NOT NULL,
  year    SMALLINT  NOT NULL,
  author  TEXT
);
```

The CRUD (or ISUD with sql acronym) will be look like this:

1. `INSERT` statement.

```rust
let book1 = "The Fellowship of the Rings".to_string();
let auth1 = "J. R. R. Tolkien".to_string();
let book2 = "Dune".to_string();
let auth2 = "Frank Herbret".to_string();

let insert = xql::insert("book", ["id", "title", "year", "author"])
    .values([
        (1_i32, &book1, 1954_i16, &auth1),
        (2_i32, &book2, 1965_i16, &auth2),
    ])
    .returning(["id"]);

assert_eq!(
    insert.to_string(),
    "INSERT INTO book(id, title, year, author) VALUES \
    (1, 'The Fellowship of the Rings', 1954, 'J. R. R. Tolkien'), \
    (2, 'Dune', 1965, 'Frank Herbret') \
    RETURNING id",
);
```

2. `SELECT` statement.

```rust
use xql::blanket::ExprExt;
use xql::ops::or;

let select = xql::select(["id", "title"])
    .from("book")
    .filter(or(
        "id".equal(1),
        "id".equal(2),
    ))
    .order_by(xql::desc("year"));

assert_eq!(
    select.to_string(),
    "SELECT id, title \
    FROM book \
    WHERE id = 1 OR id = 2 \
    ORDER BY year DESC"
);
```

3. `UPDATE` statement.

```rust
let author = &"Frank Herbert".to_string();
let update = xql::update("book")
    .set("author", author)
    .filter(xql::eq("id", 2))
    .returning(["id"]);

assert_eq!(
    update.to_string(),
    "UPDATE book \
    SET author = 'Frank Herbert' \
    WHERE id = 2 \
    RETURNING id",
);
```

4. `DELETE` statement.

```rust
let delete = xql::delete("book")
    .filter(xql::eq("id", 1))
    .returning(["id", "title"]);

assert_eq!(
    delete.to_string(),
    "DELETE FROM book \
    WHERE id = 1 \
    RETURNING id, title",
);
```

To execute those queries, add [sqlx][sqlx] to dependencies and enable the backend.

```rust
#[cfg(all(feature = "postgres", not(feature = "mysql"), not(feature = "sqlite")))]
async fn execute<'a>(
    pool: sqlx::Pool<sqlx::Postgres>,
    insert: xql::stmt::insert::Insert<'a>,
    select: xql::stmt::select::Select<'a>,
    update: xql::stmt::update::Update<'a>,
    delete: xql::stmt::delete::Delete<'a>,
) -> Result<(), sqlx::Error> {
    xql::exec::fetch_all(insert, &pool).await?;
    xql::exec::fetch_all(select, &pool).await?;
    xql::exec::fetch_all(update, &pool).await?;
    xql::exec::fetch_all(delete, &pool).await?;
    Ok(())
}

#[cfg(all(not(feature = "postgres"), feature = "mysql", not(feature = "sqlite")))]
async fn execute<'a>(
    pool: sqlx::Pool<sqlx::MySql>,
    insert: xql::stmt::insert::Insert<'a>,
    select: xql::stmt::select::Select<'a>,
    update: xql::stmt::update::Update<'a>,
    delete: xql::stmt::delete::Delete<'a>,
) -> Result<(), sqlx::Error> {
    xql::exec::fetch_all(insert, &pool).await?;
    xql::exec::fetch_all(select, &pool).await?;
    xql::exec::fetch_all(update, &pool).await?;
    xql::exec::fetch_all(delete, &pool).await?;
    Ok(())
}

#[cfg(all(not(feature = "postgres"), not(feature = "mysql"), feature = "sqlite"))]
async fn execute<'a>(
    pool: sqlx::Pool<sqlx::Sqlite>,
    insert: xql::stmt::insert::Insert<'a>,
    select: xql::stmt::select::Select<'a>,
    update: xql::stmt::update::Update<'a>,
    delete: xql::stmt::delete::Delete<'a>,
) -> Result<(), sqlx::Error> {
    xql::exec::fetch_all(insert, &pool).await?;
    xql::exec::fetch_all(select, &pool).await?;
    xql::exec::fetch_all(update, &pool).await?;
    xql::exec::fetch_all(delete, &pool).await?;
    Ok(())
}
```

[sqlx]: https://crates.io/crates/sqlx