rdbi 0.5.1

Database abstraction layer built on mysql_async with derive macros
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
150
151
152
153
154
155
156
157
158
159
160
161

//! Query builder for rdbi

use crate::error::Result;
use crate::traits::{ExecuteResult, FromRow, Pool, ToValue};
use crate::value::Value;

/// A query builder that supports fluent parameter binding.
///
/// # Example
///
/// ```ignore
/// use rdbi::{Query, Pool};
///
/// async fn find_user(pool: &impl Pool, id: i64) -> rdbi::Result<Option<User>> {
///     Query::new("SELECT * FROM users WHERE id = ?")
///         .bind(id)
///         .fetch_optional(pool)
///         .await
/// }
/// ```
#[derive(Debug, Clone)]
pub struct Query<'q> {
    sql: &'q str,
    params: Vec<Value>,
}

impl<'q> Query<'q> {
    /// Create a new query with the given SQL.
    pub fn new(sql: &'q str) -> Self {
        Self {
            sql,
            params: Vec::new(),
        }
    }

    /// Bind a single value to the query.
    ///
    /// Values are bound in order, replacing `?` placeholders.
    pub fn bind<T: ToValue>(mut self, value: T) -> Self {
        self.params.push(value.to_value());
        self
    }

    /// Bind multiple values to the query.
    ///
    /// This is useful for IN clauses or batch operations.
    pub fn bind_all<T: ToValue>(mut self, values: &[T]) -> Self {
        for value in values {
            self.params.push(value.to_value());
        }
        self
    }

    /// Get the SQL string.
    pub fn sql(&self) -> &str {
        self.sql
    }

    /// Get the bound parameters.
    pub fn params(&self) -> &[Value] {
        &self.params
    }

    /// Take ownership of the parameters.
    pub fn into_params(self) -> Vec<Value> {
        self.params
    }

    /// Execute the query and return the result.
    pub async fn execute<P: Pool>(self, pool: &P) -> Result<ExecuteResult> {
        pool.execute(self.sql, self.params).await
    }

    /// Fetch all matching rows.
    pub async fn fetch_all<T: FromRow + Send, P: Pool>(self, pool: &P) -> Result<Vec<T>> {
        pool.fetch_all(self.sql, self.params).await
    }

    /// Fetch a single optional row.
    pub async fn fetch_optional<T: FromRow + Send, P: Pool>(self, pool: &P) -> Result<Option<T>> {
        pool.fetch_optional(self.sql, self.params).await
    }

    /// Fetch exactly one row.
    pub async fn fetch_one<T: FromRow + Send, P: Pool>(self, pool: &P) -> Result<T> {
        pool.fetch_one(self.sql, self.params).await
    }

    /// Fetch a scalar value (first column of first row).
    pub async fn fetch_scalar<T: crate::FromValue + Send, P: Pool>(self, pool: &P) -> Result<T> {
        pool.fetch_scalar(self.sql, self.params).await
    }
}

/// A dynamic query builder for queries with variable SQL.
///
/// Use this when you need to build SQL dynamically at runtime.
#[derive(Debug, Clone)]
pub struct DynamicQuery {
    sql: String,
    params: Vec<Value>,
}

impl DynamicQuery {
    /// Create a new dynamic query with the given SQL.
    pub fn new(sql: impl Into<String>) -> Self {
        Self {
            sql: sql.into(),
            params: Vec::new(),
        }
    }

    /// Bind a single value to the query.
    pub fn bind<T: ToValue>(mut self, value: T) -> Self {
        self.params.push(value.to_value());
        self
    }

    /// Bind multiple values to the query.
    pub fn bind_all<T: ToValue>(mut self, values: &[T]) -> Self {
        for value in values {
            self.params.push(value.to_value());
        }
        self
    }

    /// Get the SQL string.
    pub fn sql(&self) -> &str {
        &self.sql
    }

    /// Get the bound parameters.
    pub fn params(&self) -> &[Value] {
        &self.params
    }

    /// Execute the query and return the result.
    pub async fn execute<P: Pool>(self, pool: &P) -> Result<ExecuteResult> {
        pool.execute(&self.sql, self.params).await
    }

    /// Fetch all matching rows.
    pub async fn fetch_all<T: FromRow + Send, P: Pool>(self, pool: &P) -> Result<Vec<T>> {
        pool.fetch_all(&self.sql, self.params).await
    }

    /// Fetch a single optional row.
    pub async fn fetch_optional<T: FromRow + Send, P: Pool>(self, pool: &P) -> Result<Option<T>> {
        pool.fetch_optional(&self.sql, self.params).await
    }

    /// Fetch exactly one row.
    pub async fn fetch_one<T: FromRow + Send, P: Pool>(self, pool: &P) -> Result<T> {
        pool.fetch_one(&self.sql, self.params).await
    }

    /// Fetch a scalar value (first column of first row).
    pub async fn fetch_scalar<T: crate::FromValue + Send, P: Pool>(self, pool: &P) -> Result<T> {
        pool.fetch_scalar(&self.sql, self.params).await
    }
}