Now transaction method isn't asynchronous

Author: chandr-andr

README.md

@@ -120,11 +120,7 @@ async def main() -> None:
     await db_pool.startup()
 
     connection = await db_pool.connection()
-    transaction = await connection.transaction(
-        isolation_level=IsolationLevel.Serializable,
-    )
-
-    async with transaction:
+    async with connection.transaction() as transaction:
         res: list[dict[str, Any]] = await transaction.execute(
             "SELECT * FROM users",
         )
@@ -147,7 +143,7 @@ async def main() -> None:
     await db_pool.startup()
 
     connection = await db_pool.connection()
-    transaction = await connection.transaction(
+    transaction = connection.transaction(
         isolation_level=IsolationLevel.Serializable,
     )
 
@@ -181,7 +177,7 @@ async def main() -> None:
     await db_pool.startup()
 
     connection = await db_pool.connection()
-    transaction = await connection.transaction(
+    transaction = connection.transaction(
         isolation_level=IsolationLevel.Serializable,
     )
 
@@ -208,7 +204,7 @@ async def main() -> None:
     await db_pool.startup()
 
     connection = await db_pool.connection()
-    transaction = await connection.transaction(
+    transaction = connection.transaction(
         isolation_level=IsolationLevel.Serializable,
     )
 
@@ -241,7 +237,7 @@ async def main() -> None:
     await db_pool.startup()
 
     connection = await db_pool.connection()
-    transaction = await connection.transaction(
+    transaction = connection.transaction(
         isolation_level=IsolationLevel.Serializable,
     )
 
@@ -278,7 +274,7 @@ async def main() -> None:
     await db_pool.startup()
 
     connection = await db_pool.connection()
-    transaction = await connection.transaction(
+    transaction = connection.transaction(
         isolation_level=IsolationLevel.Serializable,
     )
 

python/psqlpy/_internal/__init__.pyi

@@ -338,7 +338,7 @@ class Connection:
         ```
         """
 
-    async def transaction(
+    def transaction(
         self,
         isolation_level: IsolationLevel | None = None,
         read_variant: ReadVariant | None = None,

src/driver/connection.rs

@@ -15,47 +15,44 @@ use super::{
     transaction_options::{IsolationLevel, ReadVariant},
 };
 
-pub struct RustConnection {
+#[pyclass]
+pub struct Connection {
     pub db_client: Arc<tokio::sync::RwLock<Object>>,
 }
 
-impl RustConnection {
-    /// Execute querystring with parameters.
-    ///
-    /// Method doesn't acquire lock on database connection.
-    /// It prepares and caches querystring in the inner Object object.
-    ///
-    /// Then execute the query.
-    ///
-    /// # Errors:
-    /// May return Err Result if:
-    /// 1) Can not create/retrieve prepared statement
-    /// 2) Can not execute statement
-    pub async fn inner_execute<'a>(
+#[pymethods]
+impl Connection {
+    pub fn execute<'a>(
         &'a self,
+        py: Python<'a>,
         querystring: String,
-        parameters: Vec<PythonDTO>,
-    ) -> RustPSQLDriverPyResult<PSQLDriverPyQueryResult> {
+        parameters: Option<&'a PyAny>,
+    ) -> RustPSQLDriverPyResult<&PyAny> {
         let db_client_arc = self.db_client.clone();
 
-        let db_client_guard = db_client_arc.read().await;
-
-        let mut vec_parameters: Vec<&(dyn ToSql + Sync)> = Vec::with_capacity(parameters.len());
-        for param in parameters.iter() {
-            vec_parameters.push(param);
+        let mut params: Vec<PythonDTO> = vec![];
+        if let Some(parameters) = parameters {
+            params = convert_parameters(parameters)?
         }
 
-        let statement: tokio_postgres::Statement =
-            db_client_guard.prepare_cached(&querystring).await?;
-
-        let result = db_client_guard
-            .query(&statement, &vec_parameters.into_boxed_slice())
-            .await?;
-
-        Ok(PSQLDriverPyQueryResult::new(result))
+        rustengine_future(py, async move {
+            let mut vec_parameters: Vec<&(dyn ToSql + Sync)> = Vec::with_capacity(params.len());
+            for param in params.iter() {
+                vec_parameters.push(param);
+            }
+            let db_client_guard = db_client_arc.read().await;
+            let statement: tokio_postgres::Statement =
+                db_client_guard.prepare_cached(&querystring).await?;
+
+            let result = db_client_guard
+                .query(&statement, &vec_parameters.into_boxed_slice())
+                .await?;
+
+            Ok(PSQLDriverPyQueryResult::new(result))
+        })
     }
 
-    pub fn inner_transaction<'a>(
+    pub fn transaction<'a>(
         &'a self,
         isolation_level: Option<IsolationLevel>,
         read_variant: Option<ReadVariant>,
@@ -75,51 +72,3 @@ impl RustConnection {
         }
     }
 }
-
-#[pyclass]
-pub struct Connection(pub Arc<tokio::sync::RwLock<RustConnection>>);
-
-#[pymethods]
-impl Connection {
-    /// Execute querystring with parameters.
-    ///
-    /// It converts incoming parameters to rust readable
-    /// and then execute the query with them.
-    ///
-    /// # Errors:
-    ///
-    /// May return Err Result if:
-    /// 1) Cannot convert python parameters
-    /// 2) Cannot execute querystring.
-    pub fn execute<'a>(
-        &'a self,
-        py: Python<'a>,
-        querystring: String,
-        parameters: Option<&'a PyAny>,
-    ) -> RustPSQLDriverPyResult<&PyAny> {
-        let connection_arc = self.0.clone();
-        let mut params: Vec<PythonDTO> = vec![];
-        if let Some(parameters) = parameters {
-            params = convert_parameters(parameters)?
-        }
-
-        rustengine_future(py, async move {
-            let connection_guard = connection_arc.read().await;
-            Ok(connection_guard.inner_execute(querystring, params).await?)
-        })
-    }
-
-    pub fn transaction<'a>(
-        &'a self,
-        py: Python<'a>,
-        isolation_level: Option<IsolationLevel>,
-        read_variant: Option<ReadVariant>,
-    ) -> RustPSQLDriverPyResult<&PyAny> {
-        let connection_arc = self.0.clone();
-
-        rustengine_future(py, async move {
-            let connection_guard = connection_arc.read().await;
-            Ok(connection_guard.inner_transaction(isolation_level, read_variant))
-        })
-    }
-}

src/driver/connection_pool.rs

@@ -10,7 +10,7 @@ use crate::{
     value_converter::{convert_parameters, PythonDTO},
 };
 
-use super::connection::{Connection, RustConnection};
+use super::connection::Connection;
 
 /// PSQLPool for internal use only.
 ///
@@ -48,6 +48,10 @@ impl RustPSQLPool {
 }
 
 impl RustPSQLPool {
+    /// Return new single connection.
+    ///
+    /// # Errors:
+    /// May return Err Result if cannot get new connection from the pool.
     pub async fn inner_connection<'a>(&'a self) -> RustPSQLDriverPyResult<Connection> {
         let db_pool_arc = self.db_pool.clone();
 
@@ -61,13 +65,9 @@ impl RustPSQLPool {
             .get()
             .await?;
 
-        let inner_connection = RustConnection {
+        Ok(Connection {
             db_client: Arc::new(tokio::sync::RwLock::new(db_pool_manager)),
-        };
-
-        Ok(Connection(Arc::new(tokio::sync::RwLock::new(
-            inner_connection,
-        ))))
+        })
     }
     /// Execute querystring with parameters.
     ///

src/lib.rs

@@ -14,6 +14,7 @@ use pyo3::{pymodule, types::PyModule, PyResult, Python};
 #[pyo3(name = "_internal")]
 fn psqlpy(py: Python<'_>, pymod: &PyModule) -> PyResult<()> {
     pymod.add_class::<driver::connection_pool::PSQLPool>()?;
+    pymod.add_class::<driver::connection::Connection>()?;
     pymod.add_class::<driver::transaction::Transaction>()?;
     pymod.add_class::<driver::cursor::Cursor>()?;
     pymod.add_class::<driver::transaction_options::IsolationLevel>()?;