pixeltable 0.3.9__py3-none-any.whl → 0.3.11__py3-none-any.whl

pixeltable/exec/expr_eval/schedulers.py

@@ -11,7 +11,7 @@ from typing import Awaitable, Collection, Optional
 from pixeltable import env, func
 from pixeltable.config import Config
 
-from .globals import Dispatcher, FnCallArgs, Scheduler
+from .globals import Dispatcher, ExecCtx, FnCallArgs, Scheduler
 
 _logger = logging.getLogger('pixeltable')
 
@@ -62,9 +62,6 @@ class RateLimitsScheduler(Scheduler):
     def matches(cls, resource_pool: str) -> bool:
         return resource_pool.startswith('rate-limits:')
 
-    def submit(self, item: FnCallArgs) -> None:
-        self.queue.put_nowait(self.QueueItem(item, 0))
-
     def _set_pool_info(self) -> None:
         """Initialize pool_info with the RateLimitsInfo for the resource pool, if available"""
         if self.pool_info is not None:
@@ -76,7 +73,7 @@ class RateLimitsScheduler(Scheduler):
         assert hasattr(self.pool_info, 'get_request_resources')
         sig = inspect.signature(self.pool_info.get_request_resources)
         self.get_request_resources_param_names = [p.name for p in sig.parameters.values()]
-        self.est_usage = {r: 0 for r in self._resources}
+        self.est_usage = dict.fromkeys(self._resources, 0)
 
     async def _main_loop(self) -> None:
         item: Optional[RateLimitsScheduler.QueueItem] = None
@@ -90,7 +87,7 @@ class RateLimitsScheduler(Scheduler):
             if self.pool_info is None or not self.pool_info.is_initialized():
                 # wait for a single request to get rate limits
                 _logger.debug(f'initializing rate limits for {self.resource_pool}')
-                await self._exec(item.request, item.num_retries, is_task=False)
+                await self._exec(item.request, item.exec_ctx, item.num_retries, is_task=False)
                 _logger.debug(f'initialized rate limits for {self.resource_pool}')
                 item = None
                 # if this was the first request, it created the pool_info
@@ -141,7 +138,7 @@ class RateLimitsScheduler(Scheduler):
                 self.est_usage[resource] += val
             _logger.debug(f'creating task for {self.resource_pool}')
             self.num_in_flight += 1
-            task = asyncio.create_task(self._exec(item.request, item.num_retries, is_task=True))
+            task = asyncio.create_task(self._exec(item.request, item.exec_ctx, item.num_retries, is_task=True))
             self.dispatcher.register_task(task)
             item = None
 
@@ -171,7 +168,7 @@ class RateLimitsScheduler(Scheduler):
             return None
         return min(candidates, key=lambda x: x[1])[0]
 
-    async def _exec(self, request: FnCallArgs, num_retries: int, is_task: bool) -> None:
+    async def _exec(self, request: FnCallArgs, exec_ctx: ExecCtx, num_retries: int, is_task: bool) -> None:
         assert all(not row.has_val[request.fn_call.slot_idx] for row in request.rows)
         assert all(not row.has_exc(request.fn_call.slot_idx) for row in request.rows)
 
@@ -180,7 +177,8 @@ class RateLimitsScheduler(Scheduler):
             pxt_fn = request.fn_call.fn
             assert isinstance(pxt_fn, func.CallableFunction)
             _logger.debug(
-                f'scheduler {self.resource_pool}: start evaluating slot {request.fn_call.slot_idx}, batch_size={len(request.rows)}'
+                f'scheduler {self.resource_pool}: '
+                f'start evaluating slot {request.fn_call.slot_idx}, batch_size={len(request.rows)}'
             )
             self.total_requests += 1
             if request.is_batched:
@@ -193,13 +191,14 @@ class RateLimitsScheduler(Scheduler):
                 request.row[request.fn_call.slot_idx] = result
             end_ts = datetime.datetime.now(tz=datetime.timezone.utc)
             _logger.debug(
-                f'scheduler {self.resource_pool}: evaluated slot {request.fn_call.slot_idx} in {end_ts - start_ts}, batch_size={len(request.rows)}'
+                f'scheduler {self.resource_pool}: evaluated slot {request.fn_call.slot_idx} '
+                f'in {end_ts - start_ts}, batch_size={len(request.rows)}'
             )
 
             # purge accumulated usage estimate, now that we have a new report
