pixeltable 0.3.6__py3-none-any.whl → 0.3.8__py3-none-any.whl

pixeltable/exprs/function_call.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
 import inspect
+import logging
 import sys
+from textwrap import dedent
 from typing import Any, Optional, Sequence, Union
 
 import sqlalchemy as sql
 
-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 .expr import Expr
@@ -18,6 +17,8 @@ from .row_builder import RowBuilder
 from .rowid_ref import RowidRef
 from .sql_element_cache import SqlElementCache
 
+_logger = logging.getLogger('pixeltable')
+
 
 class FunctionCall(Expr):
     fn: func.Function
@@ -45,6 +46,8 @@ class FunctionCall(Expr):
     aggregator: Optional[Any]
     current_partition_vals: Optional[list[Any]]
 
+    _validation_error: Optional[str]
+
     def __init__(
         self,
         fn: func.Function,
@@ -54,6 +57,7 @@ class FunctionCall(Expr):
         order_by_clause: Optional[list[Any]] = None,
         group_by_clause: Optional[list[Any]] = None,
         is_method_call: bool = False,
+        validation_error: Optional[str] = None,
     ):
         assert not fn.is_polymorphic
         assert all(isinstance(arg, Expr) for arg in args)
@@ -76,26 +80,6 @@ class FunctionCall(Expr):
         self.components.extend(arg.copy() for arg in kwargs.values())
         self.kwarg_idxs = {name: i + len(args) for i, name in enumerate(kwargs.keys())}
 
-        # Now generate bound_idxs for the args and kwargs indices.
-        # This is guaranteed to work, because at this point the call has already been validated.
-        # These will be used later to dereference specific parameter values.
-        bindings = fn.signature.py_signature.bind(*self.arg_idxs, **self.kwarg_idxs)
-        self.bound_idxs = bindings.arguments
-
-        # Separately generate bound_args for purposes of determining the resource pool.
-        bindings = fn.signature.py_signature.bind(*args, **kwargs)
-        bound_args = bindings.arguments
-        self.resource_pool = fn.call_resource_pool(bound_args)
-
-        self.agg_init_args = {}
-        if self.is_agg_fn_call:
-            # We separate out the init args for the aggregator. Unpack Literals in init args.
-            assert isinstance(fn, func.AggregateFunction)
-            for arg_name, arg in bound_args.items():
-                if arg_name in fn.init_param_names[0]:
-                    assert isinstance(arg, Literal)  # This was checked during validate_call
-                    self.agg_init_args[arg_name] = arg.val
-
         # window function state:
         # self.components[self.group_by_start_idx:self.group_by_stop_idx] contains group_by exprs
         self.group_by_start_idx, self.group_by_stop_idx = 0, 0
@@ -125,10 +109,35 @@ class FunctionCall(Expr):
             raise excs.Error(
                 f'order_by argument needs to be a Pixeltable expression, but instead is a {type(order_by_clause[0])}'
             )
-        # don't add components after this, everthing after order_by_start_idx is part of the order_by clause
         self.order_by_start_idx = len(self.components)
         self.components.extend(order_by_clause)
 
+        self._validation_error = validation_error
+
+        if validation_error is not None:
+            self.resource_pool = None
+            return
+
+        # Now generate bound_idxs for the args and kwargs indices.
+        # This is guaranteed to work, because at this point the call has already been validated.
+        # These will be used later to dereference specific parameter values.
+        bindings = fn.signature.py_signature.bind(*self.arg_idxs, **self.kwarg_idxs)
+        self.bound_idxs = bindings.arguments
+
+        # Separately generate bound_args for purposes of determining the resource pool.
+        bindings = fn.signature.py_signature.bind(*args, **kwargs)
+        bound_args = bindings.arguments
+        self.resource_pool = fn.call_resource_pool(bound_args)
+
+        self.agg_init_args = {}
+        if self.is_agg_fn_call:
+            # We separate out the init args for the aggregator. Unpack Literals in init args.
+            assert isinstance(fn, func.AggregateFunction)
+            for arg_name, arg in bound_args.items():
+                if arg_name in fn.init_param_names[0]:
+                    assert isinstance(arg, Literal)  # This was checked during validate_call
+                    self.agg_init_args[arg_name] = arg.val
+
         # execution state for aggregate functions
         self.aggregator = None
         self.current_partition_vals = None
