sql_middleware/typed/any/
ops.rs

1use crate::SqlMiddlewareDbError;
2use crate::typed::traits::{BeginTx, TxConn, TypedConnOps};
3use crate::{middleware::RowValues, results::ResultSet};
4
5use super::{AnyIdle, AnyTx};
6
7impl TypedConnOps for AnyIdle {
8    #[allow(clippy::manual_async_fn)]
9    fn execute_batch(
10        &mut self,
11        sql: &str,
12    ) -> impl std::future::Future<Output = Result<(), SqlMiddlewareDbError>> {
13        async move {
14            match self {
15                #[cfg(feature = "postgres")]
16                AnyIdle::Postgres(conn) => conn.execute_batch(sql).await,
17                #[cfg(feature = "sqlite")]
18                AnyIdle::Sqlite(conn) => conn.execute_batch(sql).await,
19                #[cfg(feature = "mssql")]
20                AnyIdle::Mssql(conn) => conn.execute_batch(sql).await,
21                #[cfg(feature = "turso")]
22                AnyIdle::Turso(conn) => conn.execute_batch(sql).await,
23                #[allow(unreachable_patterns)]
24                _ => unreachable!("typed backends are not enabled"),
25            }
26        }
27    }
28
29    #[allow(clippy::manual_async_fn)]
30    fn dml(
31        &mut self,
32        query: &str,
33        params: &[RowValues],
34    ) -> impl std::future::Future<Output = Result<usize, SqlMiddlewareDbError>> {
35        async move {
36            match self {
37                #[cfg(feature = "postgres")]
38                AnyIdle::Postgres(conn) => conn.dml(query, params).await,
39                #[cfg(feature = "sqlite")]
40                AnyIdle::Sqlite(conn) => conn.dml(query, params).await,
41                #[cfg(feature = "mssql")]
42                AnyIdle::Mssql(conn) => conn.dml(query, params).await,
43                #[cfg(feature = "turso")]
44                AnyIdle::Turso(conn) => conn.dml(query, params).await,
45                #[allow(unreachable_patterns)]
46                _ => unreachable!("typed backends are not enabled"),
47            }
48        }
49    }
50
51    #[allow(clippy::manual_async_fn)]
52    fn select(
53        &mut self,
54        query: &str,
55        params: &[RowValues],
56    ) -> impl std::future::Future<Output = Result<ResultSet, SqlMiddlewareDbError>> {
57        async move {
58            match self {
59                #[cfg(feature = "postgres")]
60                AnyIdle::Postgres(conn) => conn.select(query, params).await,
61                #[cfg(feature = "sqlite")]
62                AnyIdle::Sqlite(conn) => conn.select(query, params).await,
63                #[cfg(feature = "mssql")]
64                AnyIdle::Mssql(conn) => conn.select(query, params).await,
65                #[cfg(feature = "turso")]
66                AnyIdle::Turso(conn) => conn.select(query, params).await,
67                #[allow(unreachable_patterns)]
68                _ => unreachable!("typed backends are not enabled"),
69            }
70        }
71    }
72}
73
74impl TypedConnOps for AnyTx {
75    #[allow(clippy::manual_async_fn)]
76    fn execute_batch(
77        &mut self,
78        sql: &str,
79    ) -> impl std::future::Future<Output = Result<(), SqlMiddlewareDbError>> {
80        async move {
81            match self {
82                #[cfg(feature = "postgres")]
83                AnyTx::Postgres(conn) => conn.execute_batch(sql).await,
84                #[cfg(feature = "sqlite")]
85                AnyTx::Sqlite(conn) => conn.execute_batch(sql).await,
86                #[cfg(feature = "mssql")]
87                AnyTx::Mssql(conn) => conn.execute_batch(sql).await,
88                #[cfg(feature = "turso")]
89                AnyTx::Turso(conn) => conn.execute_batch(sql).await,
90                #[allow(unreachable_patterns)]
91                _ => unreachable!("typed backends are not enabled"),
92            }
93        }
94    }
95
96    #[allow(clippy::manual_async_fn)]
97    fn dml(
98        &mut self,
99        query: &str,
100        params: &[RowValues],
101    ) -> impl std::future::Future<Output = Result<usize, SqlMiddlewareDbError>> {
102        async move {
103            match self {
104                #[cfg(feature = "postgres")]
105                AnyTx::Postgres(conn) => conn.dml(query, params).await,
106                #[cfg(feature = "sqlite")]
107                AnyTx::Sqlite(conn) => conn.dml(query, params).await,
108                #[cfg(feature = "mssql")]
109                AnyTx::Mssql(conn) => conn.dml(query, params).await,
110                #[cfg(feature = "turso")]
111                AnyTx::Turso(conn) => conn.dml(query, params).await,
112                #[allow(unreachable_patterns)]
113                _ => unreachable!("typed backends are not enabled"),
114            }
115        }
116    }
117
118    #[allow(clippy::manual_async_fn)]
119    fn select(
120        &mut self,
121        query: &str,
122        params: &[RowValues],
123    ) -> impl std::future::Future<Output = Result<ResultSet, SqlMiddlewareDbError>> {
124        async move {
125            match self {
126                #[cfg(feature = "postgres")]
127                AnyTx::Postgres(conn) => conn.select(query, params).await,
128                #[cfg(feature = "sqlite")]
129                AnyTx::Sqlite(conn) => conn.select(query, params).await,
130                #[cfg(feature = "mssql")]
131                AnyTx::Mssql(conn) => conn.select(query, params).await,
132                #[cfg(feature = "turso")]
133                AnyTx::Turso(conn) => conn.select(query, params).await,
134                #[allow(unreachable_patterns)]
135                _ => unreachable!("typed backends are not enabled"),
136            }
137        }
138    }
139}
140
141impl BeginTx for AnyIdle {
142    type Tx = AnyTx;
143
144    #[allow(clippy::manual_async_fn)]
145    fn begin(self) -> impl std::future::Future<Output = Result<Self::Tx, SqlMiddlewareDbError>> {
146        async move {
147            match self {
148                #[cfg(feature = "postgres")]
149                AnyIdle::Postgres(conn) => Ok(AnyTx::Postgres(conn.begin().await?)),
150                #[cfg(feature = "sqlite")]
151                AnyIdle::Sqlite(conn) => Ok(AnyTx::Sqlite(conn.begin().await?)),
152                #[cfg(feature = "mssql")]
153                AnyIdle::Mssql(conn) => Ok(AnyTx::Mssql(conn.begin().await?)),
154                #[cfg(feature = "turso")]
155                AnyIdle::Turso(conn) => Ok(AnyTx::Turso(conn.begin().await?)),
156                #[allow(unreachable_patterns)]
157                _ => unreachable!("typed backends are not enabled"),
158            }
159        }
160    }
161}
162
163impl TxConn for AnyTx {
164    type Idle = AnyIdle;
165
166    #[allow(clippy::manual_async_fn)]
167    fn commit(self) -> impl std::future::Future<Output = Result<Self::Idle, SqlMiddlewareDbError>> {
168        async move {
169            match self {
170                #[cfg(feature = "postgres")]
171                AnyTx::Postgres(tx) => Ok(AnyIdle::Postgres(tx.commit().await?)),
172                #[cfg(feature = "sqlite")]
173                AnyTx::Sqlite(tx) => Ok(AnyIdle::Sqlite(tx.commit().await?)),
174                #[cfg(feature = "mssql")]
175                AnyTx::Mssql(tx) => Ok(AnyIdle::Mssql(tx.commit().await?)),
176                #[cfg(feature = "turso")]
177                AnyTx::Turso(tx) => Ok(AnyIdle::Turso(tx.commit().await?)),
178                #[allow(unreachable_patterns)]
179                _ => unreachable!("typed backends are not enabled"),
180            }
181        }
182    }
183
184    /// Rollback and return to idle.
185    #[allow(clippy::manual_async_fn)]
186    fn rollback(
187        self,
188    ) -> impl std::future::Future<Output = Result<Self::Idle, SqlMiddlewareDbError>> {
189        async move {
190            match self {
191                #[cfg(feature = "postgres")]
192                AnyTx::Postgres(tx) => Ok(AnyIdle::Postgres(tx.rollback().await?)),
193                #[cfg(feature = "sqlite")]
194                AnyTx::Sqlite(tx) => Ok(AnyIdle::Sqlite(tx.rollback().await?)),
195                #[cfg(feature = "mssql")]
196                AnyTx::Mssql(tx) => Ok(AnyIdle::Mssql(tx.rollback().await?)),
197                #[cfg(feature = "turso")]
198                AnyTx::Turso(tx) => Ok(AnyIdle::Turso(tx.rollback().await?)),
199                #[allow(unreachable_patterns)]
200                _ => unreachable!("typed backends are not enabled"),
201            }
202        }
203    }
204}
sql_middleware/typed/any/ops.rs

sql_middleware/typed/any/
ops.rs
