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

cudf_polars/dsl/expressions/boolean.py

@@ -0,0 +1,326 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES.
+# SPDX-License-Identifier: Apache-2.0
+# TODO: Document BooleanFunction to remove noqa
+# ruff: noqa: D101
+"""Boolean DSL nodes."""
+
+from __future__ import annotations
+
+from enum import IntEnum, auto
+from functools import partial, reduce
+from typing import TYPE_CHECKING, Any, ClassVar
+
+import pylibcudf as plc
+
+from cudf_polars.containers import Column, DataType
+from cudf_polars.dsl.expressions.base import (
+    ExecutionContext,
+    Expr,
+)
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    import polars.type_aliases as pl_types
+    from polars.polars import _expr_nodes as pl_expr
+
+    from cudf_polars.containers import DataFrame
+
+__all__ = ["BooleanFunction"]
+
+
+class BooleanFunction(Expr):
+    class Name(IntEnum):
+        """Internal and picklable representation of polars' `BooleanFunction`."""
+
+        All = auto()
+        AllHorizontal = auto()
+        Any = auto()
+        AnyHorizontal = auto()
+        IsBetween = auto()
+        IsClose = auto()
+        IsDuplicated = auto()
+        IsFinite = auto()
+        IsFirstDistinct = auto()
+        IsIn = auto()
+        IsInfinite = auto()
+        IsLastDistinct = auto()
+        IsNan = auto()
+        IsNotNan = auto()
+        IsNotNull = auto()
+        IsNull = auto()
+        IsUnique = auto()
+        Not = auto()
+
+        @classmethod
+        def from_polars(cls, obj: pl_expr.BooleanFunction) -> Self:
+            """Convert from polars' `BooleanFunction`."""
+            try:
+                function, name = str(obj).split(".", maxsplit=1)
+            except ValueError:
+                # Failed to unpack string
+                function = None
+            if function != "BooleanFunction":
+                raise ValueError("BooleanFunction required")
+            return getattr(cls, name)
+
+    __slots__ = ("name", "options")
+    _non_child = ("dtype", "name", "options")
+
+    def __init__(
+        self,
+        dtype: DataType,
+        name: BooleanFunction.Name,
+        options: tuple[Any, ...],
+        *children: Expr,
+    ) -> None:
+        self.dtype = dtype
+        self.options = options
+        self.name = name
+        self.children = children
+        self.is_pointwise = self.name not in (
+            BooleanFunction.Name.All,
+            BooleanFunction.Name.Any,
+            BooleanFunction.Name.IsDuplicated,
+            BooleanFunction.Name.IsFirstDistinct,
+            BooleanFunction.Name.IsLastDistinct,
+            BooleanFunction.Name.IsUnique,
+        )
+        if self.name in {
+            BooleanFunction.Name.IsClose,
+        }:
+            raise NotImplementedError(
+                f"Boolean function {self.name}"
+            )  # pragma: no cover
+
+    @staticmethod
+    def _distinct(
+        column: Column,
+        dtype: DataType,
+        *,
+        keep: plc.stream_compaction.DuplicateKeepOption,
+        source_value: plc.Scalar,
+        target_value: plc.Scalar,
+    ) -> Column:
+        table = plc.Table([column.obj])
+        indices = plc.stream_compaction.distinct_indices(
+            table,
+            keep,
+            # TODO: polars doesn't expose options for these
+            plc.types.NullEquality.EQUAL,
+            plc.types.NanEquality.ALL_EQUAL,
+        )
+        return Column(
+            plc.copying.scatter(
+                [source_value],
+                indices,
+                plc.Table([plc.Column.from_scalar(target_value, table.num_rows())]),
+            ).columns()[0],
+            dtype=dtype,
+        )
+
+    _BETWEEN_OPS: ClassVar[
+        dict[
+            pl_types.ClosedInterval,
+            tuple[plc.binaryop.BinaryOperator, plc.binaryop.BinaryOperator],
+        ]
+    ] = {
+        "none": (
+            plc.binaryop.BinaryOperator.GREATER,
+            plc.binaryop.BinaryOperator.LESS,
+        ),
+        "left": (
+            plc.binaryop.BinaryOperator.GREATER_EQUAL,
+            plc.binaryop.BinaryOperator.LESS,
+        ),
+        "right": (
+            plc.binaryop.BinaryOperator.GREATER,
+            plc.binaryop.BinaryOperator.LESS_EQUAL,
+        ),
+        "both": (
+            plc.binaryop.BinaryOperator.GREATER_EQUAL,
+            plc.binaryop.BinaryOperator.LESS_EQUAL,
+        ),
+    }
+
+    def do_evaluate(
+        self, df: DataFrame, *, context: ExecutionContext = ExecutionContext.FRAME
+    ) -> Column:
+        """Evaluate this expression given a dataframe for context."""
+        if self.name in (
+            BooleanFunction.Name.IsFinite,
+            BooleanFunction.Name.IsInfinite,
+        ):
+            # Avoid evaluating the child if the dtype tells us it's unnecessary.
+            (child,) = self.children
+            needles = child.evaluate(df, context=context)
+            is_float = needles.obj.type().id() in (
+                plc.TypeId.FLOAT32,
+                plc.TypeId.FLOAT64,
+            )
+            is_finite = self.name is BooleanFunction.Name.IsFinite
+            if not is_float:
+                base = plc.Column.from_scalar(
+                    plc.Scalar.from_py(py_val=is_finite), needles.size
+                )
+                out = base.with_mask(needles.obj.null_mask(), needles.null_count)
+                return Column(out, dtype=self.dtype)
+            to_search = [-float("inf"), float("inf")]
+            if is_finite:
+                # NaN is neither finite not infinite
+                to_search.append(float("nan"))
+            haystack = plc.Column.from_iterable_of_py(
+                to_search,
+                dtype=needles.obj.type(),
+            )
+            result = plc.search.contains(haystack, needles.obj)
+            if is_finite:
+                result = plc.unary.unary_operation(result, plc.unary.UnaryOperator.NOT)
+            return Column(
+                result.with_mask(needles.obj.null_mask(), needles.null_count),
+                dtype=self.dtype,
+            )
+        columns = [child.evaluate(df, context=context) for child in self.children]
+        # Kleene logic for Any (OR) and All (AND) if ignore_nulls is
+        # False
+        if self.name in (BooleanFunction.Name.Any, BooleanFunction.Name.All):
+            (ignore_nulls,) = self.options
+            (column,) = columns
+            is_any = self.name is BooleanFunction.Name.Any
+            agg = plc.aggregation.any() if is_any else plc.aggregation.all()
+            result = plc.reduce.reduce(column.obj, agg, self.dtype.plc)
+            if not ignore_nulls and column.null_count > 0:
+                #      Truth tables
+                #     Any         All
+                #   | F U T     | F U T
+                # --+------   --+------
+                # F | F U T   F | F F F
+                # U | U U T   U | F U U
+                # T | T T T   T | F U T
+                #
+                # If the input null count was non-zero, we must
+                # post-process the result to insert the correct value.
+                h_result = result.to_py()
+                if (is_any and not h_result) or (not is_any and h_result):
+                    # Any                     All
+                    # False || Null => Null   True && Null => Null
+                    return Column(
+                        plc.Column.all_null_like(column.obj, 1), dtype=self.dtype
+                    )
+            return Column(plc.Column.from_scalar(result, 1), dtype=self.dtype)
+        if self.name is BooleanFunction.Name.IsNull:
+            (column,) = columns
+            return Column(plc.unary.is_null(column.obj), dtype=self.dtype)
+        elif self.name is BooleanFunction.Name.IsNotNull:
+            (column,) = columns
+            return Column(plc.unary.is_valid(column.obj), dtype=self.dtype)
+        elif self.name in (BooleanFunction.Name.IsNan, BooleanFunction.Name.IsNotNan):
+            (column,) = columns
+            is_float = column.obj.type().id() in (
+                plc.TypeId.FLOAT32,
+                plc.TypeId.FLOAT64,
+            )
+            if is_float:
+                op = (
+                    plc.unary.is_nan
+                    if self.name is BooleanFunction.Name.IsNan
+                    else plc.unary.is_not_nan
+                )
+                base = op(column.obj)
+            else:
+                base = plc.Column.from_scalar(
+                    plc.Scalar.from_py(
+                        py_val=self.name is not BooleanFunction.Name.IsNan
+                    ),
+                    column.size,
+                )
+            out = base.with_mask(column.obj.null_mask(), column.null_count)
+            return Column(out, dtype=self.dtype)
+        elif self.name is BooleanFunction.Name.IsFirstDistinct:
+            (column,) = columns
+            return self._distinct(
+                column,
+                dtype=self.dtype,
+                keep=plc.stream_compaction.DuplicateKeepOption.KEEP_FIRST,
+                source_value=plc.Scalar.from_py(py_val=True, dtype=self.dtype.plc),
+                target_value=plc.Scalar.from_py(py_val=False, dtype=self.dtype.plc),
+            )
+        elif self.name is BooleanFunction.Name.IsLastDistinct:
+            (column,) = columns
+            return self._distinct(
+                column,
+                dtype=self.dtype,
+                keep=plc.stream_compaction.DuplicateKeepOption.KEEP_LAST,
+                source_value=plc.Scalar.from_py(py_val=True, dtype=self.dtype.plc),
+                target_value=plc.Scalar.from_py(py_val=False, dtype=self.dtype.plc),
+            )
+        elif self.name is BooleanFunction.Name.IsUnique:
+            (column,) = columns
+            return self._distinct(
+                column,
+                dtype=self.dtype,
+                keep=plc.stream_compaction.DuplicateKeepOption.KEEP_NONE,
+                source_value=plc.Scalar.from_py(py_val=True, dtype=self.dtype.plc),
+                target_value=plc.Scalar.from_py(py_val=False, dtype=self.dtype.plc),
+            )
+        elif self.name is BooleanFunction.Name.IsDuplicated:
+            (column,) = columns
+            return self._distinct(
+                column,
+                dtype=self.dtype,
+                keep=plc.stream_compaction.DuplicateKeepOption.KEEP_NONE,
+                source_value=plc.Scalar.from_py(py_val=False, dtype=self.dtype.plc),
+                target_value=plc.Scalar.from_py(py_val=True, dtype=self.dtype.plc),
+            )
+        elif self.name is BooleanFunction.Name.AllHorizontal:
+            return Column(
+                reduce(
+                    partial(
+                        plc.binaryop.binary_operation,
+                        op=plc.binaryop.BinaryOperator.NULL_LOGICAL_AND,
+                        output_type=self.dtype.plc,
+                    ),
+                    (c.obj for c in columns),
+                ),
+                dtype=self.dtype,
+            )
+        elif self.name is BooleanFunction.Name.AnyHorizontal:
+            return Column(
+                reduce(
+                    partial(
+                        plc.binaryop.binary_operation,
+                        op=plc.binaryop.BinaryOperator.NULL_LOGICAL_OR,
+                        output_type=self.dtype.plc,
+                    ),
+                    (c.obj for c in columns),
+                ),
+                dtype=self.dtype,
+            )
+        elif self.name is BooleanFunction.Name.IsIn:
+            needles, haystack = columns
+            if haystack.obj.type().id() == plc.TypeId.LIST:
+                # Unwrap values from the list column
+                # the type: ignore is safe because we know that the type ID is LIST,
+                # which always has an inner attribute.
+                haystack = Column(
+                    haystack.obj.children()[1],
+                    dtype=DataType(haystack.dtype.polars.inner),  # type: ignore[attr-defined]
+                ).astype(needles.dtype)
+            if haystack.size:
+                return Column(
+                    plc.search.contains(haystack.obj, needles.obj), dtype=self.dtype
+                )
+            return Column(
+                plc.Column.from_scalar(plc.Scalar.from_py(py_val=False), needles.size),
+                dtype=self.dtype,
+            )
+        elif self.name is BooleanFunction.Name.Not:
+            (column,) = columns
+            return Column(
+                plc.unary.unary_operation(column.obj, plc.unary.UnaryOperator.NOT),
+                dtype=self.dtype,
+            )
+        else:
+            raise NotImplementedError(
+                f"BooleanFunction {self.name}"
+            )  # pragma: no cover; handled by init raising