@@ -137,50 +146,50 @@ class FunctionCall(Expr):
 
     def _create_rowid_refs(self, tbl: catalog.Table) -> list[Expr]:
         target = tbl._tbl_version_path.tbl_version
-        return [RowidRef(target, i) for i in range(target.num_rowid_columns())]
+        return [RowidRef(target, i) for i in range(target.get().num_rowid_columns())]
 
     def default_column_name(self) -> Optional[str]:
         return self.fn.name
 
     def _equals(self, other: FunctionCall) -> bool:
-        if self.fn != other.fn:
-            return False
-        if self.arg_idxs != other.arg_idxs:
-            return False
-        if self.kwarg_idxs != other.kwarg_idxs:
-            return False
-        if self.group_by_start_idx != other.group_by_start_idx:
-            return False
-        if self.group_by_stop_idx != other.group_by_stop_idx:
-            return False
-        if self.order_by_start_idx != other.order_by_start_idx:
-            return False
-        return True
+        return (
+            self.fn == other.fn
+            and self.arg_idxs == other.arg_idxs
+            and self.kwarg_idxs == other.kwarg_idxs
+            and self.group_by_start_idx == other.group_by_start_idx
+            and self.group_by_stop_idx == other.group_by_stop_idx
+            and self.order_by_start_idx == other.order_by_start_idx
+        )
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [
+        return [
+            *super()._id_attrs(),
             ('fn', id(self.fn)),  # use the function pointer, not the fqn, which isn't set for lambdas
             ('args', self.arg_idxs),
             ('kwargs', self.kwarg_idxs),
             ('group_by_start_idx', self.group_by_start_idx),
             ('group_by_stop_idx', self.group_by_stop_idx),
             ('fn_expr_idx', self.fn_expr_idx),
-            ('order_by_idx', self.order_by_start_idx),
+            ('order_by_start_idx', self.order_by_start_idx),
         ]
 
     def __repr__(self) -> str:
         return self.display_str()
 
+    @property
+    def validation_error(self) -> Optional[str]:
+        return self._validation_error or super().validation_error
+
     def display_str(self, inline: bool = True) -> str:
         if self.is_method_call:
             return f'{self.components[0]}.{self.fn.name}({self._print_args(1, inline)})'
         else:
-            fn_name = self.fn.display_name if self.fn.display_name != '' else 'anonymous_fn'
+            fn_name = self.fn.display_name or 'anonymous_fn'
             return f'{fn_name}({self._print_args()})'
 
     def _print_args(self, start_idx: int = 0, inline: bool = True) -> str:
         arg_strs = [str(self.components[idx]) for idx in self.arg_idxs[start_idx:]]
-        arg_strs.extend([f'{param_name}={str(self.components[idx])}' for param_name, idx in self.kwarg_idxs.items()])
+        arg_strs.extend([f'{param_name}={self.components[idx]}' for param_name, idx in self.kwarg_idxs.items()])
         if len(self.order_by) > 0:
             assert isinstance(self.fn, func.AggregateFunction)
             if self.fn.requires_order_by:
@@ -232,6 +241,8 @@ class FunctionCall(Expr):
         return self.order_by
 
     def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
+        assert self.is_valid
+
         # we currently can't translate aggregate functions with grouping and/or ordering to SQL
         if self.has_group_by() or len(self.order_by) > 0:
             return None
@@ -278,7 +289,7 @@ class FunctionCall(Expr):
             if (
                 val is None
                 and parameters_by_pos[idx].kind
-                in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)
+                in {inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}
                 and not parameters_by_pos[idx].col_type.nullable
             ):
                 return None
