pixeltable 0.2.26__py3-none-any.whl → 0.5.7__py3-none-any.whl

pixeltable/exprs/expr.py

@@ -7,29 +7,29 @@ import inspect
 import json
 import sys
 import typing
-from typing import TYPE_CHECKING, Any, Callable, Iterator, Optional, TypeVar, Union, overload, Iterable
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Iterator, TypeVar, overload
 from uuid import UUID
 
+import numpy as np
 import sqlalchemy as sql
-from typing_extensions import _AnnotatedAlias, Self
+from typing_extensions import Self, _AnnotatedAlias
 
-import pixeltable.catalog as catalog
-import pixeltable.exceptions as excs
-import pixeltable.func as func
-import pixeltable.type_system as ts
+from pixeltable import catalog, exceptions as excs, func, type_system as ts
 
 from .data_row import DataRow
-from .globals import ArithmeticOperator, ComparisonOperator, LiteralPythonTypes, LogicalOperator
+from .globals import ArithmeticOperator, ComparisonOperator, LiteralPythonTypes, LogicalOperator, StringOperator
 
 if TYPE_CHECKING:
     from pixeltable import exprs
 
+
 class ExprScope:
     """
     Representation of the scope in which an Expr needs to be evaluated. Used to determine nesting of scopes.
     parent is None: outermost scope
     """
-    def __init__(self, parent: Optional[ExprScope]):
+
+    def __init__(self, parent: ExprScope | None):
         self.parent = parent
 
     def is_contained_in(self, other: ExprScope) -> bool:
@@ -47,7 +47,7 @@ class Expr(abc.ABC):
     """
     Rules for using state in subclasses:
     - all state except for components and slot_idx is shared between copies of an Expr
-    - slot_idx is set during analysis (DataFrame.show())
+    - slot_idx is set during analysis (Query.show())
     - during eval(), components can only be accessed via self.components; any Exprs outside of that won't
       have slot_idx set
     """
@@ -61,13 +61,15 @@ class Expr(abc.ABC):
     # - set by the subclass's __init__()
     # - produced by _create_id()
     # - not expected to survive a serialize()/deserialize() roundtrip
-    id: Optional[int]
+    id: int | None
 
     # index of the expr's value in the data row:
     # - set for all materialized exprs
     # - None: not executable
     # - not set for subexprs that don't need to be materialized because the parent can be materialized via SQL
-    slot_idx: Optional[int]
+    slot_idx: int | None
+
+    T = TypeVar('T', bound='Expr')
 
     def __init__(self, col_type: ts.ColumnType):
         self.col_type = col_type
@@ -90,16 +92,33 @@ class Expr(abc.ABC):
                 result = c_scope
         return result
 
-    def bind_rel_paths(self, mapper: Optional['exprs.JsonMapper'] = None) -> None:
+    def bind_rel_paths(self) -> None:
         """
         Binds relative JsonPaths to mapper.
         This needs to be done in a separate phase after __init__(), because RelativeJsonPath()(-1) cannot be resolved
         by the immediately containing JsonMapper during initialization.
         """
+        self._bind_rel_paths()
+        has_rel_path = self._has_relative_path()
+        assert not has_rel_path, self._expr_tree()
+        assert not self._has_relative_path(), self._expr_tree()
+
+    def _bind_rel_paths(self, mapper: 'exprs.JsonMapperDispatch' | None = None) -> None:
         for c in self.components:
-            c.bind_rel_paths(mapper)
+            c._bind_rel_paths(mapper)
+
+    def _expr_tree(self) -> str:
+        """Returns a string representation of this expression as a multi-line tree. Useful for debugging."""
+        buf: list[str] = []
+        self._expr_tree_r(0, buf)
+        return '\n'.join(buf)
 
-    def default_column_name(self) -> Optional[str]:
+    def _expr_tree_r(self, indent: int, buf: list[str]) -> None:
+        buf.append(f'{" " * indent}{type(self).__name__}: {self}'.replace('\n', '\\n'))
+        for c in self.components:
+            c._expr_tree_r(indent + 2, buf)
+
+    def default_column_name(self) -> str | None:
         """
         Returns:
             None if this expression lacks a default name,
@@ -107,11 +126,29 @@ class Expr(abc.ABC):
         """
         return None
 
