@@ -6,7 +6,7 @@
 
 from __future__ import annotations
 
-from decimal import Decimal
+from decimal import Decimal, localcontext
 from typing import TYPE_CHECKING, ClassVar
 
 import polars as pl
@@ -17,6 +17,7 @@
 
 from cudf_polars.containers import Column
 from cudf_polars.dsl.expressions.base import ExecutionContext, Expr
+from cudf_polars.dsl.expressions.literal import Literal
 
 pl_expr = polars._expr_nodes
 
@@ -30,18 +31,37 @@
 _DECIMAL128_MAX_PRECISION = 38
 
 
-def _decimal_rescale_may_overflow(left: DataType, right: DataType) -> bool:
+def _decimal_precision(node: Expr) -> int:
+    """
+    The number of digits needed for the values of a Decimal expression.
+
+    A literal only needs as many digits as its value, which can be far fewer
+    than its type declares: polars gives the literal ``24`` the type
+    ``Decimal(38, 0)``.
+    """
+    dtype = node.dtype.polars_type
+    assert isinstance(dtype, pl.Decimal)
+    if isinstance(node, Literal) and isinstance(node.value, Decimal):
+        # Polars writes a Decimal literal with exactly the scale of its dtype, so
+        # the scaled value is a whole number. The default context rounds to 28
+        # digits, which would change the count near the 38 digit limit.
+        with localcontext(prec=2 * _DECIMAL128_MAX_PRECISION):
+            return max(len(str(abs(int(node.value.scaleb(dtype.scale))))), 1)
+    return dtype.precision or _DECIMAL128_MAX_PRECISION
+
+
+def _decimal_rescale_may_overflow(left: Expr, right: Expr) -> bool:
     """Whether rescaling two Decimals to their finer scale can exceed 38 digits."""
     if not (
-        plc.traits.is_fixed_point(left.plc_type)
-        and plc.traits.is_fixed_point(right.plc_type)
+        plc.traits.is_fixed_point(left.dtype.plc_type)
+        and plc.traits.is_fixed_point(right.dtype.plc_type)
     ):
         return False
-    lt, rt = left.polars_type, right.polars_type
+    lt, rt = left.dtype.polars_type, right.dtype.polars_type
     assert isinstance(lt, pl.Decimal)
     assert isinstance(rt, pl.Decimal)
-    lp = lt.precision or _DECIMAL128_MAX_PRECISION
-    rp = rt.precision or _DECIMAL128_MAX_PRECISION
+    lp = _decimal_precision(left)
+    rp = _decimal_precision(right)
     scale = max(lt.scale, rt.scale)
     return max(lp - lt.scale, rp - rt.scale) + scale > _DECIMAL128_MAX_PRECISION
 
@@ -66,9 +86,7 @@ def __init__(
         self.op = op
         self.children = (left, right)
         self.is_pointwise = True
-        if op in BinOp._COMPARISONS and _decimal_rescale_may_overflow(
-            left.dtype, right.dtype
-        ):
+        if op in BinOp._COMPARISONS and _decimal_rescale_may_overflow(left, right):
             # Polars 2.1 compares decimals of different scales exactly, but
             # libcudf rescales to the finer scale in 128 bits and wraps.
             raise NotImplementedError(
 
@@ -332,3 +332,54 @@ def test_decimal_comparison_mixed_scale_overflow(
         assert_ir_translation_raises(q, engine, NotImplementedError)
     else:
         assert_gpu_result_equal(q, engine=engine)
+
+
+@pytest.mark.parametrize("dtype", [pl.Decimal(15, 2), pl.Decimal(38, 2)])
+@pytest.mark.parametrize("literal", [0, 24, -6, 10_000])
+def test_decimal_comparison_with_integer_literal(engine: pl.GPUEngine, dtype, literal):
+    # polars types an integer literal as Decimal(38, 0), but its value needs
+    # far fewer digits than that, so rescaling it cannot overflow.
+    biggest = "9" * (dtype.precision - dtype.scale) + "." + "9" * dtype.scale
+    df = pl.DataFrame({"a": ["-2.5", "0", "24", str(literal), biggest, None]}).cast(
+        dtype
+    )
+    a = pl.col("a")
+    q = df.lazy().select(
+        lt=a < literal,
+        le=a <= literal,
+        gt=a > literal,
+        ge=a >= literal,
+        eq=a == literal,
+        ne=a != literal,
+    )
+    assert_gpu_result_equal(q, engine=engine)
+
+
+def test_decimal_comparison_of_expression_with_integer_literal(
+    engine: pl.GPUEngine,
+):
+    df = pl.DataFrame({"a": ["1.50", "2.25", "3.00"]}).cast(pl.Decimal(7, 2)).lazy()
+    q = df.select(gt=(pl.col("a") * 2).sum() > 0, lt=pl.col("a") * 2 < 5)
+    assert_gpu_result_equal(q, engine=engine)
+
+
+def test_decimal_comparison_with_literal_that_may_overflow(engine: pl.GPUEngine):
+    # The literal has a finer scale than the column, so rescaling the column
+    # to the literal's scale needs 36 + 3 digits.
+    df = pl.DataFrame({"a": ["1.00", "2.00"]}).cast(pl.Decimal(38, 2)).lazy()
+    q = df.select(gt=pl.col("a") > pl.lit(Decimal("1.005")))
+    assert_ir_translation_raises(q, engine, NotImplementedError)
+
+
+def test_decimal_comparison_with_literal_of_maximum_precision(engine: pl.GPUEngine):
+    # Neither operand needs rescaling, so a literal of 38 digits is supported.
+    df = pl.DataFrame({"a": ["1", "9" * 38]}).cast(pl.Decimal(38, 0)).lazy()
+    q = df.select(lt=pl.col("a") < pl.lit(Decimal("9" * 38)))
+    assert_gpu_result_equal(q, engine=engine)
+
+
+@pytest.mark.parametrize("literal", [Decimal("27.5"), 27.5])
+def test_decimal_comparison_with_fractional_literal(engine: pl.GPUEngine, literal):
+    df = pl.DataFrame({"a": ["1.00", "27.50", "30.00", None]}).cast(pl.Decimal(15, 2))
+    q = df.lazy().select(lt=pl.col("a") < literal, ge=pl.col("a") >= literal)
+    assert_gpu_result_equal(q, engine=engine)