@@ -291,7 +302,7 @@ class FunctionCall(Expr):
             if (
                 val is None
                 and parameters[param_name].kind
-                in (inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)
+                in {inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}
                 and not parameters[param_name].col_type.nullable
             ):
                 return None
@@ -304,6 +315,7 @@ class FunctionCall(Expr):
         Returns a list of dicts mapping each param name to its value when this FunctionCall is evaluated against
         data_rows
         """
+        assert self.is_valid
         assert all(name in self.fn.signature.parameters for name in param_names), f'{param_names}, {self.fn.signature}'
         result: list[dict[str, Any]] = []
         for row in data_rows:
@@ -327,6 +339,8 @@ class FunctionCall(Expr):
         return result
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        assert self.is_valid
+
         if isinstance(self.fn, func.ExprTemplateFunction):
             # we need to evaluate the template
             # TODO: can we get rid of this extra copy?
@@ -396,51 +410,66 @@ class FunctionCall(Expr):
         group_by_exprs = components[group_by_start_idx:group_by_stop_idx]
         order_by_exprs = components[order_by_start_idx:]
 
+        validation_error: Optional[str] = None
+
+        if isinstance(fn, func.InvalidFunction):
+            validation_error = (
+                dedent(
+                    f"""
+                    The UDF '{fn.self_path}' cannot be located, because
+                    {{errormsg}}
+                    """
+                )
+                .strip()
+                .format(errormsg=fn.errormsg)
+            )
+            return cls(fn, args, kwargs, return_type, is_method_call=is_method_call, validation_error=validation_error)
+
         # Now re-bind args and kwargs using the version of `fn` that is currently represented in code. This ensures
         # that we get a valid binding even if the signatures of `fn` have changed since the FunctionCall was
         # serialized.
 
-        resolved_fn: func.Function
-        bound_args: dict[str, Expr]
+        resolved_fn: func.Function = fn
 
         try:
+            # Bind args and kwargs to the function signature in the current codebase.
             resolved_fn, bound_args = fn._bind_to_matching_signature(args, kwargs)
         except (TypeError, excs.Error):
-            # TODO: Handle this more gracefully (instead of failing the DB load, allow the DB load to succeed, but
-            #       mark any enclosing FunctionCall as unusable). It's the same issue as dealing with a renamed UDF or
-            #       FunctionCall return type mismatch.
             signature_note_str = 'any of its signatures' if fn.is_polymorphic else 'its signature'
-            instance_signature_str = f'{len(fn.signatures)} signatures' if fn.is_polymorphic else str(fn.signature)
-            raise excs.Error(
-                f'The signature stored in the database for the UDF `{fn.self_path}` no longer matches '
-                f'{signature_note_str} as currently defined in the code.\nThis probably means that the code for '
-                f'`{fn.self_path}` has changed in a backward-incompatible way.\n'
-                f'Signature in database: {fn}\n'
-                f'Signature as currently defined in code: {instance_signature_str}'
-            )
-
-        # Evaluate the call_return_type as defined in the current codebase.
-        call_return_type = resolved_fn.call_return_type(bound_args)
-
-        if return_type is None:
-            # Schema versions prior to 25 did not store the return_type in metadata, and there is no obvious way to
-            # infer it during DB migration, so we might encounter a stored return_type of None. In that case, we use
-            # the call_return_type that we just inferred (which matches the deserialization behavior prior to
-            # version 25).
-            return_type = call_return_type
+            args_str = [str(arg.col_type) for arg in args]
+            args_str.extend(f'{name}: {arg.col_type}' for name, arg in kwargs.items())
+            call_signature_str = f'({", ".join(args_str)}) -> {return_type}'
+            fn_signature_str = f'{len(fn.signatures)} signatures' if fn.is_polymorphic else str(fn.signature)
+            validation_error = dedent(
+                f"""
+                The signature stored in the database for a UDF call to {fn.self_path!r} no longer
+                matches {signature_note_str} as currently defined in the code. This probably means that the
+                code for {fn.self_path!r} has changed in a backward-incompatible way.
+                Signature of UDF call in the database: {call_signature_str}
+                Signature of UDF as currently defined in code: {fn_signature_str}
+                """
+            ).strip()
         else:
-            # There is a return_type stored in metadata (schema version >= 25).
-            # Check that the stored return_type of the UDF call matches the column type of the FunctionCall, and
-            # fail-fast if it doesn't (otherwise we risk getting downstream database errors).
-            # TODO: Handle this more gracefully (as noted above).
-            if not return_type.is_supertype_of(call_return_type, ignore_nullable=True):
-                raise excs.Error(
-                    f'The return type stored in the database for a UDF call to `{fn.self_path}` no longer matches the '
-                    f'return type of the UDF as currently defined in the code.\nThis probably means that the code for '
-                    f'`{fn.self_path}` has changed in a backward-incompatible way.\n'
-                    f'Return type in database: `{return_type}`\n'
-                    f'Return type as currently defined in code: `{call_return_type}`'
-                )
+            # Evaluate the call_return_type as defined in the current codebase.
+            call_return_type = resolved_fn.call_return_type(bound_args)
+            if return_type is None:
+                # Schema versions prior to 25 did not store the return_type in metadata, and there is no obvious way to
+                # infer it during DB migration, so we might encounter a stored return_type of None. In that case, we use
+                # the call_return_type that we just inferred (which matches the deserialization behavior prior to
+                # version 25).
+                return_type = call_return_type
+            elif not return_type.is_supertype_of(call_return_type, ignore_nullable=True):
+                # There is a return_type stored in metadata (schema version >= 25),
+                # and the stored return_type of the UDF call doesn't match the column type of the FunctionCall.
+                validation_error = dedent(
+                    f"""
+                    The return type stored in the database for a UDF call to {fn.self_path!r} no longer
+                    matches its return type as currently defined in the code. This probably means that the
+                    code for {fn.self_path!r} has changed in a backward-incompatible way.
+                    Return type of UDF call in the database: {return_type}
+                    Return type of UDF as currently defined in code: {call_return_type}
+                    """
+                ).strip()
 
         fn_call = cls(
             resolved_fn,
@@ -450,6 +479,7 @@ class FunctionCall(Expr):
             group_by_clause=group_by_exprs,
             order_by_clause=order_by_exprs,
             is_method_call=is_method_call,
+            validation_error=validation_error,
         )
 
         return fn_call

pixeltable/exprs/globals.py

@@ -36,7 +36,7 @@ class ComparisonOperator(enum.Enum):
             return '>'
         if self == self.GE:
             return '>='
-        assert False
+        raise AssertionError()
 
     def reverse(self) -> ComparisonOperator:
         if self == self.LT:
@@ -62,7 +62,7 @@ class LogicalOperator(enum.Enum):
             return '|'
         if self == self.NOT:
             return '~'
-        assert False
+        raise AssertionError()
 
 
 class ArithmeticOperator(enum.Enum):
@@ -86,4 +86,4 @@ class ArithmeticOperator(enum.Enum):
             return '%'
         if self == self.FLOORDIV:
             return '//'
-        assert False
+        raise AssertionError()

pixeltable/exprs/in_predicate.py

@@ -71,7 +71,7 @@ class InPredicate(Expr):
         return self.value_list == other.value_list
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('value_list', self.value_list)]
+        return [*super()._id_attrs(), ('value_list', self.value_list)]
 
     def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
         lhs_sql_exprs = sql_elements.get(self.components[0])

pixeltable/exprs/inline_expr.py

@@ -131,7 +131,7 @@ class InlineList(Expr):
     def as_literal(self) -> Optional[Literal]:
         if not all(isinstance(comp, Literal) for comp in self.components):
             return None
-        return Literal(list(c.as_literal().val for c in self.components), self.col_type)
+        return Literal([c.as_literal().val for c in self.components], self.col_type)
 
 
 class InlineDict(Expr):
@@ -166,7 +166,7 @@ class InlineDict(Expr):
         self.id = self._create_id()
 
     def __repr__(self) -> str:
-        item_strs = list(f"'{key}': {str(expr)}" for key, expr in zip(self.keys, self.components))
+        item_strs = [f"'{key}': {expr}" for key, expr in zip(self.keys, self.components)]
         return '{' + ', '.join(item_strs) + '}'
 
     def _equals(self, other: InlineDict) -> bool:
@@ -174,7 +174,7 @@ class InlineDict(Expr):
         return self.keys == other.keys
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('keys', self.keys)]
+        return [*super()._id_attrs(), ('keys', self.keys)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         return None

pixeltable/exprs/is_null.py

@@ -19,7 +19,7 @@ class IsNull(Expr):
         self.id = self._create_id()
 
     def __repr__(self) -> str:
-        return f'{str(self.components[0])} == None'
+        return f'{self.components[0]} == None'
 
     def _equals(self, other: IsNull) -> bool:
         return True

pixeltable/exprs/json_mapper.py

@@ -81,12 +81,12 @@ class JsonMapper(Expr):
         """
         We override equals() because we need to avoid comparing our scope anchor.
         """
-        if type(self) != type(other):
+        if type(self) is not type(other):
             return False
         return self._src_expr.equals(other._src_expr) and self._target_expr.equals(other._target_expr)
 
     def __repr__(self) -> str:
-        return f'{str(self._src_expr)} >> {str(self._target_expr)}'
+        return f'{self._src_expr} >> {self._target_expr}'
 
     @property
     def _src_expr(self) -> Expr:

pixeltable/exprs/json_path.py

@@ -6,14 +6,13 @@ import jmespath
 import sqlalchemy as sql
 
 import pixeltable as pxt
-import pixeltable.catalog as catalog
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
+from pixeltable import catalog, exceptions as excs, type_system as ts
 
 from .data_row import DataRow
 from .expr import Expr
 from .globals import print_slice
 from .json_mapper import JsonMapper
+from .object_ref import ObjectRef
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
 
@@ -50,8 +49,16 @@ class JsonPath(Expr):
         return f'{anchor_str}{"." if isinstance(self.path_elements[0], str) else ""}{self._json_path()}'
 
     def _as_dict(self) -> dict:
+        assert len(self.components) <= 1
+        components_dict: dict[str, Any]
+        if len(self.components) == 0 or isinstance(self.components[0], ObjectRef):
+            # If the anchor is an ObjectRef, it means this JsonPath is a bound relative path. We store it as a relative
+            # path, *not* a bound path (which has no meaning in the dict).
+            components_dict = {}
+        else:
+            components_dict = super()._as_dict()
         path_elements = [[el.start, el.stop, el.step] if isinstance(el, slice) else el for el in self.path_elements]
-        return {'path_elements': path_elements, 'scope_idx': self.scope_idx, **super()._as_dict()}
+        return {'path_elements': path_elements, 'scope_idx': self.scope_idx, **components_dict}
 
     @classmethod
     def _from_dict(cls, d: dict, components: list[Expr]) -> JsonPath:
@@ -84,18 +91,18 @@ class JsonPath(Expr):
         Construct a relative path that references an ancestor of the immediately enclosing JsonMapper.
         """
         if not self.is_relative_path():