+    @property
+    def validation_error(self) -> str | None:
+        """
+        Subclasses can override this to indicate that validation has failed after a catalog load.
+
+        If an Expr (or any of its transitive components) is invalid, then it cannot be evaluated, but its metadata
+        will still be preserved in the catalog (so that the user can take appropriate corrective action).
+        """
+        for c in self.components:
+            error = c.validation_error
+            if error is not None:
+                return error
+        return None
+
+    @property
+    def is_valid(self) -> bool:
+        return self.validation_error is None
+
     def equals(self, other: Expr) -> bool:
         """
         Subclass-specific comparison. Implemented as a function because __eq__() is needed to construct Comparisons.
         """
-        if type(self) != type(other):
+        if type(self) is not type(other):
             return False
         if len(self.components) != len(other.components):
             return False
@@ -137,6 +174,9 @@ class Expr(abc.ABC):
         for attr, value in self._id_attrs():
             hasher.update(attr.encode('utf-8'))
             hasher.update(str(value).encode('utf-8'))
+        # Include the col_type of the expression to avoid expressions with identical str() representations
+        # but different types being considered the same expression, e.g. str(int(4)) == "4"
+        hasher.update(repr(self.col_type).encode('utf-8'))
         for expr in self.components:
             hasher.update(str(expr.id).encode('utf-8'))
         # truncate to machine's word size
@@ -150,12 +190,9 @@ class Expr(abc.ABC):
     def list_equals(cls, a: list[Expr], b: list[Expr]) -> bool:
         if len(a) != len(b):
             return False
-        for i in range(len(a)):
-            if not a[i].equals(b[i]):
-                return False
-        return True
+        return all(a[i].equals(b[i]) for i in range(len(a)))
 
-    def copy(self) -> Expr:
+    def copy(self: T) -> T:
         """
         Creates a copy that can be evaluated separately: it doesn't share any eval context (slot_idx)
         but shares everything else (catalog objects, etc.)
@@ -168,12 +205,12 @@ class Expr(abc.ABC):
         return result
 
     @classmethod
-    def copy_list(cls, expr_list: Optional[list[Expr]]) -> Optional[list[Expr]]:
+    def copy_list(cls, expr_list: list[Expr] | None) -> list[Expr] | None:
         if expr_list is None:
             return None
         return [e.copy() for e in expr_list]
 
-    def __deepcopy__(self, memo=None) -> Expr:
+    def __deepcopy__(self, memo: dict[int, Any] | None = None) -> Expr:
         # we don't need to create an actual deep copy because all state other than execution state is read-only
         if memo is None:
             memo = {}
@@ -183,35 +220,46 @@ class Expr(abc.ABC):
 
     def substitute(self, spec: dict[Expr, Expr]) -> Expr:
         """
