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

sql_middleware/query_builder/
select.rs