-            raise excs.Error(f'() for an absolute path is invalid')
+            raise excs.Error('() for an absolute path is invalid')
         if len(args) != 1 or not isinstance(args[0], int) or args[0] >= 0:
-            raise excs.Error(f'R() requires a negative index')
+            raise excs.Error('R() requires a negative index')
         return JsonPath(None, [], args[0])
 
     def __getattr__(self, name: str) -> 'JsonPath':
         assert isinstance(name, str)
-        return JsonPath(self._anchor, self.path_elements + [name])
+        return JsonPath(self._anchor, [*self.path_elements, name])
 
     def __getitem__(self, index: object) -> 'JsonPath':
         if isinstance(index, (int, slice, str)):
-            return JsonPath(self._anchor, self.path_elements + [index])
+            return JsonPath(self._anchor, [*self.path_elements, index])
         raise excs.Error(f'Invalid json list index: {index}')
 
     def __rshift__(self, other: object) -> 'JsonMapper':
@@ -120,7 +127,7 @@ class JsonPath(Expr):
 
         clean_name = ''.join(map(cleanup_char, ret_name))
         clean_name = clean_name.lstrip('_')  # remove leading underscore
-        if clean_name == '':
+        if not clean_name:  # Replace '' with None
             clean_name = None
 
         assert clean_name is None or catalog.is_valid_identifier(clean_name)
