sql_middleware/query_builder/
select.rs

1use crate::error::SqlMiddlewareDbError;
2use crate::executor::{
3    QueryTarget, QueryTargetKind, execute_select_dispatch, execute_select_prepared_dispatch,
4};
5use crate::pool::MiddlewarePoolConnection;
6use crate::translation::PrepareMode;
7use crate::results::ResultSet;
8use crate::types::RowValues;
9
10#[cfg(feature = "postgres")]
11use crate::postgres::typed::PgManager;
12#[cfg(feature = "sqlite")]
13use crate::sqlite::config::SqliteManager;
14#[cfg(feature = "turso")]
15use crate::typed_turso::TursoManager;
16#[cfg(any(feature = "postgres", feature = "sqlite", feature = "turso"))]
17use bb8::PooledConnection;
18
19use super::{QueryBuilder, translate_query_for_target};
20
21impl QueryBuilder<'_, '_> {
22    /// Execute a SELECT and return the result set.
23    ///
24    /// # Errors
25    /// Returns an error if placeholder translation fails or the backend query execution fails.
26    pub async fn select(self) -> Result<ResultSet, SqlMiddlewareDbError> {
27        let translated = translate_query_for_target(
28            &self.target,
29            self.sql.as_ref(),
30            self.params.as_ref(),
31            self.options,
32        );
33        let use_prepare = matches!(self.options.prepare, PrepareMode::Prepared);
34
35        match self.target {
36            QueryTarget {
37                kind: QueryTargetKind::Connection(conn),
38                ..
39            } => {
40                select_on_connection(conn, translated.as_ref(), self.params.as_ref(), use_prepare)
41                    .await
42            }
43            #[cfg(feature = "sqlite")]
44            QueryTarget {
45                kind: QueryTargetKind::TypedSqlite { conn }
46                    | QueryTargetKind::TypedSqliteTx { conn },
47                ..
48            } => select_typed_sqlite(conn, translated.as_ref(), self.params.as_ref()).await,
49            #[cfg(feature = "postgres")]
50            QueryTarget {
51                kind: QueryTargetKind::TypedPostgres { conn }
52                    | QueryTargetKind::TypedPostgresTx { conn },
53                ..
54            } => select_typed_postgres(conn, translated.as_ref(), self.params.as_ref(), use_prepare)
55                .await,
56            #[cfg(feature = "turso")]
57            QueryTarget {
58                kind: QueryTargetKind::TypedTurso { conn }
59                    | QueryTargetKind::TypedTursoTx { conn },
60                ..
61            } => select_typed_turso(conn, translated.as_ref(), self.params.as_ref()).await,
62            #[cfg(feature = "postgres")]
63            QueryTarget {
64                kind: QueryTargetKind::PostgresTx(tx),
65                ..
66            } => {
67                if use_prepare {
68                    let prepared = tx.prepare(translated.as_ref()).await?;
69                    tx.query_prepared(&prepared, self.params.as_ref()).await
70                } else {
71                    tx.query(translated.as_ref(), self.params.as_ref()).await
72                }
73            }
74            #[cfg(feature = "mssql")]
75            QueryTarget {
76                kind: QueryTargetKind::MssqlTx(tx),
77                ..
78            } => {
79                if use_prepare {
80                    let prepared = tx.prepare(translated.as_ref())?;
81                    tx.query_prepared(&prepared, self.params.as_ref()).await
82                } else {
83                    tx.query(translated.as_ref(), self.params.as_ref()).await
84                }
85            }
86            #[cfg(feature = "turso")]
87            QueryTarget {
88                kind: QueryTargetKind::TursoTx(tx),
89                ..
90            } => {
91                if use_prepare {
92                    let mut prepared = tx.prepare(translated.as_ref()).await?;
93                    tx.query_prepared(&mut prepared, self.params.as_ref()).await
94                } else {
95                    tx.execute_select(translated.as_ref(), self.params.as_ref()).await
96                }
97            }
98        }
99    }
100}
101
102async fn select_on_connection(
103    conn: &mut MiddlewarePoolConnection,
104    query: &str,
105    params: &[RowValues],
106    use_prepare: bool,
107) -> Result<ResultSet, SqlMiddlewareDbError> {
108    if use_prepare {
109        execute_select_prepared_dispatch(conn, query, params).await
110    } else {
111        execute_select_dispatch(conn, query, params).await
112    }
113}
114
115#[cfg(feature = "sqlite")]
116async fn select_typed_sqlite(
117    conn: &mut PooledConnection<'static, SqliteManager>,
118    query: &str,
119    params: &[RowValues],
120) -> Result<ResultSet, SqlMiddlewareDbError> {
121    crate::sqlite::connection::select(conn, query, params).await
122}
123
124#[cfg(feature = "postgres")]
125async fn select_typed_postgres(
126    conn: &mut PooledConnection<'static, PgManager>,
127    query: &str,
128    params: &[RowValues],
129    use_prepare: bool,
130) -> Result<ResultSet, SqlMiddlewareDbError> {
131    if use_prepare {
132        crate::typed_postgres::select_prepared(conn, query, params).await
133    } else {
134        crate::typed_postgres::select(conn, query, params).await
135    }
136}
137
138#[cfg(feature = "turso")]
139async fn select_typed_turso(
140    conn: &mut PooledConnection<'static, TursoManager>,
141    query: &str,
142    params: &[RowValues],
143) -> Result<ResultSet, SqlMiddlewareDbError> {
144    crate::typed_turso::select(conn, query, params).await
145}
sql_middleware/query_builder/select.rs

sql_middleware/query_builder/
select.rs