-        Replace 'old' with 'new' recursively.
+        Replace 'old' with 'new' recursively, and return a new version of the expression
+        This method must be used in the form: expr = expr.substitute(spec)
         """
+        from .literal import Literal
+
+        if isinstance(self, Literal):
+            return self
         for old, new in spec.items():
             if self.equals(old):
                 return new.copy()
         for i in range(len(self.components)):
             self.components[i] = self.components[i].substitute(spec)
-        return self
+        result = self.maybe_literal()
+        result.id = result._create_id()
+        return result
 
     @classmethod
     def list_substitute(cls, expr_list: list[Expr], spec: dict[Expr, Expr]) -> None:
         for i in range(len(expr_list)):
             expr_list[i] = expr_list[i].substitute(spec)
 
-    def resolve_computed_cols(self, resolve_cols: Optional[set[catalog.Column]] = None) -> Expr:
+    def resolve_computed_cols(self, resolve_cols: set[catalog.Column] | None = None) -> Expr:
         """
         Recursively replace ColRefs to unstored computed columns with their value exprs.
         Also replaces references to stored computed columns in resolve_cols.
         """
         from .column_ref import ColumnRef
         from .expr_set import ExprSet
+
         if resolve_cols is None:
             resolve_cols = set()
         result = self
         while True:
-            target_col_refs = ExprSet([
-                e for e in result.subexprs()
-                if isinstance(e, ColumnRef) and e.col.is_computed and (not e.col.is_stored or e.col in resolve_cols)
-            ])
+            target_col_refs = ExprSet(
+                [
+                    e
+                    for e in result.subexprs()
+                    if isinstance(e, ColumnRef) and e.col.is_computed and (not e.col.is_stored or e.col in resolve_cols)
+                ]
+            )
             if len(target_col_refs) == 0:
                 return result
             result = result.substitute({ref: ref.col.value_expr for ref in target_col_refs})
@@ -219,19 +267,24 @@ class Expr(abc.ABC):
     def is_bound_by(self, tbls: list[catalog.TableVersionPath]) -> bool:
         """Returns True if this expr can be evaluated in the context of tbls."""
         from .column_ref import ColumnRef
+
         col_refs = self.subexprs(ColumnRef)
-        for col_ref in col_refs:
-            if not any(tbl.has_column(col_ref.col) for tbl in tbls):
-                return False
-        return True
+        return all(any(tbl.has_column(col_ref.col) for tbl in tbls) for col_ref in col_refs)
 
     def retarget(self, tbl: catalog.TableVersionPath) -> Self:
         """Retarget ColumnRefs in this expr to the specific TableVersions in tbl."""
-        tbl_versions = {tbl_version.id: tbl_version for tbl_version in tbl.get_tbl_versions()}
+        tbl_versions = {tbl_version.id: tbl_version.get() for tbl_version in tbl.get_tbl_versions()}
         return self._retarget(tbl_versions)
 
+    @classmethod
+    def retarget_list(cls, expr_list: list[Expr], tbl: catalog.TableVersionPath) -> None:
+        """Retarget ColumnRefs in expr_list to the specific TableVersions in tbl."""
+        tbl_versions = {tbl_version.id: tbl_version.get() for tbl_version in tbl.get_tbl_versions()}
+        for i in range(len(expr_list)):
+            expr_list[i] = expr_list[i]._retarget(tbl_versions)
+
     def _retarget(self, tbl_versions: dict[UUID, catalog.TableVersion]) -> Self:
-        for i in range (len(self.components)):
+        for i in range(len(self.components)):
             self.components[i] = self.components[i]._retarget(tbl_versions)
         return self
 
@@ -254,22 +307,21 @@ class Expr(abc.ABC):
     # instances of that subclass; and another that returns all subexpressions that match the given filter.
     # In order for type checking to behave correctly on both forms, we provide two overloaded signatures.
 
-    T = TypeVar('T', bound='Expr')
-
     @overload
     def subexprs(
-        self, *, filter: Optional[Callable[[Expr], bool]] = None, traverse_matches: bool = True
+        self, *, filter: Callable[[Expr], bool] | None = None, traverse_matches: bool = True
     ) -> Iterator[Expr]: ...
 
     @overload
     def subexprs(
-        self, expr_class: type[T], filter: Optional[Callable[[Expr], bool]] = None,
-        traverse_matches: bool = True
+        self, expr_class: type[T], filter: Callable[[Expr], bool] | None = None, traverse_matches: bool = True
     ) -> Iterator[T]: ...
 
     def subexprs(
-        self, expr_class: Optional[type[T]] = None, filter: Optional[Callable[[Expr], bool]] = None,
-        traverse_matches: bool = True
+        self,
+        expr_class: type[T] | None = None,
+        filter: Callable[[Expr], bool] | None = None,
+        traverse_matches: bool = True,
     ) -> Iterator[T]:
         """
         Iterate over all subexprs, including self.