-            self.est_usage = {r: 0 for r in self._resources}
+            self.est_usage = dict.fromkeys(self._resources, 0)
 
-            self.dispatcher.dispatch(request.rows)
+            self.dispatcher.dispatch(request.rows, exec_ctx)
         except Exception as exc:
             _logger.debug(f'scheduler {self.resource_pool}: exception in slot {request.fn_call.slot_idx}: {exc}')
             if self.pool_info is None:
@@ -212,7 +211,7 @@ class RateLimitsScheduler(Scheduler):
                     self.total_retried += 1
                     _logger.debug(f'scheduler {self.resource_pool}: retrying in {retry_delay} seconds')
                     await asyncio.sleep(retry_delay)
-                    self.queue.put_nowait(self.QueueItem(request, num_retries + 1))
+                    self.queue.put_nowait(self.QueueItem(request, num_retries + 1, exec_ctx))
                     return
             # TODO: update resource limits reported in exc.response.headers, if present
 
@@ -220,7 +219,7 @@ class RateLimitsScheduler(Scheduler):
             _, _, exc_tb = sys.exc_info()
             for row in request.rows:
                 row.set_exc(request.fn_call.slot_idx, exc)
-            self.dispatcher.dispatch_exc(request.rows, request.fn_call.slot_idx, exc_tb)
+            self.dispatcher.dispatch_exc(request.rows, request.fn_call.slot_idx, exc_tb, exec_ctx)
         finally:
             _logger.debug(f'Scheduler stats: #requests={self.total_requests}, #retried={self.total_retried}')
             if is_task:
@@ -301,15 +300,15 @@ class RequestRateScheduler(Scheduler):
             if item.num_retries > 0:
                 # the last request encountered some problem: retry it synchronously, to wait for the problem to pass
                 _logger.debug(f'retrying request for {self.resource_pool}: #retries={item.num_retries}')
-                await self._exec(item.request, item.num_retries, is_task=False)
+                await self._exec(item.request, item.exec_ctx, item.num_retries, is_task=False)
                 _logger.debug(f'retried request for {self.resource_pool}: #retries={item.num_retries}')
             else:
                 _logger.debug(f'creating task for {self.resource_pool}')
                 self.num_in_flight += 1
-                task = asyncio.create_task(self._exec(item.request, item.num_retries, is_task=True))
+                task = asyncio.create_task(self._exec(item.request, item.exec_ctx, item.num_retries, is_task=True))
                 self.dispatcher.register_task(task)
 
-    async def _exec(self, request: FnCallArgs, num_retries: int, is_task: bool) -> None:
+    async def _exec(self, request: FnCallArgs, exec_ctx: ExecCtx, num_retries: int, is_task: bool) -> None:
         assert all(not row.has_val[request.fn_call.slot_idx] for row in request.rows)
         assert all(not row.has_exc(request.fn_call.slot_idx) for row in request.rows)
 
@@ -318,7 +317,8 @@ class RequestRateScheduler(Scheduler):
             pxt_fn = request.fn_call.fn
             assert isinstance(pxt_fn, func.CallableFunction)
             _logger.debug(
-                f'scheduler {self.resource_pool}: start evaluating slot {request.fn_call.slot_idx}, batch_size={len(request.rows)}'
+                f'scheduler {self.resource_pool}: '
+                f'start evaluating slot {request.fn_call.slot_idx}, batch_size={len(request.rows)}'
             )
             self.total_requests += 1
             if request.is_batched:
@@ -331,9 +331,10 @@ class RequestRateScheduler(Scheduler):
                 request.row[request.fn_call.slot_idx] = result
             end_ts = datetime.datetime.now(tz=datetime.timezone.utc)
             _logger.debug(
-                f'scheduler {self.resource_pool}: evaluated slot {request.fn_call.slot_idx} in {end_ts - start_ts}, batch_size={len(request.rows)}'
+                f'scheduler {self.resource_pool}: evaluated slot {request.fn_call.slot_idx} '
+                f'in {end_ts - start_ts}, batch_size={len(request.rows)}'
             )
-            self.dispatcher.dispatch(request.rows)
+            self.dispatcher.dispatch(request.rows, exec_ctx)
 
         except Exception as exc:
             # TODO: which exception can be retried?
@@ -341,17 +342,18 @@ class RequestRateScheduler(Scheduler):
             status = getattr(exc, 'status', None)
             _logger.debug(f'type={type(exc)} has_status={hasattr(exc, "status")} status={status}')
             if num_retries < self.MAX_RETRIES:
