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

pixeltable/exprs/literal.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+import base64
 import datetime
-from typing import Any, Optional
+import uuid
+from typing import Any
 
 import numpy as np
 import sqlalchemy as sql
@@ -16,7 +18,9 @@ from .sql_element_cache import SqlElementCache
 
 
 class Literal(Expr):
-    def __init__(self, val: Any, col_type: Optional[ts.ColumnType] = None):
+    val: Any
+
+    def __init__(self, val: Any, col_type: ts.ColumnType | None = None):
         if col_type is not None:
             val = col_type.create_literal(val)
         else:
@@ -40,7 +44,7 @@ class Literal(Expr):
         self.val = val
         self.id = self._create_id()
 
-    def default_column_name(self) -> Optional[str]:
+    def default_column_name(self) -> str | None:
         return 'Literal'
 
     def __str__(self) -> str:
@@ -53,6 +57,9 @@ class Literal(Expr):
         if self.col_type.is_date_type():
             assert isinstance(self.val, datetime.date)
             return f"'{self.val.isoformat()}'"
+        if self.col_type.is_uuid_type():
+            assert isinstance(self.val, uuid.UUID)
+            return f"'{self.val}'"
         if self.col_type.is_array_type():
             assert isinstance(self.val, np.ndarray)
             return str(self.val.tolist())
@@ -67,7 +74,7 @@ class Literal(Expr):
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return [*super()._id_attrs(), ('val', self.val)]
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         # Return a sql object so that constants can participate in SQL expressions
         return sql.sql.expression.literal(self.val, type_=self.col_type.to_sa_type())
 
@@ -89,13 +96,21 @@ class Literal(Expr):
             assert isinstance(self.val, datetime.date)
             encoded_val = self.val.isoformat()
             return {'val': encoded_val, 'val_t': self.col_type._type.name, **super()._as_dict()}
+        elif self.col_type.is_uuid_type():
+            assert isinstance(self.val, uuid.UUID)
+            encoded_val = str(self.val)
+            return {'val': encoded_val, 'val_t': self.col_type._type.name, **super()._as_dict()}
+        elif self.col_type.is_binary_type():
+            assert isinstance(self.val, bytes)
+            encoded_val = base64.b64encode(self.val).decode('utf-8')
+            return {'val': encoded_val, 'val_t': self.col_type._type.name, **super()._as_dict()}
         elif self.col_type.is_array_type():
             assert isinstance(self.val, np.ndarray)
             return {'val': self.val.tolist(), 'val_t': self.col_type._type.name, **super()._as_dict()}
         else:
             return {'val': self.val, **super()._as_dict()}
 
-    def as_literal(self) -> Optional[Literal]:
+    def as_literal(self) -> Literal | None:
         return self
 
     @classmethod
@@ -110,6 +125,13 @@ class Literal(Expr):
                 dt = datetime.datetime.fromisoformat(d['val'])
                 assert dt.tzinfo == datetime.timezone.utc  # Must be UTC in the database
                 return cls(dt)
+            elif val_t == ts.ColumnType.Type.UUID.name:
+                uuid_val = uuid.UUID(d['val'])
+                return cls(uuid_val)
+            elif val_t == ts.ColumnType.Type.BINARY.name:
+                assert isinstance(d['val'], str)
+                bytes_val = base64.b64decode(d['val'].encode('utf-8'))
+                return cls(bytes_val)
             elif val_t == ts.ColumnType.Type.ARRAY.name:
                 arrays = np.array(d['val'])
                 return cls(arrays)

pixeltable/exprs/method_ref.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 import sqlalchemy as sql
 
@@ -55,7 +55,7 @@ class MethodRef(Expr):
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return [*super()._id_attrs(), ('method_name', self.method_name)]
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:

pixeltable/exprs/object_ref.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 import sqlalchemy as sql
 
@@ -43,7 +43,7 @@ class ObjectRef(Expr):
     def _equals(self, other: ObjectRef) -> bool:
         return self.id == other.id
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:

pixeltable/exprs/row_builder.py

@@ -1,21 +1,25 @@
 from __future__ import annotations
 
+import dataclasses
 import sys
 import time