@@ -287,26 +339,41 @@ class Expr(abc.ABC):
     @overload
     @classmethod
     def list_subexprs(
-        cls, expr_list: Iterable[Expr], *, filter: Optional[Callable[[Expr], bool]] = None, traverse_matches: bool = True
+        cls, expr_list: Iterable[Expr], *, filter: Callable[[Expr], bool] | None = None, traverse_matches: bool = True
     ) -> Iterator[Expr]: ...
 
     @overload
     @classmethod
     def list_subexprs(
-        cls, expr_list: Iterable[Expr], expr_class: type[T], filter: Optional[Callable[[Expr], bool]] = None,
-        traverse_matches: bool = True
+        cls,
+        expr_list: Iterable[Expr],
+        expr_class: type[T],
+        filter: Callable[[Expr], bool] | None = None,
+        traverse_matches: bool = True,
     ) -> Iterator[T]: ...
 
     @classmethod
     def list_subexprs(
-        cls, expr_list: Iterable[Expr], expr_class: Optional[type[T]] = None,
-        filter: Optional[Callable[[Expr], bool]] = None, traverse_matches: bool = True
+        cls,
+        expr_list: Iterable[Expr],
+        expr_class: type[T] | None = None,
+        filter: Callable[[Expr], bool] | None = None,
+        traverse_matches: bool = True,
     ) -> Iterator[T]:
         """Produce subexprs for all exprs in list. Can contain duplicates."""
         for e in expr_list:
             yield from e.subexprs(expr_class=expr_class, filter=filter, traverse_matches=traverse_matches)
 
-    def _contains(self, cls: Optional[type[Expr]] = None, filter: Optional[Callable[[Expr], bool]] = None) -> bool:
+    @classmethod
+    def list_contains(
+        cls,
+        expr_list: Iterable[Expr],
+        expr_class: type[Expr] | None = None,
+        filter: Callable[[Expr], bool] | None = None,
+    ) -> bool:
+        return any(e._contains(expr_class, filter) for e in expr_list)
+
+    def _contains(self, cls: type[Expr] | None = None, filter: Callable[[Expr], bool] | None = None) -> bool:
         """
         Returns True if any subexpr is an instance of cls and/or matches filter.
         """
@@ -317,53 +384,97 @@ class Expr(abc.ABC):
         except StopIteration:
             return False
 
+    def _has_relative_path(self) -> bool:
+        return any(c._has_relative_path() for c in self.components)
+
     def tbl_ids(self) -> set[UUID]:
         """Returns table ids referenced by this expr."""
         from .column_ref import ColumnRef
         from .rowid_ref import RowidRef
-        return {ref.col.tbl.id for ref in self.subexprs(ColumnRef)} | {ref.tbl.id for ref in self.subexprs(RowidRef)}
+
+        return {ref.col.get_tbl().id for ref in self.subexprs(ColumnRef)} | {
+            ref.tbl.id for ref in self.subexprs(RowidRef)
+        }
 
     @classmethod
     def all_tbl_ids(cls, exprs_: Iterable[Expr]) -> set[UUID]:
-        return set(tbl_id for e in exprs_ for tbl_id in e.tbl_ids())
+        return {tbl_id for e in exprs_ for tbl_id in e.tbl_ids()}
 
     @classmethod
-    def get_refd_columns(cls, expr_dict: dict[str, Any]) -> list[catalog.Column]:
+    def get_refd_column_ids(cls, expr_dict: dict[str, Any]) -> set[catalog.QColumnId]:
         """Return Columns referenced by expr_dict."""
-        result: list[catalog.Column] = []
+        result: set[catalog.QColumnId] = set()
         assert '_classname' in expr_dict
         from .column_ref import ColumnRef
+
         if expr_dict['_classname'] == 'ColumnRef':
-            result.append(ColumnRef.get_column(expr_dict))
+            result.add(ColumnRef.get_column_id(expr_dict))
         if 'components' in expr_dict:
             for component_dict in expr_dict['components']:
-                result.extend(cls.get_refd_columns(component_dict))
+                result.update(cls.get_refd_column_ids(component_dict))
         return result
 
+    def as_literal(self) -> Expr | None:
+        """
+        Return a Literal expression if this expression can be evaluated to a constant value, otherwise return None.
+        """
+        return None
+
+    @classmethod
+    def from_array(cls, elements: Iterable) -> Expr | None:
+        from .inline_expr import InlineArray
+        from .literal import Literal
+
+        if isinstance(elements, np.ndarray):
+            pxttype = ts.ArrayType.from_literal(elements)
+            if pxttype is not None:
+                return Literal(elements, col_type=pxttype)
+
+        inline_array = InlineArray(elements)
+        return inline_array.maybe_literal()
+
+    def maybe_literal(self: Expr) -> Expr:
+        """
+        Return a Literal if this expression can be evaluated to a constant value, otherwise return the expression.
+        """
+        lit_expr = self.as_literal()
+        if lit_expr is not None:
+            return lit_expr
+        else:
+            return self
+
     @classmethod
