chain-builder 2.1.1

A typed, dialect-aware SQL query builder for Rust (PostgreSQL/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

//! T5 — v2 sqlx handoff tests.
//!
//! Each test is gated by a single backend feature so the file compiles under
//! one-backend feature sets (the 1.x crate cannot build with 2+ sqlx backends
//! at once). Asserts the sqlx query's SQL equals the builder's `to_sql().0`.

// A trivial row type used only for the `to_sqlx_query_as` compile-smoke checks.
#[cfg(any(
    feature = "sqlx_postgres",
    feature = "sqlx_mysql",
    feature = "sqlx_sqlite"
))]
#[derive(Debug)]
#[allow(dead_code)]
struct IdRow {
    id: i64,
}

#[cfg(feature = "sqlx_postgres")]
impl<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> for IdRow {
    fn from_row(row: &'r sqlx::postgres::PgRow) -> Result<Self, sqlx::Error> {
        use sqlx::Row;
        Ok(IdRow {
            id: row.try_get("id")?,
        })
    }
}

#[cfg(feature = "sqlx_mysql")]
impl<'r> sqlx::FromRow<'r, sqlx::mysql::MySqlRow> for IdRow {
    fn from_row(row: &'r sqlx::mysql::MySqlRow) -> Result<Self, sqlx::Error> {
        use sqlx::Row;
        Ok(IdRow {
            id: row.try_get("id")?,
        })
    }
}

#[cfg(feature = "sqlx_sqlite")]
impl<'r> sqlx::FromRow<'r, sqlx::sqlite::SqliteRow> for IdRow {
    fn from_row(row: &'r sqlx::sqlite::SqliteRow) -> Result<Self, sqlx::Error> {
        use sqlx::Row;
        Ok(IdRow {
            id: row.try_get("id")?,
        })
    }
}

#[cfg(feature = "sqlx_postgres")]
#[test]
fn postgres_to_sqlx_sql_matches_to_sql() {
    use chain_builder::{Postgres, QueryBuilder};
    use sqlx::Execute;
    let qb = QueryBuilder::<Postgres>::table("users")
        .select(["id"])
        .where_eq("status", "active");
    let (sql, _) = qb.to_sql();
    let q = qb.to_sqlx_query();
    assert_eq!(q.sql(), sql);
}

#[cfg(feature = "sqlx_postgres")]
#[test]
fn postgres_to_sqlx_query_as_compiles() {
    use chain_builder::{Postgres, QueryBuilder};
    use sqlx::Execute;
    let qb = QueryBuilder::<Postgres>::table("users")
        .select(["id"])
        .where_eq("status", "active");
    let (sql, _) = qb.to_sql();
    let q = qb.to_sqlx_query_as::<IdRow>();
    assert_eq!(q.sql(), sql);
}

#[cfg(feature = "sqlx_mysql")]
#[test]
fn mysql_to_sqlx_sql_matches_to_sql() {
    use chain_builder::{MySql, QueryBuilder};
    use sqlx::Execute;
    let qb = QueryBuilder::<MySql>::table("users")
        .select(["id"])
        .where_eq("status", "active");
    let (sql, _) = qb.to_sql();
    let q = qb.to_sqlx_query();
    assert_eq!(q.sql(), sql);
}

#[cfg(feature = "sqlx_mysql")]
#[test]
fn mysql_to_sqlx_query_as_compiles() {
    use chain_builder::{MySql, QueryBuilder};
    use sqlx::Execute;
    let qb = QueryBuilder::<MySql>::table("users")
        .select(["id"])
        .where_eq("status", "active");
    let (sql, _) = qb.to_sql();
    let q = qb.to_sqlx_query_as::<IdRow>();
    assert_eq!(q.sql(), sql);
}

#[cfg(feature = "sqlx_sqlite")]
#[test]
fn sqlite_to_sqlx_sql_matches_to_sql() {
    use chain_builder::{QueryBuilder, Sqlite};
    use sqlx::Execute;
    let qb = QueryBuilder::<Sqlite>::table("users")
        .select(["id"])
        .where_eq("status", "active");
    let (sql, _) = qb.to_sql();
    let q = qb.to_sqlx_query();
    assert_eq!(q.sql(), sql);
}

#[cfg(feature = "sqlx_sqlite")]
#[test]
fn sqlite_to_sqlx_query_as_compiles() {
    use chain_builder::{QueryBuilder, Sqlite};
    use sqlx::Execute;
    let qb = QueryBuilder::<Sqlite>::table("users")
        .select(["id"])
        .where_eq("status", "active");
    let (sql, _) = qb.to_sql();
    let q = qb.to_sqlx_query_as::<IdRow>();
    assert_eq!(q.sql(), sql);
}