Continue implementing new realization. pre-commit disabled.

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

Author: chandr-andr

src/driver/connection_pool.rs

@@ -419,13 +419,10 @@ impl ConnectionPool {
     pub async fn execute<'a>(
         self_: pyo3::Py<Self>,
         querystring: String,
-        prepared: bool,
+        prepared: Option<bool>,
         parameters: Option<pyo3::Py<PyAny>>,
     ) -> RustPSQLDriverPyResult<PSQLDriverPyQueryResult> {
-        let db_pool = pyo3::Python::with_gil(|gil| {
-            let this = self_.borrow(gil);
-            this.db_pool.clone().unwrap()
-        });
+        let db_pool = pyo3::Python::with_gil(|gil| self_.borrow(gil).db_pool.clone().unwrap());
         let db_pool_manager = tokio()
             .spawn(async move { db_pool.get().await.unwrap() })
             .await
@@ -434,6 +431,7 @@ impl ConnectionPool {
         if let Some(parameters) = parameters {
             params = convert_parameters(parameters)?;
         }
+        let prepared = prepared.unwrap_or(true);
         let result = if prepared {
             tokio()
                 .spawn(async move {

src/extra_types.rs

@@ -1,7 +1,7 @@
 use std::str::FromStr;
 
 use macaddr::{MacAddr6, MacAddr8};
-use pyo3::{pyclass, pymethods, types::PyModule, PyAny, PyResult, Python};
+use pyo3::{pyclass, pymethods, types::PyModule, Py, PyAny, PyResult, Python};
 use serde_json::Value;
 use uuid::Uuid;
 
@@ -88,7 +88,7 @@ impl PyJSON {
 impl PyJSON {
     #[new]
     #[allow(clippy::missing_errors_doc)]
-    pub fn new_json(value: &PyAny) -> RustPSQLDriverPyResult<Self> {
+    pub fn new_json(value: Py<PyAny>) -> RustPSQLDriverPyResult<Self> {
         Ok(Self {
             inner: build_serde_value(value)?,
         })
@@ -126,50 +126,6 @@ macro_rules! build_macaddr_type {
 build_macaddr_type!(PyMacAddr6, MacAddr6);
 build_macaddr_type!(PyMacAddr8, MacAddr8);
 
-// #[pyclass]
-// #[derive(Clone)]
-// pub struct PyMacAddr6 {
-//     inner: MacAddr6,
-// }
-
-// impl PyMacAddr6 {
-//     #[must_use]
-//     pub fn inner(self) -> MacAddr6 {
-//         self.inner
-//     }
-// }
-
-// #[pymethods]
-// impl PyMacAddr6 {
-//     #[new]
-//     #[allow(clippy::missing_errors_doc)]
-//     pub fn new_macaddr6(value: &str) -> RustPSQLDriverPyResult<Self> {
-//         Ok(Self {
-//             inner: MacAddr6::from_str(value)?,
-//         })
-//     }
-// }
-
-// #[pyclass]
-// #[derive(Clone)]
-// pub struct PyMacAddr8 {
-//     inner: MacAddr8,
-// }
-
-// impl PyMacAddr8 {
-//     #[must_use]
-//     pub fn inner(self) -> MacAddr8 {
-//         self.inner
-//     }
-// }
-
-// #[pymethods]
-// impl PyMacAddr8 {
-//     #[new]
-//     #[allow(clippy::missing_errors_doc)]
-//     pub fn new_macaddr8(value: &str) -> RustPSQLDriverPyResult<Self> {}
-// }
-
 #[allow(clippy::module_name_repetitions)]
 #[allow(clippy::missing_errors_doc)]
 pub fn extra_types_module(_py: Python<'_>, pymod: &PyModule) -> PyResult<()> {

src/value_converter.rs

@@ -8,8 +8,8 @@ use bytes::{BufMut, BytesMut};
 use postgres_protocol::types;
 use pyo3::{
     types::{
-        PyAnyMethods, PyBool, PyBytes, PyDate, PyDateTime, PyDict, PyFloat, PyInt, PyList, PySet,
-        PyString, PyTime, PyTuple,
+        PyAnyMethods, PyBool, PyBytes, PyDate, PyDateTime, PyDict, PyDictMethods, PyFloat, PyInt,
+        PyList, PySet, PyString, PyTime, PyTuple,
     },
     Bound, Py, PyAny, Python, ToPyObject,
 };
@@ -336,9 +336,8 @@ pub fn py_to_rust(parameter: &pyo3::Bound<'_, PyAny>) -> RustPSQLDriverPyResult<
 
         let mut serde_map: Map<String, Value> = Map::new();
 
-        for dict_item in dict.iter().unwrap() {
-            let dict_elem = dict_item.unwrap();
-            let py_list = dict_elem.downcast::<PyTuple>().map_err(|error| {
+        for dict_item in dict.items() {
+            let py_list = dict_item.downcast::<PyTuple>().map_err(|error| {
                 RustPSQLDriverError::PyToRustValueConversionError(format!(
                     "Cannot cast to list: {error}"
                 ))
@@ -528,34 +527,37 @@ pub fn postgres_to_py(
 ///
 /// # Errors
 /// May return error if cannot convert Python type into Rust one.
-pub fn build_serde_value(value: &PyAny) -> RustPSQLDriverPyResult<Value> {
-    Ok(json!(123))
-    // if value.is_instance_of::<PyList>() {
-    //     let mut result_vec: Vec<Value> = vec![];
-
-    //     let params: Vec<&PyAny> = value.extract::<Vec<&PyAny>>()?;
-
-    //     for inner in &params {
-    //         if inner.is_instance_of::<PyDict>() {
-    //             let python_dto = py_to_rust(inner)?;
-    //             result_vec.push(python_dto.to_serde_value()?);
-    //         } else if inner.is_instance_of::<PyList>() {
-    //             let serde_value = build_serde_value(inner)?;
-    //             result_vec.push(serde_value);
-    //         } else {
-    //             return Err(RustPSQLDriverError::PyToRustValueConversionError(
-    //                 "PyJSON supports only list of lists or list of dicts.".to_string(),
-    //             ));
-    //         }
-    //     }
-    //     Ok(json!(result_vec))
-    // } else if value.is_instance_of::<PyDict>() {
-    //     return py_to_rust(value)?.to_serde_value();
-    // } else {
-    //     return Err(RustPSQLDriverError::PyToRustValueConversionError(
-    //         "PyJSON must be list value.".to_string(),
-    //     ));
-    // }
+pub fn build_serde_value(value: Py<PyAny>) -> RustPSQLDriverPyResult<Value> {
+    Python::with_gil(|gil| {
+        let bind_value = value.bind(gil);
+        if bind_value.is_instance_of::<PyList>() {
+            let mut result_vec: Vec<Value> = vec![];
+
+            let params = bind_value.extract::<Vec<Py<PyAny>>>()?;
+
+            for inner in params {
+                let inner_bind = inner.bind(gil);
+                if inner_bind.is_instance_of::<PyDict>() {
+                    let python_dto = py_to_rust(inner_bind)?;
+                    result_vec.push(python_dto.to_serde_value()?);
+                } else if inner_bind.is_instance_of::<PyList>() {
+                    let serde_value = build_serde_value(inner)?;
+                    result_vec.push(serde_value);
+                } else {
+                    return Err(RustPSQLDriverError::PyToRustValueConversionError(
+                        "PyJSON supports only list of lists or list of dicts.".to_string(),
+                    ));
+                }
+            }
+            Ok(json!(result_vec))
+        } else if bind_value.is_instance_of::<PyDict>() {
+            return py_to_rust(bind_value)?.to_serde_value();
+        } else {
+            return Err(RustPSQLDriverError::PyToRustValueConversionError(
+                "PyJSON must be list value.".to_string(),
+            ));
+        }
+    })
 }
 
 /// Convert serde `Value` into Python object.