-    def from_object(cls, o: object) -> Optional[Expr]:
+    def from_object(cls, o: object) -> Expr | None:
         """
         Try to turn a literal object into an Expr.
         """
-        if isinstance(o, Expr):
-            return o
+        from .inline_expr import InlineDict, InlineList
+        from .literal import Literal
+
         # Try to create a literal. We need to check for InlineList/InlineDict
         # first, to prevent them from inappropriately being interpreted as JsonType
         # literals.
-        if isinstance(o, list):
-            from .inline_expr import InlineList
-            return InlineList(o)
-        if isinstance(o, dict):
-            from .inline_expr import InlineDict
-            return InlineDict(o)
-        obj_type = ts.ColumnType.infer_literal_type(o)
-        if obj_type is not None:
-            from .literal import Literal
-            return Literal(o, col_type=obj_type)
+        if isinstance(o, Literal):
+            return o
+
+        if isinstance(o, (list, tuple, dict, Expr)):
+            expr: Expr
+            if isinstance(o, (list, tuple)):
+                expr = InlineList(o)
+            elif isinstance(o, dict):
+                expr = InlineDict(o)
+            else:
+                expr = o
+
+            return expr.maybe_literal()
+        else:
+            # convert scalar to a literal
+            obj_type = ts.ColumnType.infer_literal_type(o)
+            if obj_type is not None:
+                return Literal(o, col_type=obj_type)
         return None
 
-    @abc.abstractmethod
-    def sql_expr(self, sql_elements: 'exprs.SqlElementCache') -> Optional[sql.ColumnElement]:
+    def sql_expr(self, sql_elements: 'exprs.SqlElementCache') -> sql.ColumnElement | None:
         """
         If this expr can be materialized directly in SQL:
         - returns a ColumnElement
@@ -372,7 +483,7 @@ class Expr(abc.ABC):
         - returns None
         - eval() will be called
         """
-        pass
+        return None
 
     @abc.abstractmethod
     def eval(self, data_row: DataRow, row_builder: 'exprs.RowBuilder') -> None:
@@ -382,6 +493,18 @@ class Expr(abc.ABC):
         """
         pass
 
+    def prepare(self) -> None:
+        """
+        Create execution state. This is called before the first eval() call.
+        """
+        for c in self.components:
+            c.prepare()
+
+    @classmethod
+    def prepare_list(cls, expr_list: Iterable[Expr]) -> None:
+        for e in expr_list:
+            e.prepare()
+
     def release(self) -> None:
         """
         Allow Expr class to tear down execution state. This is called after the last eval() call.
@@ -390,7 +513,7 @@ class Expr(abc.ABC):
             c.release()
 
     @classmethod
-    def release_list(cls, expr_list: list[Expr]) -> None:
+    def release_list(cls, expr_list: Iterable[Expr]) -> None:
         for e in expr_list:
             e.release()
 
