cudf-polars-cu13 25.10.0__py3-none-any.whl → 26.2.0__py3-none-any.whl

cudf_polars/dsl/translate.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES.
 # SPDX-License-Identifier: Apache-2.0
 
 """Translate polars IR representation to ours."""
@@ -14,8 +14,11 @@ from typing import TYPE_CHECKING, Any
 from typing_extensions import assert_never
 
 import polars as pl
-import polars.polars as plrs
-from polars.polars import _expr_nodes as pl_expr, _ir_nodes as pl_ir
+
+# polars.polars is not a part of the public API,
+# so we cannot rely on importing it directly
+# See https://github.com/pola-rs/polars/issues/24826
+from polars import polars as plrs  # type: ignore[attr-defined]
 
 import pylibcudf as plc
 
@@ -33,6 +36,8 @@ from cudf_polars.utils import config, sorting
 from cudf_polars.utils.versions import (
     POLARS_VERSION_LT_131,
     POLARS_VERSION_LT_132,
+    POLARS_VERSION_LT_133,
+    POLARS_VERSION_LT_134,
     POLARS_VERSION_LT_1323,
 )
 
@@ -61,6 +66,7 @@ class Translator:
         self.config_options = config.ConfigOptions.from_polars_engine(engine)
         self.errors: list[Exception] = []
         self._cache_nodes: dict[int, ir.Cache] = {}