cudf_polars/dsl/expressions/datetime.py

@@ -0,0 +1,271 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES.
+# SPDX-License-Identifier: Apache-2.0
+# TODO: Document TemporalFunction to remove noqa
+# ruff: noqa: D101
+"""DSL nodes for datetime operations."""
+
+from __future__ import annotations
+
+from enum import IntEnum, auto
+from typing import TYPE_CHECKING, Any, ClassVar
+
+import pylibcudf as plc
+
+from cudf_polars.containers import Column
+from cudf_polars.dsl.expressions.base import ExecutionContext, Expr
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from polars.polars import _expr_nodes as pl_expr
+
+    from cudf_polars.containers import DataFrame, DataType
+
+__all__ = ["TemporalFunction"]
+
+
+class TemporalFunction(Expr):
+    class Name(IntEnum):
+        """Internal and picklable representation of polars' `TemporalFunction`."""
+
+        BaseUtcOffset = auto()
+        CastTimeUnit = auto()
+        Century = auto()
+        Combine = auto()
+        ConvertTimeZone = auto()
+        DSTOffset = auto()
+        Date = auto()
+        Datetime = auto()
+        DatetimeFunction = auto()
+        Day = auto()
+        DaysInMonth = auto()
+        Duration = auto()
+        Hour = auto()
+        IsLeapYear = auto()
+        IsoYear = auto()
+        Microsecond = auto()
+        Millennium = auto()
+        Millisecond = auto()
+        Minute = auto()
+        Month = auto()
+        MonthEnd = auto()
+        MonthStart = auto()
+        Nanosecond = auto()
+        OffsetBy = auto()
+        OrdinalDay = auto()
+        Quarter = auto()
+        Replace = auto()
+        ReplaceTimeZone = auto()
+        Round = auto()
+        Second = auto()
+        Time = auto()
+        TimeStamp = auto()
+        ToString = auto()
+        TotalDays = auto()
+        TotalHours = auto()
+        TotalMicroseconds = auto()
+        TotalMilliseconds = auto()
+        TotalMinutes = auto()
+        TotalNanoseconds = auto()
+        TotalSeconds = auto()
+        Truncate = auto()
+        Week = auto()
+        WeekDay = auto()
+        WithTimeUnit = auto()
+        Year = auto()
+
+        @classmethod
+        def from_polars(cls, obj: pl_expr.TemporalFunction) -> Self:
+            """Convert from polars' `TemporalFunction`."""
+            try:
+                function, name = str(obj).split(".", maxsplit=1)
+            except ValueError:
+                # Failed to unpack string
+                function = None
+            if function != "TemporalFunction":
+                raise ValueError("TemporalFunction required")
+            return getattr(cls, name)
+
+    __slots__ = ("name", "options")
+    _non_child = ("dtype", "name", "options")
+    _COMPONENT_MAP: ClassVar[dict[Name, plc.datetime.DatetimeComponent]] = {
+        Name.Year: plc.datetime.DatetimeComponent.YEAR,
+        Name.Month: plc.datetime.DatetimeComponent.MONTH,
+        Name.Day: plc.datetime.DatetimeComponent.DAY,
+        Name.WeekDay: plc.datetime.DatetimeComponent.WEEKDAY,
+        Name.Hour: plc.datetime.DatetimeComponent.HOUR,
+        Name.Minute: plc.datetime.DatetimeComponent.MINUTE,
+        Name.Second: plc.datetime.DatetimeComponent.SECOND,
+        Name.Millisecond: plc.datetime.DatetimeComponent.MILLISECOND,
+        Name.Microsecond: plc.datetime.DatetimeComponent.MICROSECOND,
+        Name.Nanosecond: plc.datetime.DatetimeComponent.NANOSECOND,
+    }
+
+    _valid_ops: ClassVar[set[Name]] = {
+        *_COMPONENT_MAP.keys(),
+        Name.IsLeapYear,
+        Name.OrdinalDay,
+        Name.ToString,
+        Name.Week,
+        Name.IsoYear,
+        Name.MonthStart,
+        Name.MonthEnd,
+        Name.CastTimeUnit,
+    }
+
+    def __init__(
+        self,
+        dtype: DataType,
+        name: TemporalFunction.Name,
+        options: tuple[Any, ...],
+        *children: Expr,
+    ) -> None:
+        self.dtype = dtype
+        self.options = options
+        self.name = name
+        self.children = children
+        self.is_pointwise = True
+        if self.name not in self._valid_ops:
+            raise NotImplementedError(f"Temporal function {self.name}")
+
+        if self.name is TemporalFunction.Name.ToString and plc.traits.is_duration(
+            self.children[0].dtype.plc
+        ):
+            raise NotImplementedError("ToString is not supported on duration types")
+
+    def do_evaluate(
+        self, df: DataFrame, *, context: ExecutionContext = ExecutionContext.FRAME
+    ) -> Column:
+        """Evaluate this expression given a dataframe for context."""
+        columns = [child.evaluate(df, context=context) for child in self.children]
+        (column,) = columns
+        if self.name is TemporalFunction.Name.CastTimeUnit:
+            return Column(plc.unary.cast(column.obj, self.dtype.plc), dtype=self.dtype)
+        if self.name == TemporalFunction.Name.ToString:
+            return Column(
+                plc.strings.convert.convert_datetime.from_timestamps(
+                    column.obj,
+                    self.options[0],
+                    plc.Column.from_iterable_of_py([], dtype=self.dtype.plc),
+                ),
+                dtype=self.dtype,
+            )
+        if self.name is TemporalFunction.Name.Week:
+            result = plc.strings.convert.convert_integers.to_integers(
+                plc.strings.convert.convert_datetime.from_timestamps(
+                    column.obj,
+                    format="%V",
+                    input_strings_names=plc.Column.from_iterable_of_py(
+                        [], dtype=plc.DataType(plc.TypeId.STRING)
+                    ),
+                ),
+                self.dtype.plc,
+            )
+            return Column(result, dtype=self.dtype)
+        if self.name is TemporalFunction.Name.IsoYear:
+            result = plc.strings.convert.convert_integers.to_integers(
+                plc.strings.convert.convert_datetime.from_timestamps(
+                    column.obj,
+                    format="%G",
+                    input_strings_names=plc.Column.from_iterable_of_py(
+                        [], dtype=plc.DataType(plc.TypeId.STRING)
+                    ),
+                ),
+                self.dtype.plc,
+            )
+            return Column(result, dtype=self.dtype)
+        if self.name is TemporalFunction.Name.MonthStart:
+            ends = plc.datetime.last_day_of_month(column.obj)
+            days_to_subtract = plc.datetime.days_in_month(column.obj)
+            # must subtract 1 to avoid rolling over to the previous month
+            days_to_subtract = plc.binaryop.binary_operation(
+                days_to_subtract,
+                plc.Scalar.from_py(1, plc.DataType(plc.TypeId.INT32)),
+                plc.binaryop.BinaryOperator.SUB,
+                plc.DataType(plc.TypeId.DURATION_DAYS),
+            )
+            result = plc.binaryop.binary_operation(
+                ends,
+                days_to_subtract,
+                plc.binaryop.BinaryOperator.SUB,
+                self.dtype.plc,
+            )
+
+            return Column(result, dtype=self.dtype)
+        if self.name is TemporalFunction.Name.MonthEnd:
+            return Column(
+                plc.unary.cast(
+                    plc.datetime.last_day_of_month(column.obj), self.dtype.plc
+                ),
+                dtype=self.dtype,
+            )
+        if self.name is TemporalFunction.Name.IsLeapYear:
+            return Column(
+                plc.datetime.is_leap_year(column.obj),
+                dtype=self.dtype,
+            )
+        if self.name is TemporalFunction.Name.OrdinalDay:
+            return Column(plc.datetime.day_of_year(column.obj), dtype=self.dtype)
+        if self.name is TemporalFunction.Name.Microsecond:
+            millis = plc.datetime.extract_datetime_component(
+                column.obj, plc.datetime.DatetimeComponent.MILLISECOND
+            )
+            micros = plc.datetime.extract_datetime_component(
+                column.obj, plc.datetime.DatetimeComponent.MICROSECOND
+            )
+            millis_as_micros = plc.binaryop.binary_operation(
+                millis,
+                plc.Scalar.from_py(1_000, plc.DataType(plc.TypeId.INT32)),
+                plc.binaryop.BinaryOperator.MUL,
+                self.dtype.plc,
+            )
+            total_micros = plc.binaryop.binary_operation(
+                micros,
+                millis_as_micros,
+                plc.binaryop.BinaryOperator.ADD,
+                self.dtype.plc,
+            )
+            return Column(total_micros, dtype=self.dtype)
+        elif self.name is TemporalFunction.Name.Nanosecond:
+            millis = plc.datetime.extract_datetime_component(
+                column.obj, plc.datetime.DatetimeComponent.MILLISECOND
+            )
+            micros = plc.datetime.extract_datetime_component(
+                column.obj, plc.datetime.DatetimeComponent.MICROSECOND
+            )
+            nanos = plc.datetime.extract_datetime_component(
+                column.obj, plc.datetime.DatetimeComponent.NANOSECOND
+            )
+            millis_as_nanos = plc.binaryop.binary_operation(
+                millis,
+                plc.Scalar.from_py(1_000_000, plc.DataType(plc.TypeId.INT32)),
+                plc.binaryop.BinaryOperator.MUL,
+                self.dtype.plc,
+            )
+            micros_as_nanos = plc.binaryop.binary_operation(
+                micros,
+                plc.Scalar.from_py(1_000, plc.DataType(plc.TypeId.INT32)),
+                plc.binaryop.BinaryOperator.MUL,
+                self.dtype.plc,
+            )
+            total_nanos = plc.binaryop.binary_operation(
+                nanos,
+                millis_as_nanos,
+                plc.binaryop.BinaryOperator.ADD,
+                self.dtype.plc,
+            )
+            total_nanos = plc.binaryop.binary_operation(
+                total_nanos,
+                micros_as_nanos,
+                plc.binaryop.BinaryOperator.ADD,
+                self.dtype.plc,
+            )
+            return Column(total_nanos, dtype=self.dtype)
+
+        return Column(
+            plc.datetime.extract_datetime_component(
+                column.obj,
+                self._COMPONENT_MAP[self.name],
+            ),
+            dtype=self.dtype,
+        )