@@ -402,13 +525,10 @@ class Expr(abc.ABC):
         Turn Expr object into a dict that can be passed to json.dumps().
         Subclasses override _as_dict().
         """
-        return {
-            '_classname': self.__class__.__name__,
-            **self._as_dict(),
-        }
+        return {'_classname': self.__class__.__name__, **self._as_dict()}
 
     @classmethod
-    def as_dict_list(self, expr_list: list[Expr]) -> list[dict]:
+    def as_dict_list(cls, expr_list: list[Expr]) -> list[dict]:
         return [e.as_dict() for e in expr_list]
 
     def _as_dict(self) -> dict:
@@ -439,17 +559,19 @@ class Expr(abc.ABC):
 
     @classmethod
     def _from_dict(cls, d: dict, components: list[Expr]) -> Self:
-        assert False, 'not implemented'
+        raise AssertionError(f'not implemented: {cls.__name__}')
 
     def isin(self, value_set: Any) -> 'exprs.InPredicate':
         from .in_predicate import InPredicate
+
         if isinstance(value_set, Expr):
             return InPredicate(self, value_set_expr=value_set)
         else:
             return InPredicate(self, value_set_literal=value_set)
 
-    def astype(self, new_type: Union[ts.ColumnType, type, _AnnotatedAlias]) -> 'exprs.TypeCast':
+    def astype(self, new_type: ts.ColumnType | type | _AnnotatedAlias) -> 'exprs.TypeCast':
         from pixeltable.exprs import TypeCast
+
         # Interpret the type argument the same way we would if given in a schema
         col_type = ts.ColumnType.normalize_type(new_type, nullable_default=True, allow_builtin_types=False)
         if not self.col_type.nullable:
@@ -458,7 +580,9 @@ class Expr(abc.ABC):
             col_type = col_type.copy(nullable=False)
         return TypeCast(self, col_type)
 
-    def apply(self, fn: Callable, *, col_type: Union[ts.ColumnType, type, _AnnotatedAlias, None] = None) -> 'exprs.FunctionCall':
+    def apply(
+        self, fn: Callable, *, col_type: ts.ColumnType | type | _AnnotatedAlias | None = None
+    ) -> 'exprs.FunctionCall':
         if col_type is not None:
             col_type = ts.ColumnType.normalize_type(col_type)
         function = self._make_applicator_function(fn, col_type)
@@ -467,10 +591,7 @@ class Expr(abc.ABC):
 
     def __dir__(self) -> list[str]:
         attrs = ['isin', 'astype', 'apply']
-        attrs += [
-            f.name
-            for f in func.FunctionRegistry.get().get_type_methods(self.col_type.type_enum)
-        ]
+        attrs += [f.name for f in func.FunctionRegistry.get().get_type_methods(self.col_type.type_enum)]
         return attrs
 
     def __call__(self, *args: Any, **kwargs: Any) -> Any:
@@ -479,9 +600,11 @@ class Expr(abc.ABC):
     def __getitem__(self, index: object) -> Expr:
         if self.col_type.is_json_type():
             from .json_path import JsonPath
+
             return JsonPath(self)[index]
         if self.col_type.is_array_type():
             from .array_slice import ArraySlice
+
             if not isinstance(index, tuple):
                 index = (index,)
             if any(not isinstance(i, (int, slice)) for i in index):
@@ -495,6 +618,7 @@ class Expr(abc.ABC):
         """
         from .json_path import JsonPath
         from .method_ref import MethodRef
+
         if self.col_type.is_json_type():
             return JsonPath(self).__getattr__(name)
         else:
@@ -509,7 +633,8 @@ class Expr(abc.ABC):
 
     def __bool__(self) -> bool:
         raise TypeError(
-            'Pixeltable expressions cannot be used in conjunction with Python boolean operators (and/or/not)')
+            f'Pixeltable expressions cannot be used in conjunction with Python boolean operators (and/or/not)\n{self!r}'
+        )
 
     def __lt__(self, other: object) -> 'exprs.Comparison':
         return self._make_comparison(ComparisonOperator.LT, other)
@@ -520,6 +645,7 @@ class Expr(abc.ABC):
     def __eq__(self, other: object) -> 'exprs.Expr':  # type: ignore[override]
         if other is None:
             from .is_null import IsNull
+
             return IsNull(self)
         return self._make_comparison(ComparisonOperator.EQ, other)
 
@@ -527,6 +653,7 @@ class Expr(abc.ABC):
         if other is None:
             from .compound_predicate import CompoundPredicate
             from .is_null import IsNull
+
             return CompoundPredicate(LogicalOperator.NOT, [IsNull(self)])
         return self._make_comparison(ComparisonOperator.NE, other)
 
@@ -538,11 +665,12 @@ class Expr(abc.ABC):
 
     def _make_comparison(self, op: ComparisonOperator, other: object) -> 'exprs.Comparison':
         """
-        other: Union[Expr, LiteralPythonTypes]
+        other: Expr | LiteralPythonTypes
         """
         # TODO: check for compatibility
         from .comparison import Comparison
         from .literal import Literal
+
         if isinstance(other, Expr):
             return Comparison(op, self, other)
         if isinstance(other, typing.get_args(LiteralPythonTypes)):
@@ -552,13 +680,17 @@ class Expr(abc.ABC):
     def __neg__(self) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.MUL, -1)
 
