Skip to main content

sql_middleware/sqlite/typed/
select.rs

1use std::sync::Arc;
2
3use crate::adapters::params::convert_params;
4use crate::executor::QueryTarget;
5use crate::middleware::{ConversionMode, RowValues, SqlMiddlewareDbError};
6use crate::query_builder::QueryBuilder;
7use crate::results::ResultSet;
8
9use crate::sqlite::config::SqliteManager;
10use crate::sqlite::params::Params;
11use crate::sqlite::query;
12
13use super::SqliteTypedConnection;
14
15impl SqliteTypedConnection<super::core::Idle> {
16    /// Auto-commit SELECT.
17    ///
18    /// # Errors
19    /// Returns `SqlMiddlewareDbError` if executing the select fails.
20    pub async fn select(
21        &mut self,
22        query: &str,
23        params: &[RowValues],
24    ) -> Result<ResultSet, SqlMiddlewareDbError> {
25        let mut tx = super::core::begin_from_conn(self.take_conn()?).await?;
26        let rows = tx.select(query, params).await?;
27        let mut idle = tx.commit().await?;
28        self.conn = idle.conn.take();
29        Ok(rows)
30    }
31
32    /// Start a query builder (auto-commit per operation).
33    pub fn query<'a>(&'a mut self, sql: &'a str) -> QueryBuilder<'a, 'a> {
34        QueryBuilder::new_target(QueryTarget::from_typed_sqlite(self.conn_mut(), false), sql)
35    }
36}
37
38impl SqliteTypedConnection<super::core::InTx> {
39    /// Execute SELECT inside the open transaction.
40    ///
41    /// # Errors
42    /// Returns `SqlMiddlewareDbError` if executing the select fails.
43    pub async fn select(
44        &mut self,
45        query: &str,
46        params: &[RowValues],
47    ) -> Result<ResultSet, SqlMiddlewareDbError> {
48        let converted = convert_params::<Params>(params, ConversionMode::Query)?.0;
49        let sql_owned = query.to_owned();
50        super::core::run_blocking(self.conn_handle()?, move |guard| {
51            let mut stmt = guard
52                .prepare(&sql_owned)
53                .map_err(SqlMiddlewareDbError::SqliteError)?;
54            query::build_result_set(&mut stmt, &converted)
55        })
56        .await
57    }
58
59    /// Start a query builder within the open transaction.
60    pub fn query<'a>(&'a mut self, sql: &'a str) -> QueryBuilder<'a, 'a> {
61        QueryBuilder::new_target(QueryTarget::from_typed_sqlite(self.conn_mut(), true), sql)
62    }
63}
64
65/// Adapter for query builder select (typed-sqlite target).
66///
67/// # Errors
68/// Returns `SqlMiddlewareDbError` if converting parameters or executing the query fails.
69pub async fn select(
70    conn: &mut bb8::PooledConnection<'_, SqliteManager>,
71    query: &str,
72    params: &[RowValues],
73) -> Result<ResultSet, SqlMiddlewareDbError> {
74    let converted = convert_params::<Params>(params, ConversionMode::Query)?.0;
75    let sql_owned = query.to_owned();
76    let handle = Arc::clone(&**conn);
77    super::core::run_blocking(handle, move |guard| {
78        let mut stmt = guard
79            .prepare(&sql_owned)
80            .map_err(SqlMiddlewareDbError::SqliteError)?;
81        query::build_result_set(&mut stmt, &converted)
82    })
83    .await
84}