@@ -130,7 +137,7 @@ class JsonPath(Expr):
         return self.path_elements == other.path_elements
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('path_elements', self.path_elements)]
+        return [*super()._id_attrs(), ('path_elements', self.path_elements)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         """

pixeltable/exprs/literal.py

@@ -62,7 +62,7 @@ class Literal(Expr):
         return self.val == other.val
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('val', self.val)]
+        return [*super()._id_attrs(), ('val', self.val)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         # Return a sql object so that constants can participate in SQL expressions

pixeltable/exprs/method_ref.py

@@ -53,13 +53,13 @@ class MethodRef(Expr):
         return self.base_expr.id == other.base_expr.id and self.method_name == other.method_name
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [('method_name', self.method_name)]
+        return [*super()._id_attrs(), ('method_name', self.method_name)]
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
-        assert False, 'MethodRef cannot be evaluated directly'
+        raise AssertionError('MethodRef cannot be evaluated directly')
 
     def __repr__(self) -> str:
         return f'{self.base_expr}.{self.method_name}'

pixeltable/exprs/row_builder.py

@@ -7,12 +7,8 @@ from typing import Any, Iterable, Optional, Sequence
 from uuid import UUID
 
 import numpy as np
-import sqlalchemy as sql
 
-import pixeltable.catalog as catalog
-import pixeltable.exceptions as excs
-import pixeltable.func as func
-import pixeltable.utils as utils
+from pixeltable import catalog, exceptions as excs, utils
 from pixeltable.env import Env
 from pixeltable.utils.media_store import MediaStore
 
@@ -174,11 +170,13 @@ class RowBuilder:
 
         def refs_unstored_iter_col(col_ref: ColumnRef) -> bool:
             tbl = col_ref.col.tbl
-            return tbl.is_component_view() and tbl.is_iterator_column(col_ref.col) and not col_ref.col.is_stored
+            return (
+                tbl.get().is_component_view and tbl.get().is_iterator_column(col_ref.col) and not col_ref.col.is_stored
+            )
 
         unstored_iter_col_refs = [col_ref for col_ref in col_refs if refs_unstored_iter_col(col_ref)]
         component_views = [col_ref.col.tbl for col_ref in unstored_iter_col_refs]
-        unstored_iter_args = {view.id: view.iterator_args.copy() for view in component_views}
+        unstored_iter_args = {view.id: view.get().iterator_args.copy() for view in component_views}
         self.unstored_iter_args = {
             id: self._record_unique_expr(arg, recursive=True) for id, arg in unstored_iter_args.items()
         }
@@ -236,13 +234,6 @@ class RowBuilder:
         """Return ColumnSlotIdx for output columns"""
         return self.table_columns
 
-    def set_conn(self, conn: sql.engine.Connection) -> None:
-        from .function_call import FunctionCall
-
-        for expr in self.unique_exprs:
-            if isinstance(expr, FunctionCall) and isinstance(expr.fn, func.QueryTemplateFunction):
-                expr.fn.set_conn(conn)
-
     @property
     def num_materialized(self) -> int:
         return self.next_slot_idx
@@ -373,8 +364,8 @@ class RowBuilder:
     def set_exc(self, data_row: DataRow, slot_idx: int, exc: Exception) -> None:
         """Record an exception in data_row and propagate it to dependents"""
         data_row.set_exc(slot_idx, exc)
-        for slot_idx in self._exc_dependents[slot_idx]:
-            data_row.set_exc(slot_idx, exc)
+        for idx in self._exc_dependents[slot_idx]:
+            data_row.set_exc(idx, exc)
 
     def eval(
         self,
@@ -432,7 +423,7 @@ class RowBuilder:
             else:
                 if col.col_type.is_image_type() and data_row.file_urls[slot_idx] is None:
                     # we have yet to store this image
-                    filepath = str(MediaStore.prepare_media_path(col.tbl.id, col.id, col.tbl.version))
+                    filepath = str(MediaStore.prepare_media_path(col.tbl.id, col.id, col.tbl.get().version))
                     data_row.flush_img(slot_idx, filepath)
                 val = data_row.get_stored_val(slot_idx, col.sa_col.type)
                 table_row[col.store_name()] = val

pixeltable/exprs/rowid_ref.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any, Optional, cast
 from uuid import UUID
 
 import sqlalchemy as sql
 
-import pixeltable.catalog as catalog
-import pixeltable.type_system as ts
+from pixeltable import catalog, type_system as ts
 
 from .data_row import DataRow
 from .expr import Expr
@@ -23,9 +22,15 @@ class RowidRef(Expr):
     (with and without a TableVersion).
     """
 
+    tbl: Optional[catalog.TableVersionHandle]
+    normalized_base: Optional[catalog.TableVersionHandle]
+    tbl_id: UUID
+    normalized_base_id: UUID
+    rowid_component_idx: int
+
     def __init__(
         self,
-        tbl: catalog.TableVersion,
+        tbl: catalog.TableVersionHandle,
         idx: int,
         tbl_id: Optional[UUID] = None,
         normalized_base_id: Optional[UUID] = None,
@@ -37,8 +42,8 @@ class RowidRef(Expr):
             # (which has the same values as all its descendent views)
             normalized_base = tbl
             # don't try to reference tbl.store_tbl here
-            while normalized_base.base is not None and normalized_base.base.num_rowid_columns() > idx:
-                normalized_base = normalized_base.base
+            while normalized_base.get().base is not None and normalized_base.get().base.get().num_rowid_columns() > idx:
+                normalized_base = normalized_base.get().base
             self.normalized_base = normalized_base
         else:
             self.normalized_base = None
@@ -59,15 +64,21 @@ class RowidRef(Expr):
         )
 
     def _id_attrs(self) -> list[tuple[str, Any]]:
-        return super()._id_attrs() + [
+        return [
+            *super()._id_attrs(),
             ('normalized_base_id', self.normalized_base_id),
             ('idx', self.rowid_component_idx),
         ]
 
     def __repr__(self) -> str:
         # check if this is the pos column of a component view
-        tbl = self.tbl if self.tbl is not None else catalog.Catalog.get().tbl_versions[(self.tbl_id, None)]
-        if tbl.is_component_view() and self.rowid_component_idx == tbl.store_tbl.pos_col_idx:  # type: ignore[attr-defined]
+        from pixeltable import store
+
+        tbl = self.tbl.get() if self.tbl is not None else catalog.Catalog.get().get_tbl_version(self.tbl_id, None)
+        if (
+            tbl.is_component_view
+            and self.rowid_component_idx == cast(store.StoreComponentView, tbl.store_tbl).pos_col_idx
+        ):
             return catalog.globals._POS_COLUMN_NAME
         return ''
 
@@ -85,7 +96,7 @@ class RowidRef(Expr):
         self.tbl_id = self.tbl.id
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
-        tbl = self.tbl if self.tbl is not None else catalog.Catalog.get().tbl_versions[(self.tbl_id, None)]
+        tbl = self.tbl.get() if self.tbl is not None else catalog.Catalog.get().get_tbl_version(self.tbl_id, None)
         rowid_cols = tbl.store_tbl.rowid_columns()
         return rowid_cols[self.rowid_component_idx]