-    def __add__(self, other: object) -> 'exprs.ArithmeticExpr':
+    def __add__(self, other: object) -> exprs.ArithmeticExpr | exprs.StringOp:
+        if isinstance(self, str) or (isinstance(self, Expr) and self.col_type.is_string_type()):
+            return self._make_string_expr(StringOperator.CONCAT, other)
         return self._make_arithmetic_expr(ArithmeticOperator.ADD, other)
 
     def __sub__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.SUB, other)
 
-    def __mul__(self, other: object) -> 'exprs.ArithmeticExpr':
+    def __mul__(self, other: object) -> 'exprs.ArithmeticExpr' | 'exprs.StringOp':
+        if isinstance(self, str) or (isinstance(self, Expr) and self.col_type.is_string_type()):
+            return self._make_string_expr(StringOperator.REPEAT, other)
         return self._make_arithmetic_expr(ArithmeticOperator.MUL, other)
 
     def __truediv__(self, other: object) -> 'exprs.ArithmeticExpr':
@@ -570,13 +702,17 @@ class Expr(abc.ABC):
     def __floordiv__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.FLOORDIV, other)
 
-    def __radd__(self, other: object) -> 'exprs.ArithmeticExpr':
+    def __radd__(self, other: object) -> 'exprs.ArithmeticExpr' | 'exprs.StringOp':
+        if isinstance(other, str) or (isinstance(other, Expr) and other.col_type.is_string_type()):
+            return self._rmake_string_expr(StringOperator.CONCAT, other)
         return self._rmake_arithmetic_expr(ArithmeticOperator.ADD, other)
 
     def __rsub__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._rmake_arithmetic_expr(ArithmeticOperator.SUB, other)
 
-    def __rmul__(self, other: object) -> 'exprs.ArithmeticExpr':
+    def __rmul__(self, other: object) -> 'exprs.ArithmeticExpr' | 'exprs.StringOp':
+        if isinstance(other, str) or (isinstance(other, Expr) and other.col_type.is_string_type()):
+            return self._rmake_string_expr(StringOperator.REPEAT, other)
         return self._rmake_arithmetic_expr(ArithmeticOperator.MUL, other)
 
     def __rtruediv__(self, other: object) -> 'exprs.ArithmeticExpr':
@@ -588,13 +724,40 @@ class Expr(abc.ABC):
     def __rfloordiv__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._rmake_arithmetic_expr(ArithmeticOperator.FLOORDIV, other)
 
+    def _make_string_expr(self, op: StringOperator, other: object) -> 'exprs.StringOp':
+        """
+        Make left-handed version of string expression.
+        """
+        from .literal import Literal
+        from .string_op import StringOp
+
+        if isinstance(other, Expr):
+            return StringOp(op, self, other)
+        if isinstance(other, typing.get_args(LiteralPythonTypes)):
+            return StringOp(op, self, Literal(other))
+        raise TypeError(f'Other must be Expr or literal: {type(other)}')
+
+    def _rmake_string_expr(self, op: StringOperator, other: object) -> 'exprs.StringOp':
+        """
+        Right-handed version of _make_string_expr. other must be a literal; if it were an Expr,
+        the operation would have already been evaluated in its left-handed form.
+        """
+        from .literal import Literal
+        from .string_op import StringOp
+
+        assert not isinstance(other, Expr)  # Else the left-handed form would have evaluated first
+        if isinstance(other, typing.get_args(LiteralPythonTypes)):
+            return StringOp(op, Literal(other), self)
+        raise TypeError(f'Other must be Expr or literal: {type(other)}')
+
     def _make_arithmetic_expr(self, op: ArithmeticOperator, other: object) -> 'exprs.ArithmeticExpr':
         """
-        other: Union[Expr, LiteralPythonTypes]
+        other: Expr | LiteralPythonTypes
         """
         # TODO: check for compatibility
         from .arithmetic_expr import ArithmeticExpr
         from .literal import Literal
+
         if isinstance(other, Expr):
             return ArithmeticExpr(op, self, other)
         if isinstance(other, typing.get_args(LiteralPythonTypes)):
@@ -609,6 +772,7 @@ class Expr(abc.ABC):
         # TODO: check for compatibility
         from .arithmetic_expr import ArithmeticExpr
         from .literal import Literal
