@@ -640,13 +640,36 @@ def __init__(
         self.name = name
         self.scale = scale
         self.precision = precision
+        self._legacy_swapped = False
 
         if not self.valid_scale_and_precision():
             raise ValueError(
                 "DecimalParameter requires both or none of scale and precision to be set, "
                 "as integers"
             )
 
+        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)
+            # gets an error naming the argument the caller actually passed, and no
+            # misleading migration warning.
+            if self.scale < 0:
+                raise ValueError(
+                    "DecimalParameter scale must be >= 0, got {}".format(self.scale)
+                )
+            if self.precision < 0 or self.precision > self.MAX_PRECISION:
+                raise ValueError(
+                    "DecimalParameter precision must be between 1 and {}, got {}".format(
+                        self.MAX_PRECISION, self.precision
+                    )
+                )
+            if self.scale > self.MAX_PRECISION:
+                raise ValueError(
+                    "DecimalParameter scale must be between 0 and {}, got {}".format(
+                        self.MAX_PRECISION, self.scale
+                    )
+                )
+
         if (
             self.scale is not None
             and self.precision is not None
@@ -663,7 +686,10 @@ def __init__(
                 "`precision` is the total number of digits and `scale` is the number of "
                 "digits after the decimal point, as in SQL DECIMAL(precision, scale). "
                 "Swap your arguments; this will raise ValueError in a future "
-                "release.".format(
+                "release. Legacy-convention calls keep the previous behaviour (the "
+                "server rounds the value to the declared scale); with correctly "
+                "ordered arguments the bound scale is widened to fit the value's "
+                "fractional digits instead.".format(
                     self.scale, self.precision, self.scale, self.precision
                 ),
                 # FutureWarning (not DeprecationWarning) so end users see it by
@@ -672,6 +698,9 @@ def __init__(
                 stacklevel=2,
             )
             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.
+            self._legacy_swapped = True
 
         if self.scale is not None and self.precision is not None:
             if self.scale < 0:
@@ -700,6 +729,10 @@ def _is_int(x):
 
     def _cast_expr(self):
         if self.scale is not None and self.precision is not None:
+            if self._legacy_swapped:
+                # Legacy-convention call: bind the declared type unchanged, as
+                # earlier releases did, so existing rounding is preserved.
+                return self.CAST_EXPR.format(self.precision, self.scale)
             precision, scale = self._effective_precision_and_scale(
                 self.precision, self.scale
             )
 
@@ -1,4 +1,5 @@
 import datetime
+import warnings
 from decimal import Decimal
 from enum import Enum
 from typing import Type
@@ -190,6 +191,22 @@ def test_decimal_scale_greater_than_precision_legacy_swapped():
     assert p._cast_expr() == "DECIMAL(10,2)"
 
 
+def test_decimal_legacy_swapped_is_not_widened():
+    """Legacy-convention calls keep the old bound type (and so the old rounding):
+    DecimalParameter(Decimal("12.3456"), scale=4, precision=2) still binds DECIMAL(4,2)
+    rather than being widened to DECIMAL(6,4)."""
+    with pytest.warns(FutureWarning, match="previous behaviour"):
+        p = DecimalParameter(Decimal("12.3456"), scale=4, precision=2)
+    assert p._cast_expr() == "DECIMAL(4,2)"
+    assert p.as_tspark_param(named=False).type == "DECIMAL(4,2)"
+
+
+def test_decimal_correct_order_with_more_fractional_digits_is_widened():
+    """Counterpart of the legacy test: correctly ordered arguments do widen."""
+    p = DecimalParameter(Decimal("12.3456"), scale=2, precision=4)
+    assert p._cast_expr() == "DECIMAL(6,4)"
+
+
 @pytest.mark.parametrize(
     "scale,precision,match",
     (
@@ -213,11 +230,20 @@ def test_decimal_bool_scale_or_precision_raises(scale, precision):
         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)
+@pytest.mark.parametrize(
+    "scale,precision,match",
+    (
+        (50, 2, "scale must be between 0 and 38, got 50"),
+        (5, -1, "precision must be between 1 and 38, got -1"),
+    ),
+)
+def test_decimal_out_of_range_raw_args_raise_before_legacy_swap(scale, precision, match):
+    """Range checks run on the raw arguments before the legacy swap, so the error
+    names the argument the caller actually passed and no FutureWarning is emitted."""
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", FutureWarning)
+        with pytest.raises(ValueError, match=match):
+            DecimalParameter(Decimal("1.5"), scale=scale, precision=precision)
 
 
 class Primitive(Enum):