rok-fluent 0.4.1

Eloquent-inspired async ORM for Rust (PostgreSQL, MySQL, SQLite)
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

//! MySQL binding helpers for [`SqlValue`].

use sqlx::mysql::MySqlArguments;
use sqlx::{query::Query, query::QueryAs, MySql};

use crate::core::condition::SqlValue;

pub fn bind_value<'q>(
    q: Query<'q, MySql, MySqlArguments>,
    v: SqlValue,
) -> Query<'q, MySql, MySqlArguments> {
    match v {
        SqlValue::Text(s) => q.bind(s),
        SqlValue::Integer(n) => q.bind(n),
        SqlValue::Float(f) => q.bind(f),
        SqlValue::Bool(b) => q.bind(b),
        SqlValue::Null => q.bind(Option::<String>::None),
        // MySQL stores JSON natively as text; UUID as CHAR(36); no native arrays.
        SqlValue::Json(j) => q.bind(j.to_string()),
        SqlValue::Uuid(u) => q.bind(u.to_string()),
        SqlValue::Array(vals) => {
            let s: Vec<String> = vals.iter().map(|v| v.to_sql_literal()).collect();
            q.bind(format!("{{{}}}", s.join(",")))
        }
    }
}

pub fn bind_value_as<'q, T>(
    q: QueryAs<'q, MySql, T, MySqlArguments>,
    v: SqlValue,
) -> QueryAs<'q, MySql, T, MySqlArguments>
where
    T: for<'r> sqlx::FromRow<'r, sqlx::mysql::MySqlRow>,
{
    match v {
        SqlValue::Text(s) => q.bind(s),
        SqlValue::Integer(n) => q.bind(n),
        SqlValue::Float(f) => q.bind(f),
        SqlValue::Bool(b) => q.bind(b),
        SqlValue::Null => q.bind(Option::<String>::None),
        SqlValue::Json(j) => q.bind(j.to_string()),
        SqlValue::Uuid(u) => q.bind(u.to_string()),
        SqlValue::Array(vals) => {
            let s: Vec<String> = vals.iter().map(|v| v.to_sql_literal()).collect();
            q.bind(format!("{{{}}}", s.join(",")))
        }
    }
}

pub fn build_query<'q>(sql: &'q str, params: Vec<SqlValue>) -> Query<'q, MySql, MySqlArguments> {
    params
        .into_iter()
        .fold(sqlx::query(sql), |q, v| bind_value(q, v))
}

pub async fn fetch_all_as<T>(
    pool: &sqlx::MySqlPool,
    sql: &str,
    params: Vec<SqlValue>,
) -> Result<Vec<T>, sqlx::Error>
where
    T: for<'r> sqlx::FromRow<'r, sqlx::mysql::MySqlRow> + Send + Unpin,
{
    let mut q = sqlx::query_as::<MySql, T>(sql);
    for v in params {
        q = bind_value_as(q, v);
    }
    q.fetch_all(pool).await
}

pub async fn fetch_optional_as<T>(
    pool: &sqlx::MySqlPool,
    sql: &str,
    params: Vec<SqlValue>,
) -> Result<Option<T>, sqlx::Error>
where
    T: for<'r> sqlx::FromRow<'r, sqlx::mysql::MySqlRow> + Send + Unpin,
{
    let mut q = sqlx::query_as::<MySql, T>(sql);
    for v in params {
        q = bind_value_as(q, v);
    }
    q.fetch_optional(pool).await
}

pub async fn execute(
    pool: &sqlx::MySqlPool,
    sql: &str,
    params: Vec<SqlValue>,
) -> Result<u64, sqlx::Error> {
    let result = build_query(sql, params).execute(pool).await?;
    Ok(result.rows_affected())
}