+
         assert not isinstance(other, Expr)  # Else the left-handed form would have evaluated first
         if isinstance(other, typing.get_args(LiteralPythonTypes)):
             return ArithmeticExpr(op, Literal(other), self)
@@ -620,6 +784,7 @@ class Expr(abc.ABC):
         if not other.col_type.is_bool_type():
             raise TypeError(f'Other needs to be an expression that returns a boolean: {other.col_type}')
         from .compound_predicate import CompoundPredicate
+
         return CompoundPredicate(LogicalOperator.AND, [self, other])
 
     def __or__(self, other: object) -> Expr:
@@ -628,14 +793,15 @@ class Expr(abc.ABC):
         if not other.col_type.is_bool_type():
             raise TypeError(f'Other needs to be an expression that returns a boolean: {other.col_type}')
         from .compound_predicate import CompoundPredicate
+
         return CompoundPredicate(LogicalOperator.OR, [self, other])
 
     def __invert__(self) -> Expr:
         from .compound_predicate import CompoundPredicate
+
         return CompoundPredicate(LogicalOperator.NOT, [self])
 
-    def split_conjuncts(
-            self, condition: Callable[[Expr], bool]) -> tuple[list[Expr], Optional[Expr]]:
+    def split_conjuncts(self, condition: Callable[[Expr], bool]) -> tuple[list[Expr], Expr | None]:
         """
         Returns clauses of a conjunction that meet condition in the first element.
         The second element contains remaining clauses, rolled into a conjunction.
@@ -646,7 +812,7 @@ class Expr(abc.ABC):
         else:
             return [], self
 
-    def _make_applicator_function(self, fn: Callable, col_type: Optional[ts.ColumnType]) -> 'func.Function':
+    def _make_applicator_function(self, fn: Callable, col_type: ts.ColumnType | None) -> 'func.Function':
         """
         Creates a unary pixeltable `Function` that encapsulates a python `Callable`. The result type of
         the new `Function` is given by `col_type`, and its parameter type will be `self.col_type`.
@@ -675,7 +841,8 @@ class Expr(abc.ABC):
         if fn_type is None:
             raise excs.Error(
                 f'Column type of `{fn.__name__}` cannot be inferred. '
-                f'Use `.apply({fn.__name__}, col_type=...)` to specify.')
+                f'Use `.apply({fn.__name__}, col_type=...)` to specify.'
+            )
 
         # TODO(aaron-siegel) Currently we assume that `fn` has exactly one required parameter
         # and all optional parameters take their default values. Should we provide a more
@@ -695,17 +862,15 @@ class Expr(abc.ABC):
             second_param = next(params_iter) if len(params) >= 2 else None
             # Check that fn has at least one positional parameter
             if len(params) == 0 or first_param.kind in (inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.VAR_KEYWORD):
-                raise excs.Error(
-                    f'Function `{fn.__name__}` has no positional parameters.'
-                )
+                raise excs.Error(f'Function `{fn.__name__}` has no positional parameters.')
             # Check that fn has at most one required parameter, i.e., its second parameter
             # has no default and is not a varargs
-            if len(params) >= 2 and \
-                    second_param.kind not in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD) and \
-                    second_param.default == inspect.Parameter.empty:
-                raise excs.Error(
-                    f'Function `{fn.__name__}` has multiple required parameters.'
-                )
+            if (
+                len(params) >= 2
+                and second_param.kind not in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+                and second_param.default is inspect.Parameter.empty
+            ):
+                raise excs.Error(f'Function `{fn.__name__}` has multiple required parameters.')
         except ValueError:
             # inspect.signature(fn) will raise a `ValueError` if `fn` is a builtin; I don't
             # know of any way to get the signature of a builtin, nor to check for this in
@@ -719,7 +884,8 @@ class Expr(abc.ABC):
         # We also set the display_name explicitly, so that the `FunctionCall` gets the
         # name of `decorated_fn`, not the lambda.
         return func.make_function(
-            decorated_fn=lambda x: fn(x), return_type=fn_type, param_types=[self.col_type], function_name=fn.__name__)
+            decorated_fn=lambda x: fn(x), return_type=fn_type, param_types=[self.col_type], function_name=fn.__name__
+        )
 
 
 # A dictionary of result types of various stdlib functions that are