Added row_factory method for query results

Signed-off-by: chandr-andr (Kiselev Aleksandr) <chandr@chandr.net>

Author: chandr-andr

python/psqlpy/_internal/__init__.pyi

@@ -8,6 +8,9 @@ from typing_extensions import Self
 _CustomClass = TypeVar(
     "_CustomClass",
 )
+_RowFactoryRV = TypeVar(
+    "_RowFactoryRV",
+)
 
 class QueryResult:
     """Result."""
@@ -16,7 +19,11 @@ class QueryResult:
         self: Self,
         custom_decoders: dict[str, Callable[[bytes], Any]] | None = None,
     ) -> list[dict[Any, Any]]:
-        """Return result from database as a list of dicts."""
+        """Return result from database as a list of dicts.
+
+        `custom_decoders` must be used when you use
+        PostgreSQL Type which isn't supported, read more in our docs.
+        """
     def as_class(
         self: Self,
         as_class: Callable[..., _CustomClass],
@@ -52,12 +59,39 @@ class QueryResult:
             )
         ```
         """
+    def row_factory(
+        self,
+        row_factory: Callable[[dict[str, Any]], _RowFactoryRV],
+        custom_decoders: dict[str, Callable[[bytes], Any]] | None = None,
+    ) -> list[_RowFactoryRV]:
+        """Use custom function to convert results from database.
+
+        `custom_decoders` must be used when you use
+        PostgreSQL Type isn't supported, read more in the docs.
+
+        Argument order: firstly we apply `custom_decoders` (if specified),
+        then we apply `row_factory`.
+
+        ### Parameters:
+        - `row_factory`: function which takes `dict[str, Any]` as an argument.
+        - `custom_decoders`: functions for custom decoding.
+
+        ### Returns:
+        List of type that return passed `row_factory`.
+        """
 
 class SingleQueryResult:
     """Single result."""
 
-    def result(self: Self) -> dict[Any, Any]:
-        """Return result from database as a dict."""
+    def result(
+        self: Self,
+        custom_decoders: dict[str, Callable[[bytes], Any]] | None = None,
+    ) -> dict[Any, Any]:
+        """Return result from database as a dict.
+
+        `custom_decoders` must be used when you use
+        PostgreSQL Type which isn't supported, read more in our docs.
+        """
     def as_class(
         self: Self,
         as_class: Callable[..., _CustomClass],
@@ -96,6 +130,26 @@ class SingleQueryResult:
             )
         ```
         """
+    def row_factory(
+        self,
+        row_factory: Callable[[dict[str, Any]], _RowFactoryRV],
+        custom_decoders: dict[str, Callable[[bytes], Any]] | None = None,
+    ) -> _RowFactoryRV:
+        """Use custom function to convert results from database.
+
+        `custom_decoders` must be used when you use
+        PostgreSQL Type isn't supported, read more in our docs.
+
+        Argument order: firstly we apply `custom_decoders` (if specified),
+        then we apply `row_factory`.
+
+        ### Parameters:
+        - `row_factory`: function which takes `list[dict[str, Any]]` as an argument.
+        - `custom_decoders`: functions for custom decoding.
+
+        ### Returns:
+        Type that return passed function.
+        """
 
 class IsolationLevel(Enum):
     """Class for Isolation Level for transactions."""

src/query_result.rs

@@ -89,6 +89,28 @@ impl PSQLDriverPyQueryResult {
 
         Ok(res.to_object(py))
     }
+
+    /// Convert result from database with function passed from Python.
+    ///
+    /// # Errors
+    ///
+    /// May return Err Result if can not convert
+    /// postgres type with custom function.
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn row_factory<'a>(
+        &'a self,
+        py: Python<'a>,
+        row_factory: Py<PyAny>,
+        custom_decoders: Option<Py<PyDict>>,
+    ) -> RustPSQLDriverPyResult<Py<PyAny>> {
+        let mut res: Vec<Py<PyAny>> = vec![];
+        for row in &self.inner {
+            let pydict: pyo3::Bound<'_, PyDict> = row_to_dict(py, row, &custom_decoders)?;
+            let row_factory_class = row_factory.call_bound(py, (pydict,), None)?;
+            res.push(row_factory_class);
+        }
+        Ok(res.to_object(py))
+    }
 }
 
 #[pyclass(name = "SingleQueryResult")]
@@ -121,8 +143,13 @@ impl PSQLDriverSinglePyQueryResult {
     /// May return Err Result if can not convert
     /// postgres type to python, can not set new key-value pair
     /// in python dict or there are no result.
-    pub fn result(&self, py: Python<'_>) -> RustPSQLDriverPyResult<Py<PyAny>> {
-        Ok(row_to_dict(py, &self.inner, &None)?.to_object(py))
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn result(
+        &self,
+        py: Python<'_>,
+        custom_decoders: Option<Py<PyDict>>,
+    ) -> RustPSQLDriverPyResult<Py<PyAny>> {
+        Ok(row_to_dict(py, &self.inner, &custom_decoders)?.to_object(py))
     }
 
     /// Convert result from database to any class passed from Python.
@@ -141,4 +168,21 @@ impl PSQLDriverSinglePyQueryResult {
         let pydict: pyo3::Bound<'_, PyDict> = row_to_dict(py, &self.inner, &None)?;
         Ok(as_class.call_bound(py, (), Some(&pydict))?)
     }
+
+    /// Convert result from database with function passed from Python.
+    ///
+    /// # Errors
+    ///
+    /// May return Err Result if can not convert
+    /// postgres type with custom function
+    #[allow(clippy::needless_pass_by_value)]
+    pub fn row_factory<'a>(
+        &'a self,
+        py: Python<'a>,
+        row_factory: Py<PyAny>,
+        custom_decoders: Option<Py<PyDict>>,
+    ) -> RustPSQLDriverPyResult<Py<PyAny>> {
+        let pydict = row_to_dict(py, &self.inner, &custom_decoders)?.to_object(py);
+        Ok(row_factory.call_bound(py, (pydict,), None)?)
+    }
 }

src/value_converter.rs

@@ -325,7 +325,6 @@ pub fn convert_parameters(parameters: Py<PyAny>) -> RustPSQLDriverPyResult<Vec<P
 /// or value of the type is incorrect.
 #[allow(clippy::too_many_lines)]
 pub fn py_to_rust(parameter: &pyo3::Bound<'_, PyAny>) -> RustPSQLDriverPyResult<PythonDTO> {
-    println!("{}", parameter.get_type().name()?);
     if parameter.is_none() {
         return Ok(PythonDTO::PyNone);
     }
@@ -490,7 +489,6 @@ pub fn py_to_rust(parameter: &pyo3::Bound<'_, PyAny>) -> RustPSQLDriverPyResult<
     }
 
     if parameter.get_type().name()? == "decimal.Decimal" {
-        println!("{}", parameter.str()?.extract::<&str>()?);
         return Ok(PythonDTO::PyDecimal(Decimal::from_str_exact(
             parameter.str()?.extract::<&str>()?,
         )?));