-                self.queue.put_nowait(self.QueueItem(request, num_retries + 1))
+                self.queue.put_nowait(self.QueueItem(request, num_retries + 1, exec_ctx))
                 return
 
             # record the exception
             _, _, exc_tb = sys.exc_info()
             for row in request.rows:
                 row.set_exc(request.fn_call.slot_idx, exc)
-            self.dispatcher.dispatch_exc(request.rows, request.fn_call.slot_idx, exc_tb)
+            self.dispatcher.dispatch_exc(request.rows, request.fn_call.slot_idx, exc_tb, exec_ctx)
         finally:
             _logger.debug(
-                f'Scheduler stats: #in-flight={self.num_in_flight} #requests={self.total_requests}, #retried={self.total_retried}'
+                f'Scheduler stats: #in-flight={self.num_in_flight} #requests={self.total_requests}, '
+                f'#retried={self.total_retried}'
             )
             if is_task:
                 self.num_in_flight -= 1

pixeltable/exec/in_memory_data_node.py

@@ -1,8 +1,7 @@
 import logging
-from typing import Any, AsyncIterator, Iterator, Optional
+from typing import Any, AsyncIterator, Optional
 
-import pixeltable.catalog as catalog
-import pixeltable.exprs as exprs
+from pixeltable import catalog, exprs
 from pixeltable.utils.media_store import MediaStore
 
 from .data_row_batch import DataRowBatch
@@ -68,9 +67,12 @@ class InMemoryDataNode(ExecNode):
                 if col_info.col.col_type.is_image_type() and isinstance(val, bytes):
                     # this is a literal image, ie, a sequence of bytes; we save this as a media file and store the path
                     path = str(MediaStore.prepare_media_path(self.tbl.id, col_info.col.id, self.tbl.get().version))
-                    open(path, 'wb').write(val)
-                    val = path
-                self.output_rows[row_idx][col_info.slot_idx] = val
+                    with open(path, 'wb') as fp:
+                        fp.write(val)
+                    self.output_rows[row_idx][col_info.slot_idx] = path
+                else:
+                    self.output_rows[row_idx][col_info.slot_idx] = val
+
                 input_slot_idxs.add(col_info.slot_idx)
 
             # set the remaining output slots to their default values (presently None)

pixeltable/exec/row_update_node.py

@@ -1,8 +1,7 @@
 import logging
 from typing import Any, AsyncIterator
 
-import pixeltable.catalog as catalog
-import pixeltable.exprs as exprs
+from pixeltable import catalog, exprs
 
 from .data_row_batch import DataRowBatch
 from .exec_node import ExecNode
@@ -29,7 +28,7 @@ class RowUpdateNode(ExecNode):
         input: ExecNode,
     ):
         super().__init__(row_builder, [], [], input)
-        self.updates = {key_vals: col_vals for key_vals, col_vals in zip(key_vals_batch, col_vals_batch)}
+        self.updates = dict(zip(key_vals_batch, col_vals_batch))
         self.is_rowid_key = is_rowid_key
         # determine slot idxs of all columns we need to read or write
         # retrieve ColumnRefs from the RowBuilder (has slot_idx set)
@@ -38,7 +37,7 @@ class RowUpdateNode(ExecNode):
             for col_ref in row_builder.unique_exprs
             if isinstance(col_ref, exprs.ColumnRef)
         }
-        self.col_slot_idxs = {col: all_col_slot_idxs[col] for col in col_vals_batch[0].keys()}
+        self.col_slot_idxs = {col: all_col_slot_idxs[col] for col in col_vals_batch[0]}
         self.key_slot_idxs = {col: all_col_slot_idxs[col] for col in tbl.tbl_version.get().primary_key_columns()}
         self.matched_key_vals: set[tuple] = set()
 

pixeltable/exec/sql_node.py

@@ -6,8 +6,7 @@ from uuid import UUID
 
 import sqlalchemy as sql
 
-import pixeltable.catalog as catalog
-import pixeltable.exprs as exprs
+from pixeltable import catalog, exprs
 from pixeltable.env import Env
 
 from .data_row_batch import DataRowBatch
@@ -217,31 +216,31 @@ class SqlNode(ExecNode):
         candidates = tbl.get_tbl_versions()
         assert len(candidates) > 0
         joined_tbls: list[catalog.TableVersionHandle] = [candidates[0]]
