sql_middleware/sqlite/typed/
select.rs

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