ai: apply changes for #1006 (2 review threads)

Addresses:
  - #4418588494 at src/databricks/sql/parameters/native.py:660
  - #4418588499 at src/databricks/sql/parameters/native.py:705

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

Author: peco-engineer-bot[bot]

CHANGELOG.md

@@ -1,7 +1,7 @@
 # Release History
 
 # Unreleased
-- **Behaviour change:** `DecimalParameter` now binds `DECIMAL(precision, scale)`, matching SQL: `precision` is the total number of digits and `scale` the number of fractional digits (earlier docs described them the other way round). Calls written for the old convention (`scale > precision`, e.g. `scale=10, precision=2`) still bind `DECIMAL(10,2)` but emit a `FutureWarning`; swap your arguments, as this will raise `ValueError` in a future release. A declared `scale` equal to or less than `precision` is now interpreted with the SQL meaning, and a declared `scale` smaller than the value's own scale is widened (growing the precision by the same amount) so fractional digits are not lost (e.g. `DecimalParameter(Decimal("123.4567"), precision=10, scale=2)` binds `DECIMAL(12,4)`). The declared integer room (`precision - scale`) is not widened, so a value with more integer digits is still rejected by the server as out of range. Widening is capped at the 38-digit DECIMAL maximum; a value needing more digits than that still has its excess fractional digits rounded. The constructor now also raises `ValueError` for inputs it previously accepted: a `precision` outside 1..38 (e.g. `scale=0, precision=0`, which used to fall back to an inferred type), a negative `scale`, and `bool` values for `scale` or `precision`.
+- **Behaviour change:** `DecimalParameter` now binds `DECIMAL(precision, scale)`, matching SQL: `precision` is the total number of digits and `scale` the number of fractional digits (earlier docs described them the other way round). Calls written for the old convention (`scale > precision`, e.g. `scale=10, precision=2`) still bind `DECIMAL(10,2)` but emit a `FutureWarning`; swap your arguments, as this will raise `ValueError` in a future release. A declared `scale` equal to or less than `precision` is now interpreted with the SQL meaning, and a declared `scale` smaller than the value's own scale is widened (growing the precision by the same amount) so fractional digits are not lost (e.g. `DecimalParameter(Decimal("123.4567"), precision=10, scale=2)` binds `DECIMAL(12,4)`). The declared integer room (`precision - scale`) is not widened, so a value with more integer digits is still rejected by the server as out of range. Widening is capped at the 38-digit DECIMAL maximum; a value needing more digits than that still has its excess fractional digits rounded. The constructor now also raises `ValueError` for inputs it previously accepted: a `precision` outside 1..38 (including `precision=0`, e.g. `scale=0, precision=0` or `scale=5, precision=0`, which used to fall back to an inferred type), a negative `scale`, and `bool` values for `scale` or `precision`.
 - Preserve the originating session when re-fetching or concurrently polling async statements on the kernel backend.
 
 # 4.8.0 (2026-10-24)

src/databricks/sql/parameters/native.py

@@ -657,7 +657,10 @@ def __init__(
                 raise ValueError(
                     "DecimalParameter scale must be >= 0, got {}".format(self.scale)
                 )
-            if self.precision < 0 or self.precision > self.MAX_PRECISION:
+            # precision=0 is rejected here too (not swapped): earlier releases
+            # treated it as unset and inferred the type, so swapping e.g.
+            # scale=5, precision=0 into DECIMAL(5,0) would silently round the value.
+            if not 1 <= self.precision <= self.MAX_PRECISION:
                 raise ValueError(
                     "DecimalParameter precision must be between 1 and {}, got {}".format(
                         self.MAX_PRECISION, self.precision
@@ -700,20 +703,11 @@ def __init__(
             self.scale, self.precision = self.precision, self.scale
             # Preserve the old bound type exactly (no widening) for these callers,
             # so the only change they see is the warning.
+            # No re-validation needed: the swapped scale is the raw precision
+            # (already 1..38) and the swapped precision is the raw scale (already
+            # > that and <= 38), so the result is always a valid DECIMAL.
             self._legacy_swapped = True
 
-        if self.scale is not None and self.precision is not None:
-            if self.scale < 0:
-                raise ValueError(
-                    "DecimalParameter scale must be >= 0, got {}".format(self.scale)
-                )
-            if not 1 <= self.precision <= self.MAX_PRECISION:
-                raise ValueError(
-                    "DecimalParameter precision must be between 1 and {}, got {}".format(
-                        self.MAX_PRECISION, self.precision
-                    )
-                )
-
     def valid_scale_and_precision(self):
         def _is_int(x):
             # bool is a subclass of int; reject it so precision=True/scale=False

tests/unit/test_parameters.py

@@ -235,6 +235,9 @@ def test_decimal_bool_scale_or_precision_raises(scale, precision):
     (
         (50, 2, "scale must be between 0 and 38, got 50"),
         (5, -1, "precision must be between 1 and 38, got -1"),
+        # precision=0 used to mean "unset" (type inferred); it must not be swapped
+        # into DECIMAL(5,0), which would round the value.
+        (5, 0, "precision must be between 1 and 38, got 0"),
     ),
 )
 def test_decimal_out_of_range_raw_args_raise_before_legacy_swap(scale, precision, match):