Added tests for NUMERIC and MONEY types

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

Author: chandr-andr

python/psqlpy/_internal/extra_types.pyi

@@ -32,6 +32,16 @@ class BigInt:
         - `inner_value`: int object.
         """
 
+class Money:
+    """Represent `MONEY` in PostgreSQL and `i64` in Rust."""
+
+    def __init__(self: Self, inner_value: int) -> None:
+        """Create new instance of class.
+
+        ### Parameters:
+        - `inner_value`: int object.
+        """
+
 class Float32:
     """Represents `FLOAT4` in `PostgreSQL` and `f32` in Rust."""
 

python/psqlpy/extra_types.py

@@ -3,6 +3,7 @@
     Float32,
     Float64,
     Integer,
+    Money,
     PyCustomType,
     PyJSON,
     PyJSONB,
@@ -26,4 +27,5 @@
     "PyCustomType",
     "Float32",
     "Float64",
+    "Money",
 ]

python/tests/test_value_converter.py

@@ -1,5 +1,6 @@
 import datetime
 import uuid
+from decimal import Decimal
 from enum import Enum
 from ipaddress import IPv4Address
 from typing import Any, Dict, List, Union
@@ -15,6 +16,7 @@
     Float32,
     Float64,
     Integer,
+    Money,
     PyJSON,
     PyJSONB,
     PyMacAddr6,
@@ -72,10 +74,18 @@ async def test_as_class(
         ("BYTEA", b"Bytes", [66, 121, 116, 101, 115]),
         ("VARCHAR", "Some String", "Some String"),
         ("TEXT", "Some String", "Some String"),
+        (
+            "XML",
+            """<?xml version="1.0"?><book><title>Manual</title><chapter>...</chapter></book>""",
+            """<book><title>Manual</title><chapter>...</chapter></book>""",
+        ),
         ("BOOL", True, True),
         ("INT2", SmallInt(12), 12),
         ("INT4", Integer(121231231), 121231231),
         ("INT8", BigInt(99999999999999999), 99999999999999999),
+        ("MONEY", BigInt(99999999999999999), 99999999999999999),
+        ("MONEY", Money(99999999999999999), 99999999999999999),
+        ("NUMERIC(5, 2)", Decimal("120.12"), Decimal("120.12")),
         ("FLOAT4", 32.12329864501953, 32.12329864501953),
         ("FLOAT4", Float32(32.12329864501953), 32.12329864501953),
         ("FLOAT8", Float64(32.12329864501953), 32.12329864501953),
@@ -145,6 +155,16 @@ async def test_as_class(
             [BigInt(99999999999999999), BigInt(99999999999999999)],
             [99999999999999999, 99999999999999999],
         ),
+        (
+            "MONEY ARRAY",
+            [Money(99999999999999999), Money(99999999999999999)],
+            [99999999999999999, 99999999999999999],
+        ),
+        (
+            "NUMERIC(5, 2) ARRAY",
+            [Decimal("121.23"), Decimal("188.99")],
+            [Decimal("121.23"), Decimal("188.99")],
+        ),
         (
             "FLOAT4 ARRAY",
             [32.12329864501953, 32.12329864501953],

src/exceptions/rust_errors.rs

@@ -75,6 +75,8 @@ pub enum RustPSQLDriverError {
     RustMacAddrConversionError(#[from] macaddr::ParseError),
     #[error("Cannot execute future in Rust: {0}")]
     RustRuntimeJoinError(#[from] JoinError),
+    #[error("Cannot convert python Decimal into rust Decimal")]
+    DecimalConversionError(#[from] rust_decimal::Error),
 }
 
 impl From<RustPSQLDriverError> for pyo3::PyErr {
@@ -92,7 +94,8 @@ impl From<RustPSQLDriverError> for pyo3::PyErr {
             RustPSQLDriverError::RustToPyValueConversionError(_) => {
                 RustToPyValueMappingError::new_err((error_desc,))
             }
-            RustPSQLDriverError::PyToRustValueConversionError(_) => {
+            RustPSQLDriverError::PyToRustValueConversionError(_)
+            | RustPSQLDriverError::DecimalConversionError(_) => {
                 PyToRustValueMappingError::new_err((error_desc,))
             }
             RustPSQLDriverError::ConnectionPoolConfigurationError(_) => {

src/extra_types.rs

@@ -44,6 +44,7 @@ macro_rules! build_python_type {
 build_python_type!(SmallInt, i16);
 build_python_type!(Integer, i32);
 build_python_type!(BigInt, i64);
+build_python_type!(Money, i64);
 build_python_type!(Float32, f32);
 build_python_type!(Float64, f64);
 
@@ -189,6 +190,7 @@ pub fn extra_types_module(_py: Python<'_>, pymod: &Bound<'_, PyModule>) -> PyRes
     pymod.add_class::<SmallInt>()?;
     pymod.add_class::<Integer>()?;
     pymod.add_class::<BigInt>()?;
+    pymod.add_class::<Money>()?;
     pymod.add_class::<Float32>()?;
     pymod.add_class::<Float64>()?;
     pymod.add_class::<PyText>()?;

src/value_converter.rs

@@ -25,8 +25,8 @@ use crate::{
     additional_types::{RustMacAddr6, RustMacAddr8},
     exceptions::rust_errors::{RustPSQLDriverError, RustPSQLDriverPyResult},
     extra_types::{
-        BigInt, Float32, Float64, Integer, PyCustomType, PyJSON, PyJSONB, PyMacAddr6, PyMacAddr8,
-        PyText, PyVarChar, SmallInt,
+        BigInt, Float32, Float64, Integer, Money, PyCustomType, PyJSON, PyJSONB, PyMacAddr6,
+        PyMacAddr8, PyText, PyVarChar, SmallInt,
     },
 };
 
@@ -83,6 +83,7 @@ pub enum PythonDTO {
     PyIntU64(u64),
     PyFloat32(f32),
     PyFloat64(f64),
+    PyMoney(i64),
     PyDate(NaiveDate),
     PyTime(NaiveTime),
     PyDateTime(NaiveDateTime),
@@ -122,6 +123,7 @@ impl PythonDTO {
             PythonDTO::PyIntI64(_) => Ok(tokio_postgres::types::Type::INT8_ARRAY),
             PythonDTO::PyFloat32(_) => Ok(tokio_postgres::types::Type::FLOAT4_ARRAY),
             PythonDTO::PyFloat64(_) => Ok(tokio_postgres::types::Type::FLOAT8_ARRAY),
+            PythonDTO::PyMoney(_) => Ok(tokio_postgres::types::Type::MONEY_ARRAY),
             PythonDTO::PyIpAddress(_) => Ok(tokio_postgres::types::Type::INET_ARRAY),
             PythonDTO::PyJsonb(_) => Ok(tokio_postgres::types::Type::JSONB_ARRAY),
             PythonDTO::PyJson(_) => Ok(tokio_postgres::types::Type::JSON_ARRAY),
@@ -231,7 +233,7 @@ impl ToSql for PythonDTO {
             }
             PythonDTO::PyIntI16(int) => out.put_i16(*int),
             PythonDTO::PyIntI32(int) => out.put_i32(*int),
-            PythonDTO::PyIntI64(int) => out.put_i64(*int),
+            PythonDTO::PyIntI64(int) | PythonDTO::PyMoney(int) => out.put_i64(*int),
             PythonDTO::PyIntU32(int) => out.put_u32(*int),
             PythonDTO::PyIntU64(int) => out.put_u64(*int),
             PythonDTO::PyFloat32(float) => out.put_f32(*float),
@@ -323,6 +325,7 @@ 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);
     }
@@ -389,6 +392,12 @@ pub fn py_to_rust(parameter: &pyo3::Bound<'_, PyAny>) -> RustPSQLDriverPyResult<
         ));
     }
 
+    if parameter.is_instance_of::<Money>() {
+        return Ok(PythonDTO::PyMoney(
+            parameter.extract::<Money>()?.retrieve_value(),
+        ));
+    }
+
     if parameter.is_instance_of::<PyInt>() {
         return Ok(PythonDTO::PyIntI32(parameter.extract::<i32>()?));
     }
@@ -480,6 +489,13 @@ 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>()?,
+        )?));
+    }
+
     if let Ok(id_address) = parameter.extract::<IpAddr>() {
         return Ok(PythonDTO::PyIpAddress(id_address));
     }