sql_middleware/pool/
interaction.rs

1use super::connection::MiddlewarePoolConnection;
2use crate::error::SqlMiddlewareDbError;
3use crate::query::AnyConnWrapper;
4
5impl MiddlewarePoolConnection {
6    /// Interact with the connection asynchronously
7    ///
8    /// # Errors
9    /// Returns `SqlMiddlewareDbError::Unimplemented` for unsupported database types.
10    #[allow(unused_variables)]
11    pub async fn interact_async<F, Fut>(
12        &mut self,
13        func: F,
14    ) -> Result<Fut::Output, SqlMiddlewareDbError>
15    where
16        F: FnOnce(AnyConnWrapper<'_>) -> Fut + Send + 'static,
17        Fut: std::future::Future<Output = Result<(), SqlMiddlewareDbError>> + Send + 'static,
18    {
19        match self {
20            #[cfg(feature = "postgres")]
21            MiddlewarePoolConnection::Postgres(pg_obj) => {
22                // Assuming PostgresObject dereferences to tokio_postgres::Client
23                let client: &mut tokio_postgres::Client = pg_obj.as_mut();
24                Ok(func(AnyConnWrapper::Postgres(client)).await)
25            }
26            #[cfg(feature = "mssql")]
27            MiddlewarePoolConnection::Mssql(mssql_obj) => {
28                // Get client from Object
29                let client = &mut **mssql_obj;
30                Ok(func(AnyConnWrapper::Mssql(client)).await)
31            }
32            #[cfg(feature = "libsql")]
33            MiddlewarePoolConnection::Libsql(libsql_obj) => {
34                Ok(func(AnyConnWrapper::Libsql(libsql_obj)).await)
35            }
36            #[cfg(feature = "sqlite")]
37            MiddlewarePoolConnection::Sqlite(_) => Err(SqlMiddlewareDbError::Unimplemented(
38                "interact_async is not supported for SQLite; use interact_sync instead".to_string(),
39            )),
40            #[allow(unreachable_patterns)]
41            _ => Err(SqlMiddlewareDbError::Unimplemented(
42                "interact_async is not implemented for this database type".to_string(),
43            )),
44        }
45    }
46
47    /// Interact with the connection synchronously
48    ///
49    /// # Errors
50    /// Returns `SqlMiddlewareDbError::Unimplemented` for unsupported database types.
51    #[allow(unused_variables)]
52    pub async fn interact_sync<F, R>(&self, f: F) -> Result<R, SqlMiddlewareDbError>
53    where
54        F: FnOnce(AnyConnWrapper) -> R + Send + 'static,
55        R: Send + 'static,
56    {
57        match self {
58            #[cfg(feature = "sqlite")]
59            MiddlewarePoolConnection::Sqlite(sqlite_conn) => {
60                sqlite_conn
61                    .with_connection(move |conn| {
62                        let wrapper = AnyConnWrapper::Sqlite(conn);
63                        Ok(f(wrapper))
64                    })
65                    .await
66            }
67            #[cfg(feature = "postgres")]
68            MiddlewarePoolConnection::Postgres(_) => Err(SqlMiddlewareDbError::Unimplemented(
69                "interact_sync is not supported for Postgres; use interact_async instead"
70                    .to_string(),
71            )),
72            #[cfg(feature = "mssql")]
73            MiddlewarePoolConnection::Mssql(_) => Err(SqlMiddlewareDbError::Unimplemented(
74                "interact_sync is not supported for SQL Server; use interact_async instead"
75                    .to_string(),
76            )),
77            #[allow(unreachable_patterns)]
78            _ => Err(SqlMiddlewareDbError::Unimplemented(
79                "interact_sync is not implemented for this database type".to_string(),
80            )),
81        }
82    }
83}
sql_middleware/pool/interaction.rs

sql_middleware/pool/
interaction.rs
