First variant for decoders

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

Author: chandr-andr

python/psqlpy/_internal/__init__.pyi

@@ -11,7 +11,10 @@ _CustomClass = TypeVar(
 class QueryResult:
     """Result."""
 
-    def result(self: Self) -> list[dict[Any, Any]]:
+    def result(
+        self: Self,
+        custom_decoders: dict[str, Callable[[list[int]], Any]] | None = None,
+    ) -> list[dict[Any, Any]]:
         """Return result from database as a list of dicts."""
     def as_class(
         self: Self,

src/driver/connection.rs

@@ -257,7 +257,7 @@ impl Connection {
         };
 
         Python::with_gil(|gil| match result.columns().first() {
-            Some(first_column) => postgres_to_py(gil, &result, first_column, 0),
+            Some(first_column) => postgres_to_py(gil, &result, first_column, 0, &None),
             None => Ok(gil.None()),
         })
     }

src/driver/transaction.rs

@@ -331,7 +331,7 @@ impl Transaction {
         };
 
         Python::with_gil(|gil| match result.columns().first() {
-            Some(first_column) => postgres_to_py(gil, &result, first_column, 0),
+            Some(first_column) => postgres_to_py(gil, &result, first_column, 0, &None),
             None => Ok(gil.None()),
         })
     }

src/query_result.rs

@@ -13,10 +13,11 @@ use crate::{exceptions::rust_errors::RustPSQLDriverPyResult, value_converter::po
 fn row_to_dict<'a>(
     py: Python<'a>,
     postgres_row: &'a Row,
+    custom_decoders: &Option<Py<PyDict>>,
 ) -> RustPSQLDriverPyResult<pyo3::Bound<'a, PyDict>> {
     let python_dict = PyDict::new_bound(py);
     for (column_idx, column) in postgres_row.columns().iter().enumerate() {
-        let python_type = postgres_to_py(py, postgres_row, column, column_idx)?;
+        let python_type = postgres_to_py(py, postgres_row, column, column_idx, custom_decoders)?;
         python_dict.set_item(column.name().to_object(py), python_type)?;
     }
     Ok(python_dict)
@@ -55,10 +56,14 @@ impl PSQLDriverPyQueryResult {
     /// postgres type to python or set new key-value pair
     /// in python dict.
     #[allow(clippy::needless_pass_by_value)]
-    pub fn result(&self, py: Python<'_>) -> RustPSQLDriverPyResult<Py<PyAny>> {
+    pub fn result(
+        &self,
+        py: Python<'_>,
+        custom_decoders: Option<Py<PyDict>>,
+    ) -> RustPSQLDriverPyResult<Py<PyAny>> {
         let mut result: Vec<pyo3::Bound<'_, PyDict>> = vec![];
         for row in &self.inner {
-            result.push(row_to_dict(py, row)?);
+            result.push(row_to_dict(py, row, &custom_decoders)?);
         }
         Ok(result.to_object(py))
     }
@@ -77,7 +82,7 @@ impl PSQLDriverPyQueryResult {
     ) -> 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)?;
+            let pydict: pyo3::Bound<'_, PyDict> = row_to_dict(py, row, &None)?;
             let convert_class_inst = as_class.call_bound(py, (), Some(&pydict))?;
             res.push(convert_class_inst);
         }
@@ -117,7 +122,7 @@ impl PSQLDriverSinglePyQueryResult {
     /// 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)?.to_object(py))
+        Ok(row_to_dict(py, &self.inner, &None)?.to_object(py))
     }
 
     /// Convert result from database to any class passed from Python.
@@ -133,7 +138,7 @@ impl PSQLDriverSinglePyQueryResult {
         py: Python<'a>,
         as_class: Py<PyAny>,
     ) -> RustPSQLDriverPyResult<Py<PyAny>> {
-        let pydict: pyo3::Bound<'_, PyDict> = row_to_dict(py, &self.inner)?;
+        let pydict: pyo3::Bound<'_, PyDict> = row_to_dict(py, &self.inner, &None)?;
         Ok(as_class.call_bound(py, (), Some(&pydict))?)
     }
 }

src/value_converter.rs

@@ -652,10 +652,9 @@ fn postgres_bytes_to_py(
                 None => Ok(py.None().to_object(py)),
             }
         }
-        _ => Ok(
-            _composite_field_postgres_to_py::<Option<Vec<u8>>>(type_, buf, is_simple)?
-                .to_object(py),
-        ),
+        _ => Err(RustPSQLDriverError::RustToPyValueConversionError(
+            format!("Cannot convert {type_} into Python type, please look at the custom_decoders functionality.")
+        )),
     }
 }
 
@@ -720,9 +719,21 @@ pub fn postgres_to_py(
     row: &Row,
     column: &Column,
     column_i: usize,
+    custom_decoders: &Option<Py<PyDict>>,
 ) -> RustPSQLDriverPyResult<Py<PyAny>> {
-    let column_type = column.type_();
     let raw_bytes_data = row.col_buffer(column_i);
+
+    if let Some(custom_decoders) = custom_decoders {
+        let py_encoder_func = custom_decoders
+            .bind(py)
+            .get_item(column.name().to_lowercase());
+
+        if let Ok(Some(py_encoder_func)) = py_encoder_func {
+            return Ok(py_encoder_func.call((raw_bytes_data,), None)?.unbind());
+        }
+    }
+
+    let column_type = column.type_();
     match raw_bytes_data {
         Some(mut raw_bytes_data) => match column_type.kind() {
             Kind::Simple | Kind::Array(_) => {