-from dataclasses import dataclass
-from typing import Any, Iterable, Optional, Sequence
+from typing import TYPE_CHECKING, Any, Iterable, NamedTuple, Sequence, TypeVar
 from uuid import UUID
 
 import numpy as np
+import sqlalchemy as sql
 
-from pixeltable import catalog, exceptions as excs, utils
+from pixeltable import catalog, exceptions as excs, exprs, utils
 from pixeltable.env import Env
-from pixeltable.utils.media_store import MediaStore
+from pixeltable.utils.misc import non_none_dict_factory
 
 from .data_row import DataRow
 from .expr import Expr, ExprScope
 from .expr_set import ExprSet
 
+if TYPE_CHECKING:
+    from .column_ref import ColumnRef
+
 
 class ExecProfile:
     def __init__(self, row_builder: RowBuilder):
@@ -35,8 +39,7 @@ class ExecProfile:
             )
 
 
-@dataclass
-class ColumnSlotIdx:
+class ColumnSlotIdx(NamedTuple):
     """Info for how to locate materialized column in DataRow
     TODO: can this be integrated into RowBuilder directly?
     """
@@ -50,6 +53,12 @@ class RowBuilder:
 
     For ColumnRefs to unstored iterator columns:
     - in order for them to be executable, we also record the iterator args and pass them to the ColumnRef
