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

sql_middleware/typed/any/
ops.rs
