@@ -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 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.
+- **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. `scale=0` (previously also treated as unset) is now honoured as `DECIMAL(precision, 0)`, except that when the value has more integer digits than `precision` (which earlier releases accepted via the inferred type) it falls back to the inferred type with a `FutureWarning`; this 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)
 
@@ -608,7 +608,8 @@ def __init__(
         the value has more fractional digits than `scale`, the bound scale (and so the
         precision) is widened to fit them (capped at precision 38) so they are not lost;
         the declared integer room (`precision - scale`) is kept, so a value with more
-        integer digits than that is still rejected by the server as out of range.
+        integer digits than that is still rejected by the server as out of range
+        (except, for backward compatibility, with `scale=0`: see the CHANGELOG).
         Round the `Decimal` yourself (e.g. with `Decimal.quantize`) before binding if
         you need it narrowed to the declared scale.
 
@@ -688,6 +689,31 @@ def __init__(
                     )
                 )
 
+        if self.scale == 0 and self.precision is not None:
+            # Earlier releases also treated scale=0 as falsy, i.e. "unset", and
+            # inferred the type from the value. Honouring DECIMAL(precision, 0) is
+            # only a regression when the value has more integer digits than
+            # `precision` (the server would now reject a call that used to work), so
+            # keep the inferred type for exactly that case, with a warning.
+            normalized = self._normalized_value_digits()
+            if normalized is not None:
+                digits, exponent = normalized
+                if max(len(digits) + exponent, 0) > self.precision:
+                    warnings.warn(
+                        "DecimalParameter received scale=0, precision={} for a value "
+                        "with more than {} integer digits; ignoring scale and "
+                        "precision and inferring the DECIMAL type from the value, as "
+                        "earlier releases did. Declare a precision large enough for "
+                        "the value, or pass both as None to infer the type. This "
+                        "will raise ValueError in a future release.".format(
+                            self.precision, self.precision
+                        ),
+                        FutureWarning,
+                        stacklevel=2,
+                    )
+                    self.scale = None
+                    self.precision = None
+
         if (
             self.scale is not None
             and self.precision is not None
@@ -761,29 +787,21 @@ def _cast_expr(self):
 
     MAX_PRECISION = 38
 
-    def _effective_precision_and_scale(self, precision: int, scale: int):
-        """Widen a declared DECIMAL(precision, scale) so the value's fractional digits
-        fit: the value's own scale is authoritative over an under-declared target
-        scale. The declared integer room (``precision - scale``) is never widened, so
-        a value with more integer digits is still rejected by the server as out of
-        range, as in earlier releases.
-
-        Exception: the total is capped at MAX_PRECISION (38) digits. If the value
-        needs more than that (e.g. a scale over 38), the cast is clamped and the
-        server rounds away the fractional digits that do not fit.
-        """
+    def _normalized_value_digits(self):
+        """Return ``(digits, exponent)`` of the value with insignificant trailing
+        fractional zeros stripped, or None if the value is not a finite number."""
         value = self.value
         if not isinstance(value, decimal.Decimal):
             # The value is sent to the server as str(value), so inspect that same
             # textual form; this makes int / float / str values widen like Decimals.
             try:
                 value = decimal.Decimal(str(value))
             except (decimal.InvalidOperation, ValueError, TypeError):
-                return precision, scale
+                return None
         sign, digits, exponent = value.as_tuple()
         if not isinstance(exponent, int):
-            # NaN / Infinity: leave the declared type as-is
-            return precision, scale
+            # NaN / Infinity
+            return None
 
         # Trailing fractional zeros carry no information, so ignore them: otherwise
         # Decimal("1.50") and Decimal("1.5") would bind different types for the same
@@ -794,6 +812,23 @@ def _effective_precision_and_scale(self, precision: int, scale: int):
         if digits == (0,):
             # Zero (e.g. Decimal("0.000")) has no significant fractional digits
             exponent = max(exponent, 0)
+        return digits, exponent
+
+    def _effective_precision_and_scale(self, precision: int, scale: int):
+        """Widen a declared DECIMAL(precision, scale) so the value's fractional digits
+        fit: the value's own scale is authoritative over an under-declared target
+        scale. The declared integer room (``precision - scale``) is never widened, so
+        a value with more integer digits is still rejected by the server as out of
+        range, as in earlier releases.
+
+        Exception: the total is capped at MAX_PRECISION (38) digits. If the value
+        needs more than that (e.g. a scale over 38), the cast is clamped and the
+        server rounds away the fractional digits that do not fit.
+        """
+        normalized = self._normalized_value_digits()
+        if normalized is None:
+            return precision, scale
+        digits, exponent = normalized
 
         value_scale = max(-exponent, 0)
         declared_int_digits = precision - scale
 
@@ -123,9 +123,11 @@ def test_calculate_decimal_cast_string(value, expected):
         # 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)"),
-        # Positive exponent: 1E+3 needs 4 integer digits; declared room (2) is kept
-        (Decimal("1E+3"), 0, 2, "DECIMAL(2,0)"),
+        # Positive exponent: 1E+3 needs 4 integer digits, which DECIMAL(5,0) fits
         (Decimal("1E+3"), 0, 5, "DECIMAL(5,0)"),
+        (Decimal("1E+3"), 0, 4, "DECIMAL(4,0)"),
+        # scale=0 with a fractional value that fits the integer room: honoured, widened
+        (Decimal("123.45"), 0, 3, "DECIMAL(5,2)"),
         # Widened precision is capped at 38
         (Decimal("0.123456789012345678901234567890123456"), 2, 10, "DECIMAL(38,36)"),
         # Widened scale is capped at the (capped) precision
@@ -144,7 +146,7 @@ def test_calculate_decimal_cast_string(value, expected):
         # Non-Decimal values are inspected via str(value), which is what is sent
         (1.5, 2, 10, "DECIMAL(10,2)"),
         (12.3456, 2, 10, "DECIMAL(12,4)"),
-        (123456789012, 0, 10, "DECIMAL(10,0)"),
+        (1234567890, 0, 10, "DECIMAL(10,0)"),
         ("123.4567", 2, 10, "DECIMAL(12,4)"),
         # Unparseable values fall back to the declared type
         ("not-a-number", 2, 10, "DECIMAL(10,2)"),
@@ -261,6 +263,36 @@ def test_decimal_precision_zero_falls_back_to_inferred_type_with_warning(scale):
     assert p._cast_expr() == "DECIMAL(6,2)"
 
 
+@pytest.mark.parametrize(
+    "value,precision,expected",
+    (
+        (Decimal("123.45"), 2, "DECIMAL(5,2)"),
+        (Decimal("1E+3"), 2, "DECIMAL(4,0)"),
+        (123456789012, 10, "DECIMAL(12,0)"),
+    ),
+)
+def test_decimal_scale_zero_integer_overflow_falls_back_to_inferred_type(
+    value, precision, expected
+):
+    """scale=0 used to mean "unset" (type inferred). When honouring DECIMAL(precision,0)
+    would overflow the value's integer digits (a call that used to succeed), keep the
+    inferred type, with a FutureWarning."""
+    with pytest.warns(FutureWarning, match="scale=0"):
+        p = DecimalParameter(value, scale=0, precision=precision)
+    assert p.scale is None and p.precision is None
+    assert p._cast_expr() == expected
+
+
+@pytest.mark.parametrize(
+    "value,precision", ((Decimal("123.45"), 3), (Decimal("0.5"), 1), (Decimal("NaN"), 1))
+)
+def test_decimal_scale_zero_that_fits_is_honoured_without_warning(value, precision):
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", FutureWarning)
+        p = DecimalParameter(value, scale=0, precision=precision)
+    assert (p.scale, p.precision) == (0, precision)
+
+
 class Primitive(Enum):
     """These are the inferrable types. This Enum is used for parametrized tests."""