-        for tbl in candidates[1:]:
-            if tbl.id in refd_tbl_ids:
-                joined_tbls.append(tbl)
+        for t in candidates[1:]:
+            if t.id in refd_tbl_ids:
+                joined_tbls.append(t)
 
         first = True
-        prev_tbl: catalog.TableVersionHandle
-        for tbl in joined_tbls[::-1]:
+        prev_tbl: Optional[catalog.TableVersionHandle] = None
+        for t in joined_tbls[::-1]:
             if first:
-                stmt = stmt.select_from(tbl.get().store_tbl.sa_tbl)
+                stmt = stmt.select_from(t.get().store_tbl.sa_tbl)
                 first = False
             else:
                 # join tbl to prev_tbl on prev_tbl's rowid cols
                 prev_tbl_rowid_cols = prev_tbl.get().store_tbl.rowid_columns()
-                tbl_rowid_cols = tbl.get().store_tbl.rowid_columns()
+                tbl_rowid_cols = t.get().store_tbl.rowid_columns()
                 rowid_clauses = [
                     c1 == c2 for c1, c2 in zip(prev_tbl_rowid_cols, tbl_rowid_cols[: len(prev_tbl_rowid_cols)])
                 ]
-                stmt = stmt.join(tbl.get().store_tbl.sa_tbl, sql.and_(*rowid_clauses))
-            if tbl.id in exact_version_only:
-                stmt = stmt.where(tbl.get().store_tbl.v_min_col == tbl.get().version)
+                stmt = stmt.join(t.get().store_tbl.sa_tbl, sql.and_(*rowid_clauses))
+            if t.id in exact_version_only:
+                stmt = stmt.where(t.get().store_tbl.v_min_col == t.get().version)
             else:
-                stmt = stmt.where(tbl.get().store_tbl.v_min_col <= tbl.get().version).where(
-                    tbl.get().store_tbl.v_max_col > tbl.get().version
+                stmt = stmt.where(t.get().store_tbl.v_min_col <= t.get().version).where(
+                    t.get().store_tbl.v_max_col > t.get().version
                 )
-            prev_tbl = tbl
+            prev_tbl = t
         return stmt
 
     def set_where(self, where_clause: exprs.Expr) -> None:
@@ -291,7 +290,7 @@ class SqlNode(ExecNode):
 
             conn = Env.get().conn
             result_cursor = conn.execute(stmt)
-            for warning in w:
+            for _ in w:
                 pass
 
         tbl_version = self.tbl.tbl_version if self.tbl is not None else None
@@ -494,7 +493,7 @@ class SqlJoinNode(SqlNode):
                 if join_clause.join_type != plan.JoinType.CROSS
                 else sql.sql.expression.literal(True)
             )
