@@ -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 (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`.
+- **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 0..38, a negative `scale`, and `bool` values for `scale` or `precision`. `precision=0` (e.g. `scale=5, precision=0`) still falls back to an inferred type as before, but now emits a `FutureWarning`; it will raise `ValueError` in a future release.
 - Preserve the originating session when re-fetching or concurrently polling async statements on the kernel backend.
 
 # 4.8.0 (2026-10-24)
 
@@ -648,6 +648,24 @@ def __init__(
                 "as integers"
             )
 
+        if self.precision == 0:
+            # Earlier releases treated precision=0 as falsy, i.e. "unset", and inferred
+            # the type from the value. Keep that behaviour for now (swapping e.g.
+            # scale=5, precision=0 into DECIMAL(5,0) would silently round the value),
+            # but warn so callers migrate before this becomes an error, like the
+            # other legacy-convention calls below.
+            warnings.warn(
+                "DecimalParameter received precision=0 (scale={}); ignoring scale and "
+                "precision and inferring the DECIMAL type from the value, as earlier "
+                "releases did. `precision` must be between 1 and {}; pass both as None "
+                "to infer the type. This will raise ValueError in a future "
+                "release.".format(self.scale, self.MAX_PRECISION),
+                FutureWarning,
+                stacklevel=2,
+            )
+            self.scale = None
+            self.precision = None
+
         if self.scale is not None and self.precision is not None:
             # Range-check the raw arguments *before* the legacy swap below, so a call
             # that is simply invalid (rather than written for the legacy convention)
@@ -657,9 +675,6 @@ def __init__(
                 raise ValueError(
                     "DecimalParameter scale must be >= 0, got {}".format(self.scale)
                 )
-            # 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(
@@ -770,6 +785,16 @@ def _effective_precision_and_scale(self, precision: int, scale: int):
             # NaN / Infinity: leave the declared type as-is
             return precision, scale
 
+        # Trailing fractional zeros carry no information, so ignore them: otherwise
+        # Decimal("1.50") and Decimal("1.5") would bind different types for the same
+        # declared parameter. (Stripping keeps len(digits) + exponent unchanged.)
+        while exponent < 0 and len(digits) > 1 and digits[-1] == 0:
+            digits = digits[:-1]
+            exponent += 1
+        if digits == (0,):
+            # Zero (e.g. Decimal("0.000")) has no significant fractional digits
+            exponent = max(exponent, 0)
+
         value_scale = max(-exponent, 0)
         declared_int_digits = precision - scale
         # Integer room is never widened past the declared one: an overflowing value
 
@@ -115,6 +115,11 @@ def test_calculate_decimal_cast_string(value, expected):
         (Decimal("123"), 0, 10, "DECIMAL(10,0)"),
         # Value scale exceeds declared scale: scale widens, declared int room (8) is kept
         (Decimal("123.4567"), 2, 10, "DECIMAL(12,4)"),
+        # Trailing fractional zeros are not significant and do not widen the scale
+        (Decimal("123.4500"), 2, 10, "DECIMAL(10,2)"),
+        (Decimal("123.4560"), 2, 10, "DECIMAL(11,3)"),
+        (Decimal("0.000"), 2, 10, "DECIMAL(10,2)"),
+        (Decimal("100"), 0, 10, "DECIMAL(10,0)"),
         # Value has more integer digits than declared precision - scale allows:
         # integer room is not widened, so the server rejects it as out of range
         (Decimal("123456789012.5"), 2, 10, "DECIMAL(10,2)"),
@@ -211,7 +216,6 @@ def test_decimal_correct_order_with_more_fractional_digits_is_widened():
     "scale,precision,match",
     (
         (2, 50, "precision must be between 1 and 38"),
-        (0, 0, "precision must be between 1 and 38"),
         (-1, 10, "scale must be >= 0"),
     ),
 )
@@ -235,9 +239,6 @@ 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):
@@ -249,6 +250,17 @@ def test_decimal_out_of_range_raw_args_raise_before_legacy_swap(scale, precision
             DecimalParameter(Decimal("1.5"), scale=scale, precision=precision)
 
 
+@pytest.mark.parametrize("scale", (0, 5, 10))
+def test_decimal_precision_zero_falls_back_to_inferred_type_with_warning(scale):
+    """precision=0 used to mean "unset" (type inferred). Keep that, with a
+    FutureWarning, rather than raising or swapping into DECIMAL(scale,0), which
+    would round the value."""
+    with pytest.warns(FutureWarning, match="precision=0"):
+        p = DecimalParameter(Decimal("1234.56"), scale=scale, precision=0)
+    assert p.scale is None and p.precision is None
+    assert p._cast_expr() == "DECIMAL(6,2)"
+
+
 class Primitive(Enum):
     """These are the inferrable types. This Enum is used for parametrized tests."""