+        self._expr_context: ExecutionContext = ExecutionContext.FRAME
 
     def translate_ir(self, *, n: int | None = None) -> ir.IR:
         """
@@ -96,7 +102,7 @@ class Translator:
         # IR is versioned with major.minor, minor is bumped for backwards
         # compatible changes (e.g. adding new nodes), major is bumped for
         # incompatible changes (e.g. renaming nodes).
-        if (version := self.visitor.version()) >= (10, 1):
+        if (version := self.visitor.version()) >= (11, 1):
             e = NotImplementedError(
                 f"No support for polars IR {version=}"
             )  # pragma: no cover; no such version for now.
@@ -201,6 +207,23 @@ class set_node(AbstractContextManager[None]):
 noop_context: nullcontext[None] = nullcontext()
 
 
+class set_expr_context(AbstractContextManager[None]):
+    __slots__ = ("_prev", "ctx", "translator")
+
+    def __init__(self, translator: Translator, ctx: ExecutionContext) -> None:
+        self.translator = translator
+        self.ctx = ctx
+        self._prev: ExecutionContext | None = None
+
+    def __enter__(self) -> None:
+        self._prev = self.translator._expr_context
+        self.translator._expr_context = self.ctx
+
+    def __exit__(self, *args: Any) -> None:
+        assert self._prev is not None
+        self.translator._expr_context = self._prev
+
+
 @singledispatch
 def _translate_ir(node: Any, translator: Translator, schema: Schema) -> ir.IR:
     raise NotImplementedError(
@@ -209,7 +232,7 @@ def _translate_ir(node: Any, translator: Translator, schema: Schema) -> ir.IR:
 
 
 @_translate_ir.register
-def _(node: pl_ir.PythonScan, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.PythonScan, translator: Translator, schema: Schema) -> ir.IR:
     scan_fn, with_columns, source_type, predicate, nrows = node.options
     options = (scan_fn, with_columns, source_type, nrows)
     predicate = (
@@ -221,7 +244,7 @@ def _(node: pl_ir.PythonScan, translator: Translator, schema: Schema) -> ir.IR:
 
 
 @_translate_ir.register
-def _(node: pl_ir.Scan, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.Scan, translator: Translator, schema: Schema) -> ir.IR:
     typ, *options = node.scan_type
     paths = node.paths
     # Polars can produce a Scan with an empty ``node.paths`` (eg. the native
@@ -254,6 +277,9 @@ def _(node: pl_ir.Scan, translator: Translator, schema: Schema) -> ir.IR:
         skip_rows = 0
     else:
         skip_rows, n_rows = pre_slice
+        if (n_rows == 2**32 - 1) or (n_rows == 2**64 - 1):
+            # Polars translates slice(10, None) -> (10, u32/64max)
+            n_rows = -1
 
     return ir.Scan(
         schema,
@@ -274,7 +300,7 @@ def _(node: pl_ir.Scan, translator: Translator, schema: Schema) -> ir.IR:
 
 
 @_translate_ir.register
-def _(node: pl_ir.Cache, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.Cache, translator: Translator, schema: Schema) -> ir.IR:
     if POLARS_VERSION_LT_1323:  # pragma: no cover
         refcount = node.cache_hits
     else:
@@ -293,7 +319,9 @@ def _(node: pl_ir.Cache, translator: Translator, schema: Schema) -> ir.IR:
 
 
 @_translate_ir.register
-def _(node: pl_ir.DataFrameScan, translator: Translator, schema: Schema) -> ir.IR:
+def _(
+    node: plrs._ir_nodes.DataFrameScan, translator: Translator, schema: Schema
+) -> ir.IR:
     return ir.DataFrameScan(
         schema,
         node.df,
@@ -302,7 +330,7 @@ def _(node: pl_ir.DataFrameScan, translator: Translator, schema: Schema) -> ir.I
 
 
 @_translate_ir.register
-def _(node: pl_ir.Select, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.Select, translator: Translator, schema: Schema) -> ir.IR:
     with set_node(translator.visitor, node.input):
         inp = translator.translate_ir(n=None)
         exprs = [
@@ -312,15 +340,17 @@ def _(node: pl_ir.Select, translator: Translator, schema: Schema) -> ir.IR:
 
 
 @_translate_ir.register
-def _(node: pl_ir.GroupBy, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.GroupBy, translator: Translator, schema: Schema) -> ir.IR:
     with set_node(translator.visitor, node.input):
         inp = translator.translate_ir(n=None)
         keys = [
             translate_named_expr(translator, n=e, schema=inp.schema) for e in node.keys
         ]
-        original_aggs = [
-            translate_named_expr(translator, n=e, schema=inp.schema) for e in node.aggs
-        ]
+        with set_expr_context(translator, ExecutionContext.GROUPBY):
+            original_aggs = [
+                translate_named_expr(translator, n=e, schema=inp.schema)
+                for e in node.aggs
+            ]
     is_rolling = node.options.rolling is not None
     is_dynamic = node.options.dynamic is not None
     if is_dynamic:
@@ -333,8 +363,34 @@ def _(node: pl_ir.GroupBy, translator: Translator, schema: Schema) -> ir.IR:
         return rewrite_groupby(node, schema, keys, original_aggs, inp)
 
 
+_DECIMAL_TYPES = {plc.TypeId.DECIMAL32, plc.TypeId.DECIMAL64, plc.TypeId.DECIMAL128}
+
+
+def _align_decimal_scales(
+    left: expr.Expr, right: expr.Expr
+) -> tuple[expr.Expr, expr.Expr]:
+    left_type, right_type = left.dtype, right.dtype
+
+    if plc.traits.is_fixed_point(left_type.plc_type) and plc.traits.is_fixed_point(
+        right_type.plc_type
+    ):
+        target = DataType.common_decimal_dtype(left_type, right_type)
+
+        if (
+            left_type.id() != target.id() or left_type.scale() != target.scale()
+        ):  # pragma: no cover; no test yet
+            left = expr.Cast(target, True, left)  # noqa: FBT003
+
+        if (
+            right_type.id() != target.id() or right_type.scale() != target.scale()
+        ):  # pragma: no cover; no test yet
+            right = expr.Cast(target, True, right)  # noqa: FBT003
+
+    return left, right
+
+
 @_translate_ir.register
-def _(node: pl_ir.Join, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.Join, translator: Translator, schema: Schema) -> ir.IR:
     # Join key dtypes are dependent on the schema of the left and
     # right inputs, so these must be translated with the relevant
     # input active.
@@ -388,22 +444,24 @@ def _(node: pl_ir.Join, translator: Translator, schema: Schema) -> ir.IR:
                 expr.BinOp(
                     dtype,
                     expr.BinOp._MAPPING[op],
-                    insert_colrefs(
-                        left.value,
-                        table_ref=plc.expressions.TableReference.LEFT,
-                        name_to_index={
-                            name: i for i, name in enumerate(inp_left.schema)
-                        },
-                    ),
-                    insert_colrefs(
-                        right.value,
-                        table_ref=plc.expressions.TableReference.RIGHT,
-                        name_to_index={
-                            name: i for i, name in enumerate(inp_right.schema)
-                        },
+                    *_align_decimal_scales(
+                        insert_colrefs(
+                            left_ne.value,
+                            table_ref=plc.expressions.TableReference.LEFT,
+                            name_to_index={
+                                name: i for i, name in enumerate(inp_left.schema)
+                            },
+                        ),
+                        insert_colrefs(
+                            right_ne.value,
+                            table_ref=plc.expressions.TableReference.RIGHT,
+                            name_to_index={
+                                name: i for i, name in enumerate(inp_right.schema)
+                            },
+                        ),
                     ),
                 )
-                for op, left, right in zip(ops, left_on, right_on, strict=True)
+                for op, left_ne, right_ne in zip(ops, left_on, right_on, strict=True)
             ),
         )
 
@@ -411,7 +469,7 @@ def _(node: pl_ir.Join, translator: Translator, schema: Schema) -> ir.IR:
 
 
 @_translate_ir.register
-def _(node: pl_ir.HStack, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.HStack, translator: Translator, schema: Schema) -> ir.IR:
     with set_node(translator.visitor, node.input):
         inp = translator.translate_ir(n=None)
         exprs = [
@@ -422,7 +480,7 @@ def _(node: pl_ir.HStack, translator: Translator, schema: Schema) -> ir.IR:
 
 @_translate_ir.register
 def _(
-    node: pl_ir.Reduce, translator: Translator, schema: Schema
+    node: plrs._ir_nodes.Reduce, translator: Translator, schema: Schema
 ) -> ir.IR:  # pragma: no cover; polars doesn't emit this node yet
     with set_node(translator.visitor, node.input):
         inp = translator.translate_ir(n=None)
@@ -433,7 +491,7 @@ def _(
 
 
 @_translate_ir.register
-def _(node: pl_ir.Distinct, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.Distinct, translator: Translator, schema: Schema) -> ir.IR:
     (keep, subset, maintain_order, zlice) = node.options
     keep = ir.Distinct._KEEP_MAP[keep]
     subset = frozenset(subset) if subset is not None else None
@@ -448,7 +506,7 @@ def _(node: pl_ir.Distinct, translator: Translator, schema: Schema) -> ir.IR:
 
 
 @_translate_ir.register
-def _(node: pl_ir.Sort, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.Sort, translator: Translator, schema: Schema) -> ir.IR:
     with set_node(translator.visitor, node.input):
         inp = translator.translate_ir(n=None)
         by = [
@@ -463,14 +521,14 @@ def _(node: pl_ir.Sort, translator: Translator, schema: Schema) -> ir.IR:
 
 
 @_translate_ir.register
-def _(node: pl_ir.Slice, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.Slice, translator: Translator, schema: Schema) -> ir.IR:
     return ir.Slice(
         schema, node.offset, node.len, translator.translate_ir(n=node.input)
     )
 
 
 @_translate_ir.register
-def _(node: pl_ir.Filter, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.Filter, translator: Translator, schema: Schema) -> ir.IR:
     with set_node(translator.visitor, node.input):
         inp = translator.translate_ir(n=None)
         mask = translate_named_expr(translator, n=node.predicate, schema=inp.schema)
@@ -478,12 +536,16 @@ def _(node: pl_ir.Filter, translator: Translator, schema: Schema) -> ir.IR:
 
 
 @_translate_ir.register
-def _(node: pl_ir.SimpleProjection, translator: Translator, schema: Schema) -> ir.IR:
+def _(
+    node: plrs._ir_nodes.SimpleProjection, translator: Translator, schema: Schema
+) -> ir.IR:
     return ir.Projection(schema, translator.translate_ir(n=node.input))
 
 
 @_translate_ir.register
-def _(node: pl_ir.MergeSorted, translator: Translator, schema: Schema) -> ir.IR:
+def _(
+    node: plrs._ir_nodes.MergeSorted, translator: Translator, schema: Schema
+) -> ir.IR:
     key = node.key
     inp_left = translator.translate_ir(n=node.input_left)
     inp_right = translator.translate_ir(n=node.input_right)
@@ -496,7 +558,9 @@ def _(node: pl_ir.MergeSorted, translator: Translator, schema: Schema) -> ir.IR:
 
 
 @_translate_ir.register
-def _(node: pl_ir.MapFunction, translator: Translator, schema: Schema) -> ir.IR:
+def _(
+    node: plrs._ir_nodes.MapFunction, translator: Translator, schema: Schema
+) -> ir.IR:
     name, *options = node.function
     return ir.MapFunction(
         schema,
@@ -507,14 +571,14 @@ def _(node: pl_ir.MapFunction, translator: Translator, schema: Schema) -> ir.IR:
 
 
 @_translate_ir.register
-def _(node: pl_ir.Union, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.Union, translator: Translator, schema: Schema) -> ir.IR:
     return ir.Union(
         schema, node.options, *(translator.translate_ir(n=n) for n in node.inputs)
     )
 
 
 @_translate_ir.register
-def _(node: pl_ir.HConcat, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.HConcat, translator: Translator, schema: Schema) -> ir.IR:
     return ir.HConcat(
         schema,
         False,  # noqa: FBT003
@@ -523,7 +587,7 @@ def _(node: pl_ir.HConcat, translator: Translator, schema: Schema) -> ir.IR:
 
 
 @_translate_ir.register
-def _(node: pl_ir.Sink, translator: Translator, schema: Schema) -> ir.IR:
+def _(node: plrs._ir_nodes.Sink, translator: Translator, schema: Schema) -> ir.IR:
     payload = json.loads(node.payload)
     try:
         file = payload["File"]
@@ -556,7 +620,7 @@ def _(node: pl_ir.Sink, translator: Translator, schema: Schema) -> ir.IR:
 
 
 def translate_named_expr(
-    translator: Translator, *, n: pl_expr.PyExprIR, schema: Schema
+    translator: Translator, *, n: plrs._expr_nodes.PyExprIR, schema: Schema
 ) -> expr.NamedExpr:
     """
     Translate a polars-internal named expression IR object into our representation.