-            is_outer = join_clause.join_type == plan.JoinType.LEFT or join_clause.join_type == plan.JoinType.FULL_OUTER
+            is_outer = join_clause.join_type in (plan.JoinType.LEFT, plan.JoinType.FULL_OUTER)
             stmt = stmt.join(
                 self.input_ctes[i + 1],
                 onclause=on_clause,

pixeltable/exprs/__init__.py

@@ -15,8 +15,8 @@ from .globals import ArithmeticOperator, ComparisonOperator, LogicalOperator
 from .in_predicate import InPredicate
 from .inline_expr import InlineArray, InlineDict, InlineList
 from .is_null import IsNull
-from .json_mapper import JsonMapper
-from .json_path import RELATIVE_PATH_ROOT, JsonPath
+from .json_mapper import JsonMapper, JsonMapperDispatch
+from .json_path import JsonPath
 from .literal import Literal
 from .method_ref import MethodRef
 from .object_ref import ObjectRef
@@ -24,5 +24,6 @@ from .row_builder import ColumnSlotIdx, ExecProfile, RowBuilder
 from .rowid_ref import RowidRef
 from .similarity_expr import SimilarityExpr
 from .sql_element_cache import SqlElementCache
+from .string_op import StringOp
 from .type_cast import TypeCast
 from .variable import Variable

pixeltable/exprs/arithmetic_expr.py

@@ -19,6 +19,8 @@ class ArithmeticExpr(Expr):
     Allows arithmetic exprs on json paths
     """
 
+    operator: ArithmeticOperator
+
     def __init__(self, operator: ArithmeticOperator, op1: Expr, op2: Expr):
         if op1.col_type.is_json_type() or op2.col_type.is_json_type() or operator == ArithmeticOperator.DIV:
             # we assume it's a float

pixeltable/exprs/column_property_ref.py

@@ -52,7 +52,7 @@ class ColumnPropertyRef(Expr):
         return f'{self._col_ref}.{self.prop.name.lower()}'
 
     def is_error_prop(self) -> bool:
-        return self.prop in {self.Property.ERRORTYPE, self.Property.ERRORMSG}
+        return self.prop in (self.Property.ERRORTYPE, self.Property.ERRORMSG)
 
     def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
         if not self._col_ref.col.is_stored:

pixeltable/exprs/column_ref.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copy
 from typing import Any, Optional, Sequence
 from uuid import UUID
 
@@ -125,11 +126,46 @@ class ColumnRef(Expr):
 
         return super().__getattr__(name)
 
+    @classmethod
+    def find_embedding_index(
+        cls, col: catalog.Column, idx_name: Optional[str], method_name: str
+    ) -> dict[str, catalog.TableVersion.IndexInfo]:
+        """Return IndexInfo for a column, with an optional given name"""
+        # determine index to use
+        idx_info_dict = col.get_idx_info()
+        from pixeltable import index
+
+        embedding_idx_info = {
+            info: value for info, value in idx_info_dict.items() if isinstance(value.idx, index.EmbeddingIndex)
+        }
+        if len(embedding_idx_info) == 0:
+            raise excs.Error(f'No indices found for {method_name!r} on column {col.name!r}')
+        if idx_name is not None and idx_name not in embedding_idx_info:
+            raise excs.Error(f'Index {idx_name!r} not found for {method_name!r} on column {col.name!r}')
+        if len(embedding_idx_info) > 1:
+            if idx_name is None:
+                raise excs.Error(
+                    f'Column {col.name!r} has multiple indices; use the index name to disambiguate: '
+                    f'`{method_name}(..., idx=<index_name>)`'
+                )
+            idx_info = {idx_name: embedding_idx_info[idx_name]}
+        else:
+            idx_info = embedding_idx_info
+        return idx_info
+
     def similarity(self, item: Any, *, idx: Optional[str] = None) -> Expr:
         from .similarity_expr import SimilarityExpr
 
         return SimilarityExpr(self, item, idx_name=idx)
 
+    def embedding(self, *, idx: Optional[str] = None) -> ColumnRef:
+        idx_info = ColumnRef.find_embedding_index(self.col, idx, 'embedding')
+        assert len(idx_info) == 1
+        col = copy.copy(next(iter(idx_info.values())).val_col)
+        col.name = f'{self.col.name}_embedding_{idx if idx is not None else ""}'
+        col.create_sa_cols()
+        return ColumnRef(col)
+
     def default_column_name(self) -> Optional[str]:
         return str(self)
 
@@ -140,13 +176,13 @@ class ColumnRef(Expr):
         tbl = catalog.Catalog.get().get_table_by_id(self.col.tbl.id)
         return tbl.select(self)
 
-    def show(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
+    def show(self, *args: Any, **kwargs: Any) -> 'pxt.dataframe.DataFrameResultSet':
         return self._df().show(*args, **kwargs)
 
-    def head(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
+    def head(self, *args: Any, **kwargs: Any) -> 'pxt.dataframe.DataFrameResultSet':
         return self._df().head(*args, **kwargs)
 
-    def tail(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
+    def tail(self, *args: Any, **kwargs: Any) -> 'pxt.dataframe.DataFrameResultSet':
         return self._df().tail(*args, **kwargs)
 
     def count(self) -> int:

pixeltable/exprs/compound_predicate.py

@@ -61,7 +61,7 @@ class CompoundPredicate(Expr):
         return [*super()._id_attrs(), ('operator', self.operator.value)]
 
     def split_conjuncts(self, condition: Callable[[Expr], bool]) -> tuple[list[Expr], Optional[Expr]]:
-        if self.operator in {LogicalOperator.OR, LogicalOperator.NOT}:
+        if self.operator in (LogicalOperator.OR, LogicalOperator.NOT):
             return super().split_conjuncts(condition)
         matches = [op for op in self.components if condition(op)]
         non_matches = [op for op in self.components if not condition(op)]

pixeltable/exprs/data_row.py

@@ -63,11 +63,25 @@ class DataRow:
     # - None if vals[i] is not a media type or if there is no local file yet for file_urls[i]
     file_paths: np.ndarray  # of str
 
-    def __init__(self, size: int, img_slot_idxs: list[int], media_slot_idxs: list[int], array_slot_idxs: list[int]):
+    # for nested rows (ie, those produced by JsonMapperDispatcher)
+    parent_row: Optional[DataRow]
+    parent_slot_idx: Optional[int]
+
+    def __init__(
+        self,
+        size: int,
+        img_slot_idxs: list[int],
+        media_slot_idxs: list[int],
+        array_slot_idxs: list[int],
+        parent_row: Optional[DataRow] = None,
+        parent_slot_idx: Optional[int] = None,
+    ):
         self.img_slot_idxs = img_slot_idxs
         self.media_slot_idxs = media_slot_idxs
         self.array_slot_idxs = array_slot_idxs
         self.init(size)
+        self.parent_row = parent_row
+        self.parent_slot_idx = parent_slot_idx
 
     def init(self, num_slots: int) -> None:
         self.vals = np.full(num_slots, None, dtype=object)
@@ -79,6 +93,8 @@ class DataRow:
         self.pk = None
         self.file_urls = np.full(num_slots, None, dtype=object)
         self.file_paths = np.full(num_slots, None, dtype=object)
+        self.parent_row = None
+        self.parent_slot_idx = None
 
     def clear(self, idxs: Optional[np.ndarray] = None) -> None:
         if idxs is not None:

pixeltable/exprs/expr.py

@@ -17,7 +17,7 @@ from typing_extensions import Self, _AnnotatedAlias
 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
@@ -69,6 +69,8 @@ class Expr(abc.ABC):
     # - not set for subexprs that don't need to be materialized because the parent can be materialized via SQL
     slot_idx: Optional[int]
 
+    T = TypeVar('T', bound='Expr')
+
     def __init__(self, col_type: ts.ColumnType):
         self.col_type = col_type
         self.components = []
@@ -97,9 +99,11 @@ class Expr(abc.ABC):
         by the immediately containing JsonMapper during initialization.
         """
         self._bind_rel_paths()
-        assert not self._has_relative_path, self._expr_tree()
+        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: Optional['exprs.JsonMapper'] = None) -> None:
+    def _bind_rel_paths(self, mapper: Optional['exprs.JsonMapperDispatch'] = None) -> None:
         for c in self.components:
             c._bind_rel_paths(mapper)
 