+
+    Args:
+        output_exprs: list of Exprs to be evaluated
+        columns: list of columns to be materialized
+        input_exprs: list of Exprs that are excluded from evaluation (because they're already materialized)
+    TODO: enforce that output_exprs doesn't overlap with input_exprs?
     """
 
     unique_exprs: ExprSet
@@ -63,9 +72,13 @@ class RowBuilder:
 
     input_exprs: ExprSet
 
-    table_columns: list[ColumnSlotIdx]
+    tbl: catalog.TableVersion | None  # reference table of the RowBuilder; used to identify pk columns for writes
+    for_view_load: bool  # True if this RowBuilder represents a view load
+
+    table_columns: dict[catalog.Column, int | None]  # value: slot idx, if the result of an expr
     default_eval_ctx: EvalCtx
     unstored_iter_args: dict[UUID, Expr]
+    unstored_iter_outputs: dict[UUID, list['ColumnRef']]
 
     # transitive dependents for the purpose of exception propagation: an exception for slot i is propagated to
     # _exc_dependents[i]
@@ -84,7 +97,12 @@ class RowBuilder:
     # (a subexpr can be shared across multiple output exprs)
     output_expr_ids: list[set[int]]
 
-    @dataclass
+    img_slot_idxs: list[int]  # Indices of image slots
+    media_slot_idxs: list[int]  # Indices of non-image media slots
+    array_slot_idxs: list[int]  # Indices of array slots
+    json_slot_idxs: list[int]  # Indices of json slots
+
+    @dataclasses.dataclass
     class EvalCtx:
         """Context for evaluating a set of target exprs"""
 
@@ -93,41 +111,45 @@ class RowBuilder:
         target_slot_idxs: list[int]  # slot idxs of target exprs; might contain duplicates
         target_exprs: list[Expr]  # exprs corresponding to target_slot_idxs
 
-    def __init__(self, output_exprs: Sequence[Expr], columns: Sequence[catalog.Column], input_exprs: Iterable[Expr]):
-        """
-        Args:
-            output_exprs: list of Exprs to be evaluated
-            columns: list of columns to be materialized
-            input_exprs: list of Exprs that are excluded from evaluation (because they're already materialized)
-        TODO: enforce that output_exprs doesn't overlap with input_exprs?
-        """
+    def __init__(
+        self,
+        output_exprs: Sequence[Expr],
+        columns: Sequence[catalog.Column],
+        input_exprs: Iterable[Expr],
+        tbl: catalog.TableVersion | None = None,
+        for_view_load: bool = False,
+    ):
+        from .column_property_ref import ColumnPropertyRef
+        from .column_ref import ColumnRef
+
         self.unique_exprs: ExprSet[Expr] = ExprSet()  # dependencies precede their dependents
         self.next_slot_idx = 0
 
-        # record input and output exprs; make copies to avoid reusing execution state
+        # record input exprs; make copies to avoid reusing execution state
         unique_input_exprs = [self._record_unique_expr(e.copy(), recursive=False) for e in input_exprs]
+
         self.input_expr_slot_idxs = {e.slot_idx for e in unique_input_exprs}
 
         resolve_cols = set(columns)
         self.output_exprs = ExprSet(
-            [
-                self._record_unique_expr(e.copy().resolve_computed_cols(resolve_cols=resolve_cols), recursive=True)
-                for e in output_exprs
-            ]
+            self._record_unique_expr(e.copy().resolve_computed_cols(resolve_cols=resolve_cols), recursive=True)
+            for e in output_exprs
         )
 
         # if init(columns):
-        # - we are creating table rows and need to record columns for create_table_row()
+        # - we are creating table rows and need to record columns for create_store_table_row()
         # - output_exprs materialize those columns
         # - input_exprs are ColumnRefs of the non-computed columns (ie, what needs to be provided as input)
         # - media validation:
         #   * for write-validated columns, we need to create validating ColumnRefs
         #   * further references to that column (eg, computed cols) need to resolve to the validating ColumnRef
-        from .column_ref import ColumnRef
 
-        self.table_columns: list[ColumnSlotIdx] = []
+        self.for_view_load = for_view_load
+        self.tbl = tbl
+        self.table_columns = {}
         self.input_exprs = ExprSet()
         validating_colrefs: dict[Expr, Expr] = {}  # key: non-validating colref, value: corresp. validating colref
+
         for col in columns:
             expr: Expr
             if col.is_computed:
@@ -168,24 +190,39 @@ class RowBuilder:
         #   because that would cause them to be evaluated for every single row
         # - the separate eval ctx allows the ColumnRef to materialize the iterator args only when the underlying
         #   iterated object changes
+
         col_refs = [e for e in self.unique_exprs if isinstance(e, ColumnRef)]
 
         def refs_unstored_iter_col(col_ref: ColumnRef) -> bool:
-            tbl = col_ref.col.tbl
-            return (
-                tbl.get().is_component_view and tbl.get().is_iterator_column(col_ref.col) and not col_ref.col.is_stored
-            )
+            tbl = col_ref.col.get_tbl()
+            return tbl.is_component_view and tbl.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.get().iterator_args.copy() for view in component_views}
+        component_views = [col_ref.col.get_tbl() for col_ref in unstored_iter_col_refs]
+        unstored_iter_args = {view.id: view.iterator_args.copy() for view in component_views}
+
+        # the *stored* output columns of the unstored iterators
+        self.unstored_iter_outputs = {
+            view.id: [
+                self._record_unique_expr(ColumnRef(col), recursive=True)
+                for col in view.iterator_columns()
+                if col.is_stored
+            ]
+            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()
+            id: self._record_unique_expr(args, recursive=True) for id, args in unstored_iter_args.items()
         }
 
+        unstored_iter_col_refs = [
+            self._record_unique_expr(col_ref, recursive=True) for col_ref in unstored_iter_col_refs
+        ]
+
         for col_ref in unstored_iter_col_refs:
-            iter_arg_ctx = self.create_eval_ctx([unstored_iter_args[col_ref.col.tbl.id]])
-            col_ref.set_iter_arg_ctx(iter_arg_ctx)
+            iter_arg_ctx = self.create_eval_ctx([self.unstored_iter_args[col_ref.col.get_tbl().id]])
+            iter_outputs = self.unstored_iter_outputs[col_ref.col.get_tbl().id]
+            col_ref.set_iter_arg_ctx(iter_arg_ctx, iter_outputs)
 
         # we guarantee that we can compute the expr DAG in a single front-to-back pass
         for i, expr in enumerate(self.unique_exprs):
@@ -196,14 +233,13 @@ class RowBuilder:
         # self.dependents = np.zeros((self.num_materialized, self.num_materialized), dtype=bool)
         self.dependencies = np.zeros((self.num_materialized, self.num_materialized), dtype=bool)
         exc_dependencies: list[set[int]] = [set() for _ in range(self.num_materialized)]
-        from .column_property_ref import ColumnPropertyRef
 
         for expr in self.unique_exprs:
             if expr.slot_idx in self.input_expr_slot_idxs:
                 # this is input and therefore doesn't depend on other exprs
                 continue
             # error properties don't have exceptions themselves
-            if isinstance(expr, ColumnPropertyRef) and expr.is_error_prop():
+            if isinstance(expr, ColumnPropertyRef) and expr.is_cellmd_prop():
                 continue
             dependency_idxs = [d.slot_idx for d in expr.dependencies()]
             self.dependencies[expr.slot_idx, dependency_idxs] = True
@@ -229,13 +265,32 @@ class RowBuilder:
         for e in self.output_exprs:
             self._record_output_expr_id(e, e.slot_idx)
 
+        self.img_slot_idxs = [e.slot_idx for e in self.unique_exprs if e.col_type.is_image_type()]
+        self.media_slot_idxs = [
+            e.slot_idx for e in self.unique_exprs if e.col_type.is_media_type() and not e.col_type.is_image_type()
+        ]
+        self.array_slot_idxs = [e.slot_idx for e in self.unique_exprs if e.col_type.is_array_type()]
+        self.json_slot_idxs = [e.slot_idx for e in self.unique_exprs if e.col_type.is_json_type()]
+
     def add_table_column(self, col: catalog.Column, slot_idx: int) -> None:
-        """Record a column that is part of the table row"""
-        self.table_columns.append(ColumnSlotIdx(col, slot_idx))
+        """Record an output column for which the value is produced via expr evaluation"""
+        assert self.tbl is not None
+        assert col.is_stored
+        self.table_columns[col] = slot_idx
 
-    def output_slot_idxs(self) -> list[ColumnSlotIdx]:
-        """Return ColumnSlotIdx for output columns"""
-        return self.table_columns
+    def add_table_columns(self, cols: list[catalog.Column]) -> None:
+        """Record output columns whose values are materialized into DataRow.cell_vals"""
+        for col in cols:
+            self.table_columns[col] = None
+
+    @property
+    def media_output_col_info(self) -> list[ColumnSlotIdx]:
+        """Return slot idxs for media output columns whose values are produced by expr evaluation"""
+        return [
+            ColumnSlotIdx(col, slot_idx)
+            for col, slot_idx in self.table_columns.items()
+            if col.col_type.is_media_type() and slot_idx is not None
+        ]
 
     @property
     def num_materialized(self) -> int:
@@ -250,7 +305,9 @@ class RowBuilder:
         self.next_slot_idx += 1
         return result
 
-    def _record_unique_expr(self, expr: Expr, recursive: bool) -> Expr:
+    T = TypeVar('T', bound=Expr)
+
+    def _record_unique_expr(self, expr: T, recursive: bool) -> T:
         """Records the expr if it's not a duplicate and assigns a slot idx to expr and its components"
         Returns:
             the unique expr
@@ -279,7 +336,7 @@ class RowBuilder:
             self._record_output_expr_id(d, output_expr_id)
 
     def _compute_dependencies(
-        self, target_slot_idxs: list[int], excluded_slot_idxs: list[int], target_scope: Optional[ExprScope] = None
+        self, target_slot_idxs: list[int], excluded_slot_idxs: list[int], target_scope: ExprScope | None = None
     ) -> list[int]:
         """Compute exprs needed to materialize the given target slots, excluding 'excluded_slot_idxs'
 
@@ -333,7 +390,7 @@ class RowBuilder:
             self.__set_slot_idxs_aux(c)
 
     def get_dependencies(
-        self, targets: Iterable[Expr], exclude: Optional[Iterable[Expr]] = None, limit_scope: bool = True
+        self, targets: Iterable[Expr], exclude: Iterable[Expr] | None = None, limit_scope: bool = True
     ) -> list[Expr]:
         """
         Return list of dependencies needed to evaluate the given target exprs (expressed as slot idxs).
@@ -351,7 +408,7 @@ class RowBuilder:
             return []
         # make sure we only refer to recorded exprs
         targets = [self.unique_exprs[e] for e in targets]
-        target_scope: Optional[ExprScope] = None
+        target_scope: ExprScope | None = None
         if limit_scope:
             # make sure all targets are from the same scope
             target_scopes = {e.scope() for e in targets}
@@ -369,7 +426,7 @@ class RowBuilder:
         return [self.unique_exprs[id] for id in result_ids]
 
     def create_eval_ctx(
-        self, targets: Iterable[Expr], exclude: Optional[Iterable[Expr]] = None, limit_scope: bool = True
+        self, targets: Iterable[Expr], exclude: Iterable[Expr] | None = None, limit_scope: bool = True
     ) -> EvalCtx:
         """Return EvalCtx for targets"""
         targets = list(targets)
@@ -398,9 +455,9 @@ class RowBuilder:
         self,
         data_row: DataRow,
         ctx: EvalCtx,
-        profile: Optional[ExecProfile] = None,
+        profile: ExecProfile | None = None,
         ignore_errors: bool = False,
-        force_eval: Optional[ExprScope] = None,
+        force_eval: ExprScope | None = None,
     ) -> None:
         """
         Populates the slots in data_row given in ctx.
@@ -429,33 +486,76 @@ class RowBuilder:
                         expr, f'expression {expr}', data_row.get_exc(expr.slot_idx), exc_tb, input_vals, 0
                     ) from exc
 
-    def create_table_row(self, data_row: DataRow, exc_col_ids: set[int]) -> tuple[dict[str, Any], int]:
-        """Create a table row from the slots that have an output column assigned
+    def create_store_table_row(
+        self, data_row: DataRow, cols_with_excs: set[int] | None, pk: tuple[int, ...]
+    ) -> tuple[list[Any], int]:
+        """Create a store table row from the slots that have an output column assigned
 
-        Return tuple[dict that represents a stored row (can be passed to sql.insert()), # of exceptions]
+        Return tuple[list of row values in `self.table_columns` order, # of exceptions]
             This excludes system columns.
+            Row values are converted to their store type.
         """
+        from pixeltable.exprs.column_property_ref import ColumnPropertyRef
+
         num_excs = 0
-        table_row: dict[str, Any] = {}
-        for info in self.table_columns:
-            col, slot_idx = info.col, info.slot_idx
+        table_row: list[Any] = list(pk)
+        # Nulls in JSONB columns need to be stored as sql.sql.null(), otherwise it stores a json 'null'
+        for col, slot_idx in self.table_columns.items():
+            if col.id in data_row.cell_vals:
+                table_row.append(data_row.cell_vals[col.id])
+                if col.stores_cellmd:
+                    if data_row.cell_md[col.id] is None:
+                        table_row.append(sql.sql.null())
+                    else:
+                        # we want to minimize the size of the stored dict and use dict_factory to remove Nones
+                        md = dataclasses.asdict(data_row.cell_md[col.id], dict_factory=non_none_dict_factory)
+                        assert len(md) > 0
+                        table_row.append(md)
+                if slot_idx is not None and data_row.has_exc(slot_idx):
+                    num_excs += 1
+                    if cols_with_excs is not None:
+                        cols_with_excs.add(col.id)
+                continue
+
             if data_row.has_exc(slot_idx):
-                # exceptions get stored in the errortype/-msg columns
                 exc = data_row.get_exc(slot_idx)
                 num_excs += 1
-                exc_col_ids.add(col.id)
-                table_row[col.store_name()] = None
-                table_row[col.errortype_store_name()] = type(exc).__name__
-                table_row[col.errormsg_store_name()] = str(exc)
+                if cols_with_excs is not None:
+                    cols_with_excs.add(col.id)
+                table_row.append(sql.sql.null() if col.col_type.is_json_type() else None)
+                if col.stores_cellmd:
+                    # exceptions get stored in the errortype/-msg properties of the cellmd column
+                    table_row.append(ColumnPropertyRef.create_cellmd_exc(exc))
             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.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
-                # we unfortunately need to set these, even if there are no errors
-                table_row[col.errortype_store_name()] = None
-                table_row[col.errormsg_store_name()] = None
+                val = data_row.get_stored_val(slot_idx, col.sa_col_type)
+                table_row.append(val)
+                if col.stores_cellmd:
+                    table_row.append(sql.sql.null())  # placeholder for cellmd column
 
         return table_row, num_excs
+
+    def store_column_names(self) -> list[str]:
+        """
+        Returns the list of store column names corresponding to the table_columns of this RowBuilder.
+        The second tuple element of the return value is a dictionary containing all media columns in the
+        table; it's the mapping {list_index: column}.
+        """
+        assert self.tbl is not None, self.table_columns
+        store_col_names: list[str] = [pk_col.name for pk_col in self.tbl.store_tbl.pk_columns()]
+
+        for col in self.table_columns:
+            store_col_names.append(col.store_name())
+            if col.stores_cellmd:
+                store_col_names.append(col.cellmd_store_name())
+
+        return store_col_names
+
+    def make_row(self) -> exprs.DataRow:
+        """Creates a new DataRow with the current row_builder's configuration."""
+        return exprs.DataRow(
+            size=self.num_materialized,
+            img_slot_idxs=self.img_slot_idxs,
+            media_slot_idxs=self.media_slot_idxs,
+            array_slot_idxs=self.array_slot_idxs,
+            json_slot_idxs=self.json_slot_idxs,
+        )

pixeltable/exprs/rowid_ref.py

@@ -1,17 +1,21 @@
 from __future__ import annotations
 
-from typing import Any, Optional, cast
+import logging
+from typing import Any, cast
 from uuid import UUID
 
 import sqlalchemy as sql
 
 from pixeltable import catalog, type_system as ts
+from pixeltable.catalog.table_version import TableVersionKey
 
 from .data_row import DataRow
 from .expr import Expr
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
 
+_logger = logging.getLogger('pixeltable')
+
 
 class RowidRef(Expr):
     """A reference to a part of a table rowid
@@ -22,18 +26,18 @@ class RowidRef(Expr):
     (with and without a TableVersion).
     """
 
-    tbl: Optional[catalog.TableVersionHandle]
-    normalized_base: Optional[catalog.TableVersionHandle]
+    tbl: catalog.TableVersionHandle | None
+    normalized_base: catalog.TableVersionHandle | None
     tbl_id: UUID
     normalized_base_id: UUID
     rowid_component_idx: int
 
     def __init__(
         self,
-        tbl: Optional[catalog.TableVersionHandle],
+        tbl: catalog.TableVersionHandle | None,
         idx: int,
-        tbl_id: Optional[UUID] = None,
-        normalized_base_id: Optional[UUID] = None,
+        tbl_id: UUID | None = None,
+        normalized_base_id: UUID | None = None,
     ):
         super().__init__(ts.IntType(nullable=False))
         self.tbl = tbl
@@ -54,7 +58,7 @@ class RowidRef(Expr):
         self.rowid_component_idx = idx
         self.id = self._create_id()
 
-    def default_column_name(self) -> Optional[str]:
+    def default_column_name(self) -> str | None:
         return str(self)
 
     def _equals(self, other: RowidRef) -> bool:
@@ -74,7 +78,11 @@ class RowidRef(Expr):
         # check if this is the pos column of a component view
         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)
