[coverage] Conformance findings: PARAMQUERY-021 (#901)

Signed-off-by: peco-engineer-bot[bot] <3815206+peco-engineer-bot[bot]@users.noreply.github.com>

Author: peco-engineer-bot[bot]

src/databricks/sql/parameters/native.py

@@ -615,9 +615,10 @@ def __init__(
 
             The `name` argument to this function would be `my_param`.
         :scale:
-            The maximum precision (total number of digits) of the number between 1 and 38.
+            The number of digits to the right of the decimal point. If the value itself
+            has more fractional digits, the value's scale is used so no digits are lost.
         :precision:
-            The number of digits to the right of the decimal point.
+            The maximum precision (total number of digits) of the number between 1 and 38.
         """
         self.value: decimal.Decimal = value
         self.name = name
@@ -638,11 +639,37 @@ def valid_scale_and_precision(self):
             return False
 
     def _cast_expr(self):
-        if self.scale and self.precision:
-            return self.CAST_EXPR.format(self.scale, self.precision)
+        if self.scale is not None and self.precision is not None:
+            precision, scale = self._effective_precision_and_scale(self.precision, self.scale)
+            # SQL DECIMAL type syntax is DECIMAL(precision, scale)
+            return self.CAST_EXPR.format(precision, scale)
         else:
             return self.calculate_decimal_cast_string(self.value)
 
+    MAX_PRECISION = 38
+
+    def _effective_precision_and_scale(self, precision: int, scale: int):
+        """Widen a declared DECIMAL(precision, scale) so the bound value never loses
+        fractional digits: the value's own scale is authoritative over an
+        under-declared target scale. Integer-digit room from the declared type is kept.
+        """
+        try:
+            sign, digits, exponent = self.value.as_tuple()
+        except AttributeError:
+            return precision, scale
+        if not isinstance(exponent, int):
+            # NaN / Infinity: leave the declared type as-is
+            return precision, scale
+
+        value_scale = max(-exponent, 0)
+        value_int_digits = max(len(digits) + exponent, 0)
+
+        effective_scale = max(scale, value_scale)
+        int_digits = max(precision - scale, value_int_digits)
+        effective_precision = min(int_digits + effective_scale, self.MAX_PRECISION)
+        effective_scale = min(effective_scale, effective_precision)
+        return effective_precision, effective_scale
+
     def calculate_decimal_cast_string(self, input: decimal.Decimal) -> str:
         """Returns the smallest SQL cast argument that can contain the passed decimal
 

tests/e2e/test_parameterized_queries.py

@@ -510,6 +510,26 @@ def test_native_recursive_complex_type(
         )
         assert self._recursive_compare(result.col, data)
 
+    @pytest.mark.parametrize("extra_params", [{}, {"use_sea": True}])
+    def test_decimal_explicit_precision_scale_order(self, extra_params):
+        """PARAMQUERY-021 (a): a declared DECIMAL(10,2) target (precision=10, scale=2)
+        must be sent as DECIMAL(10,2), not DECIMAL(2,10), and the value round-trips."""
+        param = DecimalParameter(Decimal("123.45"), scale=2, precision=10)
+        with self.cursor(extra_params) as cursor:
+            result = cursor.execute("SELECT ? AS v", [param]).fetchone()
+
+        assert result.v == Decimal("123.45")
+
+    @pytest.mark.parametrize("extra_params", [{}, {"use_sea": True}])
+    def test_decimal_target_type_never_truncates_bound_scale(self, extra_params):
+        """PARAMQUERY-021 (c): the value's own scale (4) is authoritative over an
+        under-declared target scale (2): all four fractional digits must survive."""
+        param = DecimalParameter(Decimal("123.4567"), scale=2, precision=10)
+        with self.cursor(extra_params) as cursor:
+            result = cursor.execute("SELECT ? AS v", [param]).fetchone()
+
+        assert result.v == Decimal("123.4567")
+
 
 class TestInlineParameterSyntax(PySQLPytestTestCase):
     """The inline parameter approach uses pyformat markers"""

tests/unit/test_parameters.py

@@ -107,6 +107,19 @@ def test_calculate_decimal_cast_string(value, expected):
     assert p._cast_expr() == expected
 
 
+@pytest.mark.parametrize(
+    "value,scale,precision,expected",
+    (
+        (Decimal("123.45"), 2, 10, "DECIMAL(10,2)"),
+        (Decimal("123"), 0, 10, "DECIMAL(10,0)"),
+    ),
+)
+def test_decimal_explicit_precision_scale_cast_string(value, scale, precision, expected):
+    """PARAMQUERY-021: SQL DECIMAL type is DECIMAL(precision, scale)."""
+    p = DecimalParameter(value, scale=scale, precision=precision)
+    assert p._cast_expr() == expected
+
+
 class Primitive(Enum):
     """These are the inferrable types. This Enum is used for parametrized tests."""