@@ -188,7 +192,7 @@ class Expr(abc.ABC):
             return False
         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.)
@@ -206,7 +210,7 @@ class Expr(abc.ABC):
             return None
         return [e.copy() for e in expr_list]
 
-    def __deepcopy__(self, memo=None) -> Expr:
+    def __deepcopy__(self, memo: Optional[dict[int, Any]] = 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 = {}
@@ -296,8 +300,6 @@ 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
@@ -370,9 +372,8 @@ class Expr(abc.ABC):
         except StopIteration:
             return False
 
-    @property
     def _has_relative_path(self) -> bool:
-        return any(c._has_relative_path for c in self.components)
+        return any(c._has_relative_path() for c in self.components)
 
     def tbl_ids(self) -> set[UUID]:
         """Returns table ids referenced by this expr."""
@@ -459,7 +460,6 @@ class Expr(abc.ABC):
                 return Literal(o, col_type=obj_type)
         return None
 
-    @abc.abstractmethod
     def sql_expr(self, sql_elements: 'exprs.SqlElementCache') -> Optional[sql.ColumnElement]:
         """
         If this expr can be materialized directly in SQL:
@@ -469,7 +469,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:
@@ -605,10 +605,6 @@ class Expr(abc.ABC):
                 # Return the `MethodRef` object itself; it requires arguments to become a `FunctionCall`
                 return method_ref
 
-    def __rshift__(self, other: object) -> 'exprs.Expr':
-        # Implemented here for type-checking purposes
-        raise excs.Error('The `>>` operator can only be applied to Json expressions')
-
     def __bool__(self) -> bool:
         raise TypeError(
             f'Pixeltable expressions cannot be used in conjunction with Python boolean operators (and/or/not)\n{self!r}'
@@ -658,13 +654,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) -> Union[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) -> Union['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':
@@ -676,13 +676,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) -> Union['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) -> Union['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':
@@ -694,6 +698,32 @@ 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]
@@ -805,13 +835,13 @@ class Expr(abc.ABC):
             first_param = next(params_iter) if len(params) >= 1 else None
             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}:
+            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.')
             # 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.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.')