Implemented fetch_row for transaction

Author: insani7y

python/psqlpy/_internal/__init__.pyi

@@ -10,6 +10,12 @@ class QueryResult:
     def result(self: Self) -> list[dict[Any, Any]]:
         """Return result from database as a list of dicts."""
 
+class SingleQueryResult:
+    """Single result."""
+
+    def result(self: Self) -> dict[Any, Any]:
+        """Return result from database as a dict."""
+
 class IsolationLevel(Enum):
     """Class for Isolation Level for transactions."""
 
@@ -320,6 +326,57 @@ class Transaction:
             # This way transaction begins and commits by itself.
         ```
         """
+    async def fetch_row(
+        self: Self,
+        querystring: str,
+        parameters: list[Any] | None = None,
+    ) -> SingleQueryResult:
+        """Execute the query and return first row.
+
+        Querystring can contain `$<number>` parameters
+        for converting them in the driver side.
+
+        ### Parameters:
+        - `querystring`: querystring to execute.
+        - `parameters`: list of parameters to pass in the query.
+
+        ### Example:
+        ```python
+        import asyncio
+
+        from psqlpy import PSQLPool, QueryResult
+
+
+        async def main() -> None:
+            db_pool = PSQLPool()
+            await db_pool.startup()
+
+            transaction = await db_pool.transaction()
+            await transaction.begin()
+            query_result: SingleQueryResult = await transaction.execute(
+                "SELECT username FROM users WHERE id = $1",
+                [100],
+            )
+            dict_result: Dict[Any, Any] = query_result.result()
+            # You must call commit manually
+            await transaction.commit()
+
+        # Or you can transaction as a async context manager
+
+        async def main() -> None:
+            db_pool = PSQLPool()
+            await psqlpy.startup()
+
+            transaction = await db_pool.transaction()
+            async with transaction:
+                query_result: SingleQueryResult = await transaction.execute(
+                    "SELECT username FROM users WHERE id = $1",
+                    [100],
+                )
+                dict_result: Dict[Any, Any] = query_result.result()
+            # This way transaction begins and commits by itself.
+        ```
+        """
     async def savepoint(self: Self, savepoint_name: str) -> None:
         """Create new savepoint.
 

python/tests/test_transaction.py

@@ -234,3 +234,19 @@ async def test_transaction_execute_many(
                 table_name,
                 transaction,
             ) - number_database_records == len(insert_values)
+
+
+async def test_transaction_fetch_row(
+    psql_pool: PSQLPool,
+    table_name: str,
+) -> None:
+    connection = await psql_pool.connection()
+    async with connection.transaction() as transaction:
+        database_single_query_result: typing.Final = (
+            await transaction.fetch_row(
+                f"SELECT * FROM  {table_name}",
+                [],
+            )
+        )
+        result = database_single_query_result.result()
+        assert isinstance(result, dict)

src/driver/transaction.rs

@@ -1,24 +1,21 @@
-use deadpool_postgres::Object;
-use pyo3::{
-    pyclass, pymethods,
-    types::{PyList, PyString},
-    Py, PyAny, PyObject, PyRef, PyRefMut, Python,
+use super::{
+    cursor::Cursor,
+    transaction_options::{IsolationLevel, ReadVariant},
 };
-use std::{collections::HashSet, sync::Arc, vec};
-use tokio_postgres::types::ToSql;
-
 use crate::{
     common::rustengine_future,
     exceptions::rust_errors::{RustPSQLDriverError, RustPSQLDriverPyResult},
-    query_result::PSQLDriverPyQueryResult,
+    query_result::{PSQLDriverPyQueryResult, PSQLDriverSinglePyQueryResult},
     value_converter::{convert_parameters, PythonDTO},
 };
-
-use super::{
-    cursor::Cursor,
-    transaction_options::{IsolationLevel, ReadVariant},
+use deadpool_postgres::Object;
+use pyo3::{
+    pyclass, pymethods,
+    types::{PyList, PyString},
+    Py, PyAny, PyErr, PyObject, PyRef, PyRefMut, Python,
 };
-
+use std::{collections::HashSet, sync::Arc, vec};
+use tokio_postgres::types::ToSql;
 /// Transaction for internal use only.
 ///
 /// It is not exposed to python.
@@ -166,7 +163,56 @@ impl RustTransaction {
 
         Ok(())
     }
+    /// Fetch single row from query.
+    ///
+    /// Method doesn't acquire lock on any structure fields.
+    /// It prepares and caches querystring in the inner Object object.
+    ///
+    /// Then execute the query.
+    ///
+    /// # Errors
+    /// May return Err Result if:
+    /// 1) Transaction is not started
+    /// 2) Transaction is done already
+    /// 3) Can not create/retrieve prepared statement
+    /// 4) Can not execute statement
+    pub async fn inner_fetch_row(
+        &self,
+        querystring: String,
+        parameters: Vec<PythonDTO>,
+    ) -> RustPSQLDriverPyResult<PSQLDriverSinglePyQueryResult> {
+        let db_client_arc = self.db_client.clone();
+        let is_started_arc = self.is_started.clone();
+        let is_done_arc = self.is_done.clone();
 
+        let db_client_guard = db_client_arc.read().await;
+        let is_started_guard = is_started_arc.read().await;
+        let is_done_guard = is_done_arc.read().await;
+
+        if !*is_started_guard {
+            return Err(RustPSQLDriverError::DataBaseTransactionError(
+                "Transaction is not started, please call begin() on transaction".into(),
+            ));
+        }
+        if *is_done_guard {
+            return Err(RustPSQLDriverError::DataBaseTransactionError(
+                "Transaction is already committed or rolled back".into(),
+            ));
+        }
+
+        let mut vec_parameters: Vec<&(dyn ToSql + Sync)> = Vec::with_capacity(parameters.len());
+        for param in &parameters {
+            vec_parameters.push(param);
+        }
+
+        let statement = db_client_guard.prepare_cached(&querystring).await?;
+
+        let result = db_client_guard
+            .query(&statement, &vec_parameters.into_boxed_slice())
+            .await?;
+
+        Ok(PSQLDriverSinglePyQueryResult::new(result))
+    }
     /// Start transaction
     /// Set up isolation level if specified
     /// Set up deferable if specified
@@ -599,7 +645,8 @@ impl Transaction {
         let transaction_arc = slf.transaction.clone();
         let transaction_arc2 = slf.transaction.clone();
         let is_no_exc = exception.is_none();
-        let exc_message = format!("{exception}");
+        let py_err = PyErr::from_value(exception);
+
         rustengine_future(py, async move {
             let transaction_guard = transaction_arc.read().await;
             if is_no_exc {
@@ -609,7 +656,7 @@ impl Transaction {
                 })
             } else {
                 transaction_guard.inner_rollback().await?;
-                Err(RustPSQLDriverError::DataBaseTransactionError(exc_message))
+                Err(RustPSQLDriverError::PyError(py_err))
             }
         })
     }
@@ -673,6 +720,33 @@ impl Transaction {
                 .await
         })
     }
+    /// Execute querystring with parameters and return first row.
+    ///
+    /// It converts incoming parameters to rust readable,
+    /// executes query with them and returns first row of response.
+    ///
+    /// # Errors
+    ///
+    /// May return Err Result if:
+    /// 1) Cannot convert python parameters
+    /// 2) Cannot execute querystring.
+    pub fn fetch_row<'a>(
+        &'a self,
+        py: Python<'a>,
+        querystring: String,
+        parameters: Option<&'a PyList>,
+    ) -> RustPSQLDriverPyResult<&PyAny> {
+        let transaction_arc = self.transaction.clone();
+        let mut params: Vec<PythonDTO> = vec![];
+        if let Some(parameters) = parameters {
+            params = convert_parameters(parameters)?;
+        }
+
+        rustengine_future(py, async move {
+            let transaction_guard = transaction_arc.read().await;
+            transaction_guard.inner_fetch_row(querystring, params).await
+        })
+    }
 
     /// Start the transaction.
     ///

src/query_result.rs

@@ -43,3 +43,43 @@ impl PSQLDriverPyQueryResult {
         Ok(result.to_object(py))
     }
 }
+
+#[pyclass(name = "SingleQueryResult")]
+#[allow(clippy::module_name_repetitions)]
+pub struct PSQLDriverSinglePyQueryResult {
+    inner: Vec<Row>,
+}
+
+impl PSQLDriverSinglePyQueryResult {
+    #[must_use]
+    pub fn new(database_row: Vec<Row>) -> Self {
+        PSQLDriverSinglePyQueryResult {
+            inner: database_row,
+        }
+    }
+}
+
+#[pymethods]
+impl PSQLDriverSinglePyQueryResult {
+    /// Return result as a Python list of dicts.
+    ///
+    /// It's a common variant how to return a result for the future
+    /// processing.
+    ///
+    /// # Errors
+    ///
+    /// May return Err Result if can not convert
+    /// postgres type to python or set new key-value pair
+    /// in python dict.
+    pub fn result(&self, py: Python<'_>) -> RustPSQLDriverPyResult<Py<PyAny>> {
+        if let Some(row) = self.inner.first() {
+            let python_dict = PyDict::new(py);
+            for (column_idx, column) in row.columns().iter().enumerate() {
+                let python_type = postgres_to_py(py, row, column, column_idx)?;
+                python_dict.set_item(column.name().to_object(py), python_type)?;
+            }
+            return Ok(python_dict.to_object(py));
+        }
+        return Ok(PyDict::new(py).to_object(py));
+    }
+}