@@ -602,15 +666,18 @@ def _translate_expr(
 
 @_translate_expr.register
 def _(
-    node: pl_expr.Function, translator: Translator, dtype: DataType, schema: Schema
+    node: plrs._expr_nodes.Function,
+    translator: Translator,
+    dtype: DataType,
+    schema: Schema,
 ) -> expr.Expr:
     name, *options = node.function_data
     options = tuple(options)
-    if isinstance(name, pl_expr.StringFunction):
+    if isinstance(name, plrs._expr_nodes.StringFunction):
         if name in {
-            pl_expr.StringFunction.StripChars,
-            pl_expr.StringFunction.StripCharsStart,
-            pl_expr.StringFunction.StripCharsEnd,
+            plrs._expr_nodes.StringFunction.StripChars,
+            plrs._expr_nodes.StringFunction.StripCharsStart,
+            plrs._expr_nodes.StringFunction.StripCharsEnd,
         }:
             column, chars = (
                 translator.translate_expr(n=n, schema=schema) for n in node.input
@@ -639,8 +706,8 @@ def _(
             options,
             *(translator.translate_expr(n=n, schema=schema) for n in node.input),
         )
-    elif isinstance(name, pl_expr.BooleanFunction):
-        if name == pl_expr.BooleanFunction.IsBetween:
+    elif isinstance(name, plrs._expr_nodes.BooleanFunction):
+        if name == plrs._expr_nodes.BooleanFunction.IsBetween:
             column, lo, hi = (
                 translator.translate_expr(n=n, schema=schema) for n in node.input
             )
@@ -658,19 +725,19 @@ def _(
             options,
             *(translator.translate_expr(n=n, schema=schema) for n in node.input),
         )
-    elif isinstance(name, pl_expr.TemporalFunction):
+    elif isinstance(name, plrs._expr_nodes.TemporalFunction):
         # functions for which evaluation of the expression may not return
         # the same dtype as polars, either due to libcudf returning a different
         # dtype, or due to our internal processing affecting what libcudf returns
         needs_cast = {
-            pl_expr.TemporalFunction.Year,
-            pl_expr.TemporalFunction.Month,
-            pl_expr.TemporalFunction.Day,
-            pl_expr.TemporalFunction.WeekDay,
-            pl_expr.TemporalFunction.Hour,
-            pl_expr.TemporalFunction.Minute,
-            pl_expr.TemporalFunction.Second,
-            pl_expr.TemporalFunction.Millisecond,
+            plrs._expr_nodes.TemporalFunction.Year,
+            plrs._expr_nodes.TemporalFunction.Month,
+            plrs._expr_nodes.TemporalFunction.Day,
+            plrs._expr_nodes.TemporalFunction.WeekDay,
+            plrs._expr_nodes.TemporalFunction.Hour,
+            plrs._expr_nodes.TemporalFunction.Minute,
+            plrs._expr_nodes.TemporalFunction.Second,
+            plrs._expr_nodes.TemporalFunction.Millisecond,
         }
         result_expr = expr.TemporalFunction(
             dtype,
@@ -679,9 +746,11 @@ def _(
             *(translator.translate_expr(n=n, schema=schema) for n in node.input),
         )
         if name in needs_cast:
-            return expr.Cast(dtype, result_expr)
+            return expr.Cast(dtype, True, result_expr)  # noqa: FBT003
         return result_expr
-    elif not POLARS_VERSION_LT_131 and isinstance(name, pl_expr.StructFunction):
+    elif not POLARS_VERSION_LT_131 and isinstance(
+        name, plrs._expr_nodes.StructFunction
+    ):
         return expr.StructFunction(
             dtype,
             expr.StructFunction.Name.from_polars(name),
@@ -690,15 +759,38 @@ def _(
         )
     elif isinstance(name, str):
         children = (translator.translate_expr(n=n, schema=schema) for n in node.input)
-        if name == "log":
-            (base,) = options
-            (child,) = children
-            return expr.BinOp(
-                dtype,
-                plc.binaryop.BinaryOperator.LOG_BASE,
-                child,
-                expr.Literal(dtype, base),
-            )
+        if name == "log" or (
+            not POLARS_VERSION_LT_133
+            and name == "l"
+            and isinstance(options[0], str)
+            and "".join((name, *options)) == "log"
+        ):
+            if POLARS_VERSION_LT_133:  # pragma: no cover
+                (base,) = options
+                (child,) = children
+                return expr.BinOp(
+                    dtype,
+                    plc.binaryop.BinaryOperator.LOG_BASE,
+                    child,
+                    expr.Literal(dtype, base),
+                )
+            else:
+                (child, base) = children
+                res = expr.BinOp(
+                    dtype,
+                    plc.binaryop.BinaryOperator.LOG_BASE,
+                    child,
+                    expr.Literal(dtype, base.value),
+                )
+                return (
+                    res
+                    if not POLARS_VERSION_LT_134
+                    else expr.Cast(
+                        DataType(pl.Float64()),
+                        True,  # noqa: FBT003
+                        res,
+                    )
+                )
         elif name == "pow":
             return expr.BinOp(dtype, plc.binaryop.BinaryOperator.POW, *children)
         return expr.UnaryFunction(dtype, name, options, *children)
@@ -709,11 +801,15 @@ def _(
 
 @_translate_expr.register
 def _(
-    node: pl_expr.Window, translator: Translator, dtype: DataType, schema: Schema
+    node: plrs._expr_nodes.Window,
+    translator: Translator,
+    dtype: DataType,
+    schema: Schema,
 ) -> expr.Expr:
-    if isinstance(node.options, pl_expr.RollingGroupOptions):
+    if isinstance(node.options, plrs._expr_nodes.RollingGroupOptions):
         # pl.col("a").rolling(...)
-        agg = translator.translate_expr(n=node.function, schema=schema)
+        with set_expr_context(translator, ExecutionContext.ROLLING):
+            agg = translator.translate_expr(n=node.function, schema=schema)
         name_generator = unique_names(schema)
         aggs, named_post_agg = decompose_single_agg(
             expr.NamedExpr(next(name_generator), agg),
@@ -723,7 +819,7 @@ def _(
         )
         named_aggs = [agg for agg, _ in aggs]
         orderby = node.options.index_column
-        orderby_dtype = schema[orderby].plc
+        orderby_dtype = schema[orderby].plc_type
         if plc.traits.is_integral(orderby_dtype):
             # Integer orderby column is cast in implementation to int64 in polars
             orderby_dtype = plc.DataType(plc.TypeId.INT64)
@@ -752,9 +848,10 @@ def _(
             for agg in named_aggs
         }
         return replace([named_post_agg.value], replacements)[0]
-    elif isinstance(node.options, pl_expr.WindowMapping):
+    elif isinstance(node.options, plrs._expr_nodes.WindowMapping):
         # pl.col("a").over(...)
-        agg = translator.translate_expr(n=node.function, schema=schema)
+        with set_expr_context(translator, ExecutionContext.WINDOW):
+            agg = translator.translate_expr(n=node.function, schema=schema)
         name_gen = unique_names(schema)
         aggs, post = decompose_single_agg(
             expr.NamedExpr(next(name_gen), agg),
@@ -779,20 +876,41 @@ def _(
             if has_order_by
             else None
         )
+
+        named_aggs = [agg for agg, _ in aggs]
+
+        by_exprs = [
+            translator.translate_expr(n=n, schema=schema) for n in node.partition_by
+        ]
+
+        child_deps = [
+            v.children[0]
+            for ne in named_aggs
+            for v in (ne.value,)
+            if isinstance(v, expr.Agg)
+            or (
+                isinstance(v, expr.UnaryFunction)
+                and v.name in {"rank", "fill_null_with_strategy", "cum_sum"}
+            )
+        ]
+        children = (*by_exprs, *((order_by_expr,) if has_order_by else ()), *child_deps)
         return expr.GroupedRollingWindow(
             dtype,
             (mapping, has_order_by, descending, nulls_last),
-            [agg for agg, _ in aggs],
+            named_aggs,
             post,
-            *(translator.translate_expr(n=n, schema=schema) for n in node.partition_by),
-            _order_by_expr=order_by_expr,
+            len(by_exprs),
+            *children,
         )
     assert_never(node.options)
 
 
 @_translate_expr.register
 def _(
-    node: pl_expr.Literal, translator: Translator, dtype: DataType, schema: Schema
+    node: plrs._expr_nodes.Literal,
+    translator: Translator,
+    dtype: DataType,
+    schema: Schema,
 ) -> expr.Expr:
     if isinstance(node.value, plrs.PySeries):
         return expr.LiteralColumn(dtype, pl.Series._from_pyseries(node.value))
@@ -804,7 +922,7 @@ def _(
 
 @_translate_expr.register
 def _(
-    node: pl_expr.Sort, translator: Translator, dtype: DataType, schema: Schema
+    node: plrs._expr_nodes.Sort, translator: Translator, dtype: DataType, schema: Schema
 ) -> expr.Expr:
     # TODO: raise in groupby
     return expr.Sort(
@@ -814,7 +932,10 @@ def _(
 
 @_translate_expr.register
 def _(
-    node: pl_expr.SortBy, translator: Translator, dtype: DataType, schema: Schema
+    node: plrs._expr_nodes.SortBy,
+    translator: Translator,
+    dtype: DataType,
+    schema: Schema,
 ) -> expr.Expr:
     options = node.sort_options
     return expr.SortBy(
@@ -827,7 +948,10 @@ def _(
 
 @_translate_expr.register
 def _(
-    node: pl_expr.Slice, translator: Translator, dtype: DataType, schema: Schema
+    node: plrs._expr_nodes.Slice,
+    translator: Translator,
+    dtype: DataType,
+    schema: Schema,
 ) -> expr.Expr:
     offset = translator.translate_expr(n=node.offset, schema=schema)
     length = translator.translate_expr(n=node.length, schema=schema)
@@ -843,7 +967,10 @@ def _(
 
 @_translate_expr.register
 def _(
-    node: pl_expr.Gather, translator: Translator, dtype: DataType, schema: Schema
+    node: plrs._expr_nodes.Gather,
+    translator: Translator,
+    dtype: DataType,
+    schema: Schema,
 ) -> expr.Expr:
     return expr.Gather(
         dtype,
@@ -854,7 +981,10 @@ def _(
 
 @_translate_expr.register
 def _(
-    node: pl_expr.Filter, translator: Translator, dtype: DataType, schema: Schema
+    node: plrs._expr_nodes.Filter,
+    translator: Translator,
+    dtype: DataType,
+    schema: Schema,
 ) -> expr.Expr:
     return expr.Filter(
         dtype,
@@ -865,44 +995,70 @@ def _(
 
 @_translate_expr.register
 def _(
-    node: pl_expr.Cast, translator: Translator, dtype: DataType, schema: Schema
+    node: plrs._expr_nodes.Cast, translator: Translator, dtype: DataType, schema: Schema
 ) -> expr.Expr:
+    # TODO: node.options can be 2 meaning wrap_numerical=True
+    # don't necessarily raise because wrapping isn't always needed, but it's unhandled
+    strict = node.options != 1
     inner = translator.translate_expr(n=node.expr, schema=schema)
+
+    if plc.traits.is_floating_point(inner.dtype.plc_type) and plc.traits.is_fixed_point(
+        dtype.plc_type
+    ):
+        return expr.Cast(
+            dtype,
+            strict,
+            expr.UnaryFunction(
+                inner.dtype, "round", (-dtype.plc_type.scale(), "half_to_even"), inner
+            ),
+        )
+
     # Push casts into literals so we can handle Cast(Literal(Null))
     if isinstance(inner, expr.Literal):
         return inner.astype(dtype)
-    elif isinstance(inner, expr.Cast):
-        # Translation of Len/Count-agg put in a cast, remove double
-        # casts if we have one.
-        (inner,) = inner.children
-    return expr.Cast(dtype, inner)
+    else:
+        return expr.Cast(dtype, strict, inner)
 
 
 @_translate_expr.register
 def _(
-    node: pl_expr.Column, translator: Translator, dtype: DataType, schema: Schema
+    node: plrs._expr_nodes.Column,
+    translator: Translator,
+    dtype: DataType,
+    schema: Schema,
 ) -> expr.Expr:
     return expr.Col(dtype, node.name)
 
 
 @_translate_expr.register
 def _(
-    node: pl_expr.Agg, translator: Translator, dtype: DataType, schema: Schema
+    node: plrs._expr_nodes.Agg, translator: Translator, dtype: DataType, schema: Schema
 ) -> expr.Expr:
-    value = expr.Agg(
-        dtype,
-        node.name,
-        node.options,
-        *(translator.translate_expr(n=n, schema=schema) for n in node.arguments),
-    )
-    if value.name in ("count", "n_unique") and value.dtype.id() != plc.TypeId.INT32:
-        return expr.Cast(value.dtype, value)
+    agg_name = node.name
+    args = [translator.translate_expr(n=arg, schema=schema) for arg in node.arguments]
+
+    if agg_name not in ("count", "n_unique", "mean", "median", "quantile"):
+        args = [
+            expr.Cast(dtype, True, arg)  # noqa: FBT003
+            if plc.traits.is_fixed_point(arg.dtype.plc_type)
+            and arg.dtype.plc_type != dtype.plc_type
+            else arg
+            for arg in args
+        ]
+
+    value = expr.Agg(dtype, agg_name, node.options, translator._expr_context, *args)
+
+    if agg_name in ("count", "n_unique") and value.dtype.id() != plc.TypeId.INT32:
+        return expr.Cast(value.dtype, True, value)  # noqa: FBT003
     return value
 
 
 @_translate_expr.register
 def _(
-    node: pl_expr.Ternary, translator: Translator, dtype: DataType, schema: Schema
+    node: plrs._expr_nodes.Ternary,
+    translator: Translator,
+    dtype: DataType,
+    schema: Schema,
 ) -> expr.Expr:
     return expr.Ternary(
         dtype,
@@ -914,26 +1070,70 @@ def _(
 
 @_translate_expr.register
 def _(
-    node: pl_expr.BinaryExpr,
+    node: plrs._expr_nodes.BinaryExpr,
     translator: Translator,
     dtype: DataType,
     schema: Schema,
 ) -> expr.Expr:
-    if plc.traits.is_boolean(dtype.plc) and node.op == pl_expr.Operator.TrueDivide:
-        dtype = DataType(pl.Float64())
+    left = translator.translate_expr(n=node.left, schema=schema)
+    right = translator.translate_expr(n=node.right, schema=schema)
+    if (
+        POLARS_VERSION_LT_133
+        and plc.traits.is_boolean(dtype.plc_type)
+        and node.op == plrs._expr_nodes.Operator.TrueDivide
+    ):
+        dtype = DataType(pl.Float64())  # pragma: no cover
+    if node.op == plrs._expr_nodes.Operator.TrueDivide and (
+        plc.traits.is_fixed_point(left.dtype.plc_type)
+        or plc.traits.is_fixed_point(right.dtype.plc_type)
+    ):
+        f64 = DataType(pl.Float64())
+        return expr.Cast(
+            dtype,
+            True,  # noqa: FBT003
+            expr.BinOp(
+                f64,
+                expr.BinOp._MAPPING[node.op],
+                expr.Cast(f64, True, left),  # noqa: FBT003
+                expr.Cast(f64, True, right),  # noqa: FBT003
+            ),
+        )
+
+    if (
+        not POLARS_VERSION_LT_134
+        and node.op == plrs._expr_nodes.Operator.Multiply
+        and plc.traits.is_fixed_point(left.dtype.plc_type)
+        and plc.traits.is_fixed_point(right.dtype.plc_type)
+    ):
+        left_scale = -left.dtype.plc_type.scale()
+        right_scale = -right.dtype.plc_type.scale()
+        out_scale = max(left_scale, right_scale)
+
+        return expr.UnaryFunction(
+            DataType(pl.Decimal(38, out_scale)),
+            "round",
+            (out_scale, "half_to_even"),
+            expr.BinOp(
+                DataType(pl.Decimal(38, left_scale + right_scale)),
+                expr.BinOp._MAPPING[node.op],
+                left,
+                right,
+            ),
+        )
+
     return expr.BinOp(
         dtype,
         expr.BinOp._MAPPING[node.op],
-        translator.translate_expr(n=node.left, schema=schema),
-        translator.translate_expr(n=node.right, schema=schema),
+        left,
+        right,
     )
 
 
 @_translate_expr.register
 def _(
-    node: pl_expr.Len, translator: Translator, dtype: DataType, schema: Schema
+    node: plrs._expr_nodes.Len, translator: Translator, dtype: DataType, schema: Schema
 ) -> expr.Expr:
     value = expr.Len(dtype)
     if dtype.id() != plc.TypeId.INT32:
-        return expr.Cast(dtype, value)
+        return expr.Cast(dtype, True, value)  # noqa: FBT003
     return value  # pragma: no cover; never reached since polars len has uint32 dtype