+        tbl = (
+            self.tbl.get()
+            if self.tbl is not None
+            else catalog.Catalog.get().get_tbl_version(TableVersionKey(self.tbl_id, None, None))
+        )
         if (
             tbl.is_component_view
             and self.rowid_component_idx == cast(store.StoreComponentView, tbl.store_tbl).pos_col_idx
@@ -95,8 +103,13 @@ class RowidRef(Expr):
         self.tbl = tbl.tbl_version
         self.tbl_id = self.tbl.id
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
-        tbl = self.tbl.get() if self.tbl is not None else catalog.Catalog.get().get_tbl_version(self.tbl_id, None)
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
+        tbl = (
+            self.tbl.get()
+            if self.tbl is not None
+            else catalog.Catalog.get().get_tbl_version(TableVersionKey(self.tbl_id, None, None))
+        )
+        assert tbl.is_validated
         rowid_cols = tbl.store_tbl.rowid_columns()
         assert self.rowid_component_idx <= len(rowid_cols), (
             f'{self.rowid_component_idx} not consistent with {rowid_cols}'
@@ -107,6 +120,8 @@ class RowidRef(Expr):
         data_row[self.slot_idx] = data_row.pk[self.rowid_component_idx]
 
     def _as_dict(self) -> dict:
+        # TODO: Serialize the full TableVersionHandle, not just the UUID
+        assert self.tbl is None or self.tbl.anchor_tbl_id is None  # TODO: support anchor_tbl_id for view-over-replica
         return {
             'tbl_id': str(self.tbl_id),
             'normalized_base_id': str(self.normalized_base_id),