cudf_polars/dsl/expressions/literal.py

@@ -0,0 +1,97 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES.
+# SPDX-License-Identifier: Apache-2.0
+# TODO: remove need for this
+# ruff: noqa: D101
+"""Literal DSL nodes."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, NoReturn
+
+import polars as pl
+
+import pylibcudf as plc
+
+from cudf_polars.containers import Column, DataType
+from cudf_polars.dsl.expressions.base import ExecutionContext, Expr
+
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+
+    from cudf_polars.containers import DataFrame
+
+__all__ = ["Literal", "LiteralColumn"]
+
+
+class Literal(Expr):
+    __slots__ = ("value",)
+    _non_child = ("dtype", "value")
+    value: Any  # Python scalar
+
+    def __init__(self, dtype: DataType, value: Any) -> None:
+        if value is None and dtype.id() == plc.TypeId.EMPTY:
+            # TypeId.EMPTY not supported by libcudf
+            # cuDF Python also maps EMPTY to INT8
+            dtype = DataType(pl.datatypes.Int8())
+        self.dtype = dtype
+        self.value = value
+        self.children = ()
+        self.is_pointwise = True
+
+    def do_evaluate(
+        self, df: DataFrame, *, context: ExecutionContext = ExecutionContext.FRAME
+    ) -> Column:
+        """Evaluate this expression given a dataframe for context."""
+        return Column(
+            plc.Column.from_scalar(plc.Scalar.from_py(self.value, self.dtype.plc), 1),
+            dtype=self.dtype,
+        )
+
+    @property
+    def agg_request(self) -> NoReturn:  # noqa: D102
+        raise NotImplementedError(
+            "Not expecting to require agg request of literal"
+        )  # pragma: no cover
+
+    def astype(self, dtype: DataType) -> Literal:
+        """Cast self to dtype."""
+        if self.value is None:
+            return Literal(dtype, self.value)
+        else:
+            # Use polars to cast instead of pylibcudf
+            # since there are just Python scalars
+            casted = pl.Series(values=[self.value], dtype=self.dtype.polars).cast(
+                dtype.polars
+            )[0]
+            return Literal(dtype, casted)
+
+
+class LiteralColumn(Expr):
+    __slots__ = ("value",)
+    _non_child = ("dtype", "value")
+    value: pl.Series
+
+    def __init__(self, dtype: DataType, value: pl.Series) -> None:
+        self.dtype = dtype
+        self.value = value
+        self.children = ()
+        self.is_pointwise = True
+
+    def get_hashable(self) -> Hashable:
+        """Compute a hash of the column."""
+        # This is stricter than necessary, but we only need this hash
+        # for identity in groupby replacements so it's OK. And this
+        # way we avoid doing potentially expensive compute.
+        return (type(self), self.dtype.plc, id(self.value))
+
+    def do_evaluate(
+        self, df: DataFrame, *, context: ExecutionContext = ExecutionContext.FRAME
+    ) -> Column:
+        """Evaluate this expression given a dataframe for context."""
+        return Column(plc.Column.from_arrow(self.value), dtype=self.dtype)
+
+    @property
+    def agg_request(self) -> NoReturn:  # noqa: D102
+        raise NotImplementedError(
+            "Not expecting to require agg request of literal"
+        )  # pragma: no cover