@@ -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 so fractional digits are not lost (up to the 38-digit DECIMAL maximum; a value needing more digits than that still has its excess fractional digits rounded).
+- **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 the bound type is widened to fit the value: a declared `scale` smaller than the value's own scale is widened so fractional digits are not lost, and a declared `precision` whose integer room (`precision - scale`) is smaller than the value's integer digits is also widened, so such values are no longer rejected by the server as out of range (e.g. `DecimalParameter(Decimal("123456789012.5"), precision=10, scale=2)` now binds `DECIMAL(14,2)` instead of failing). If you relied on `precision` as a server-side range check, validate the value client-side. Widening is capped at the 38-digit DECIMAL maximum; a value needing more digits than that still has its excess fractional digits rounded.
 - Preserve the originating session when re-fetching or concurrently polling async statements on the kernel backend.
 
 # 4.8.0 (2026-10-24)
 
@@ -664,6 +664,18 @@ def __init__(
             )
             self.scale, self.precision = self.precision, self.scale
 
+        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):
         if (self.scale is None and self.precision is None) or (
             isinstance(self.scale, int) and isinstance(self.precision, int)
@@ -692,18 +704,25 @@ 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 bound value does not lose
-        fractional digits: the value's own scale is authoritative over an
-        under-declared target scale. Integer-digit room from the declared type is kept.
+        """Widen a declared DECIMAL(precision, scale) so the bound value fits: the
+        value's own scale is authoritative over an under-declared target scale, and
+        the integer-digit room is widened to the value's integer digits when the
+        declared ``precision - scale`` is too small (so the declared precision is not
+        enforced as a range check). Extra integer room from the declared type is kept.
 
         Exception: the total is capped at MAX_PRECISION (38) digits. If the value
         itself needs more than 38 digits (e.g. a scale over 38), the cast is clamped
         and the server rounds away the fractional digits that do not fit.
         """
-        try:
-            sign, digits, exponent = self.value.as_tuple()
-        except AttributeError:
-            return precision, scale
+        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
+        sign, digits, exponent = value.as_tuple()
         if not isinstance(exponent, int):
             # NaN / Infinity: leave the declared type as-is
             return precision, scale
 
@@ -130,8 +130,13 @@ def test_calculate_decimal_cast_string(value, expected):
         # NaN / Infinity leave the declared type untouched
         (Decimal("NaN"), 2, 10, "DECIMAL(10,2)"),
         (Decimal("Infinity"), 2, 10, "DECIMAL(10,2)"),
-        # Non-Decimal values (no as_tuple) fall back to the declared type
+        # 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(12,0)"),
+        ("123.4567", 2, 10, "DECIMAL(12,4)"),
+        # Unparseable values fall back to the declared type
+        ("not-a-number", 2, 10, "DECIMAL(10,2)"),
     ),
 )
 def test_decimal_explicit_precision_scale_cast_string(value, scale, precision, expected):
@@ -164,6 +169,26 @@ def test_decimal_scale_greater_than_precision_legacy_swapped():
     assert p._cast_expr() == "DECIMAL(10,2)"
 
 
+@pytest.mark.parametrize(
+    "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"),
+    ),
+)
+def test_decimal_invalid_declared_precision_or_scale_raises(scale, precision, match):
+    with pytest.raises(ValueError, match=match):
+        DecimalParameter(Decimal("1.5"), scale=scale, precision=precision)
+
+
+def test_decimal_legacy_swapped_out_of_range_precision_raises():
+    """The range check applies after the legacy swap (scale=50 becomes precision=50)."""
+    with pytest.warns(FutureWarning, match="legacy"):
+        with pytest.raises(ValueError, match="precision must be between 1 and 38"):
+            DecimalParameter(Decimal("1.5"), scale=50, precision=2)
+
+
 class Primitive(Enum):
     """These are the inferrable types. This Enum is used for parametrized tests."""