pixeltable 0.4.0rc3__py3-none-any.whl → 0.4.2__py3-none-any.whl

pixeltable/catalog/table_version.py

@@ -29,7 +29,14 @@ if TYPE_CHECKING:
 
 from ..func.globals import resolve_symbol
 from .column import Column
-from .globals import _POS_COLUMN_NAME, _ROWID_COLUMN_NAME, MediaValidation, UpdateStatus, is_valid_identifier
+from .globals import (
+    _POS_COLUMN_NAME,
+    _ROWID_COLUMN_NAME,
+    MediaValidation,
+    RowCountStats,
+    UpdateStatus,
+    is_valid_identifier,
+)
 
 if TYPE_CHECKING:
     from pixeltable import exec, store
@@ -167,18 +174,6 @@ class TableVersion:
         self.idxs_by_name = {}
         self.external_stores = {}
 
-    def init(self) -> None:
-        """
-        Initialize schema-related in-memory metadata separately, now that this TableVersion instance is visible
-        in Catalog.
-        """
-        from .catalog import Catalog
-
-        assert (self.id, self.effective_version) in Catalog.get()._tbl_versions
-        self._init_schema()
-        # init external stores; this needs to happen after the schema is created
-        self._init_external_stores()
-
     def __hash__(self) -> int:
         return hash(self.id)
 
@@ -195,6 +190,12 @@ class TableVersion:
         else:
             return f'{self.name}:{self.effective_version}'
 
+    @property
+    def handle(self) -> 'TableVersionHandle':
+        from .table_version_handle import TableVersionHandle
+
+        return TableVersionHandle(self.id, self.effective_version, self)
+
     @classmethod
     def create(
         cls,
@@ -207,7 +208,6 @@ class TableVersion:
         # base_path: Optional[pxt.catalog.TableVersionPath] = None,
         view_md: Optional[schema.ViewMd] = None,
     ) -> tuple[UUID, Optional[TableVersion]]:
-        session = Env.get().session
         user = Env.get().user
 
         # assign ids
@@ -224,8 +224,9 @@ class TableVersion:
         # Column.dependent_cols for existing cols is wrong at this point, but init() will set it correctly
         column_md = cls._create_column_md(cols)
         tbl_id = uuid.uuid4()
+        tbl_id_str = str(tbl_id)
         table_md = schema.TableMd(
-            tbl_id=str(tbl_id),
+            tbl_id=tbl_id_str,
             name=name,
             user=user,
             is_replica=False,
@@ -234,22 +235,17 @@ class TableVersion:
             next_col_id=len(cols),
             next_idx_id=0,
             next_row_id=0,
+            view_sn=0,
             column_md=column_md,
             index_md={},
             external_stores=[],
             view_md=view_md,
             additional_md={},
         )
-        # create a schema.Table here, we need it to call our c'tor;
-        # don't add it to the session yet, we might add index metadata
-        tbl_record = schema.Table(id=tbl_id, dir_id=dir_id, md=dataclasses.asdict(table_md))
 
         # create schema.TableVersion
         table_version_md = schema.TableVersionMd(
-            tbl_id=str(tbl_record.id), created_at=timestamp, version=0, schema_version=0, additional_md={}
-        )
-        tbl_version_record = schema.TableVersion(
-            tbl_id=tbl_record.id, version=0, md=dataclasses.asdict(table_version_md)
+            tbl_id=tbl_id_str, created_at=timestamp, version=0, schema_version=0, additional_md={}
         )
 
         # create schema.TableSchemaVersion
@@ -263,7 +259,7 @@ class TableVersion:
             schema_col_md[col.id] = md
 
         schema_version_md = schema.TableSchemaVersionMd(
-            tbl_id=str(tbl_record.id),
+            tbl_id=tbl_id_str,
             schema_version=0,
             preceding_schema_version=None,
             columns=schema_col_md,
@@ -272,9 +268,8 @@ class TableVersion:
             media_validation=media_validation.name.lower(),
             additional_md={},
         )
-        schema_version_record = schema.TableSchemaVersion(
-            tbl_id=tbl_record.id, schema_version=0, md=dataclasses.asdict(schema_version_md)
-        )
+
+        cat = pxt.catalog.Catalog.get()
 
         # if this is purely a snapshot (it doesn't require any additional storage for columns and it doesn't have a
         # predicate to apply at runtime), we don't create a physical table and simply use the base's table version path
@@ -285,22 +280,23 @@ class TableVersion:
             and view_md.sample_clause is None
             and len(cols) == 0
         ):
-            session.add(tbl_record)
-            session.add(tbl_version_record)
-            session.add(schema_version_record)
-            return tbl_record.id, None
+            cat.store_tbl_md(
+                tbl_id=tbl_id,
+                dir_id=dir_id,
+                tbl_md=table_md,
+                version_md=table_version_md,
+                schema_version_md=schema_version_md,
+            )
+            return tbl_id, None
 
         # assert (base_path is not None) == (view_md is not None)
         is_snapshot = view_md is not None and view_md.is_snapshot
         effective_version = 0 if is_snapshot else None
         base_path = pxt.catalog.TableVersionPath.from_md(view_md.base_versions) if view_md is not None else None
         base = base_path.tbl_version if base_path is not None else None
-        tbl_version = cls(
-            tbl_record.id, table_md, effective_version, schema_version_md, [], base_path=base_path, base=base
-        )
+        tbl_version = cls(tbl_id, table_md, effective_version, schema_version_md, [], base_path=base_path, base=base)
         # TODO: break this up, so that Catalog.create_table() registers tbl_version
-        cat = pxt.catalog.Catalog.get()
-        cat._tbl_versions[tbl_record.id, effective_version] = tbl_version
+        cat._tbl_versions[tbl_id, effective_version] = tbl_version
         tbl_version.init()
         tbl_version.store_tbl.create()
         is_mutable = not is_snapshot and not table_md.is_replica
@@ -317,12 +313,14 @@ class TableVersion:
                 status = tbl_version._add_default_index(col)
                 assert status is None or status.num_excs == 0
 
-        # we re-create the tbl_record here, now that we have new index metadata
-        tbl_record = schema.Table(id=tbl_id, dir_id=dir_id, md=dataclasses.asdict(tbl_version.tbl_md))
-        session.add(tbl_record)
-        session.add(tbl_version_record)
-        session.add(schema_version_record)
-        return tbl_record.id, tbl_version
+        cat.store_tbl_md(
+            tbl_id=tbl_id,
+            dir_id=dir_id,
+            tbl_md=tbl_version.tbl_md,
+            version_md=table_version_md,
+            schema_version_md=schema_version_md,
+        )
+        return tbl_id, tbl_version
 
     @classmethod
     def create_replica(cls, md: schema.FullTableMd) -> TableVersion:
@@ -342,24 +340,39 @@ class TableVersion:
         return tbl_version
 
     def drop(self) -> None:
-        from .catalog import Catalog
-
         if self.is_view and self.is_mutable:
             # update mutable_views
+            # TODO: invalidate base to force reload
             from .table_version_handle import TableVersionHandle
 
             assert self.base is not None
             if self.base.get().is_mutable:
                 self.base.get().mutable_views.remove(TableVersionHandle.create(self))
 
-        cat = Catalog.get()
+        # cat = Catalog.get()
         # delete this table and all associated data
         MediaStore.delete(self.id)
         FileCache.get().clear(tbl_id=self.id)
-        cat.delete_tbl_md(self.id)
+        # cat.delete_tbl_md(self.id)
         self.store_tbl.drop()
         # de-register table version from catalog
-        cat.remove_tbl_version(self)
+        # cat.remove_tbl_version(self)
+
+    def init(self) -> None:
+        """
+        Initialize schema-related in-memory metadata separately, now that this TableVersion instance is visible
+        in Catalog.
+        """
+        from .catalog import Catalog
+
+        cat = Catalog.get()
+        assert (self.id, self.effective_version) in cat._tbl_versions
+        self._init_schema()
+        if not self.is_snapshot:
+            cat.record_column_dependencies(self)
+
+        # init external stores; this needs to happen after the schema is created
+        self._init_external_stores()
 
     def _init_schema(self) -> None:
         # create columns first, so the indices can reference them
@@ -369,6 +382,10 @@ class TableVersion:
         # create the sa schema only after creating the columns and indices
         self._init_sa_schema()
 
+        # created value_exprs after everything else has been initialized
+        for col in self.cols_by_id.values():
+            col.init_value_expr()
+
     def _init_cols(self) -> None:
         """Initialize self.cols with the columns visible in our effective version"""
         self.cols = []
@@ -395,6 +412,7 @@ class TableVersion:
                 schema_version_add=col_md.schema_version_add,
                 schema_version_drop=col_md.schema_version_drop,
                 value_expr_dict=col_md.value_expr,
+                tbl=self,
             )
             col.tbl = self
             self.cols.append(col)
@@ -410,10 +428,10 @@ class TableVersion:
                 self.cols_by_name[col.name] = col
             self.cols_by_id[col.id] = col
 
-            # make sure to traverse columns ordered by position = order in which cols were created;
-            # this guarantees that references always point backwards
-            if not self.is_snapshot and col_md.value_expr is not None:
-                self._record_refd_columns(col)
+            # # make sure to traverse columns ordered by position = order in which cols were created;
+            # # this guarantees that references always point backwards
+            # if not self.is_snapshot and col_md.value_expr is not None:
+            #     self._record_refd_columns(col)
 
     def _init_idxs(self) -> None:
         # self.idx_md = tbl_md.index_md
@@ -479,14 +497,9 @@ class TableVersion:
         )
 
         Catalog.get().store_tbl_md(
-            self.id, self._tbl_md, version_md, self._schema_version_md if new_schema_version else None
+            self.id, None, self._tbl_md, version_md, self._schema_version_md if new_schema_version else None
         )
 
-    def ensure_md_loaded(self) -> None:
-        """Ensure that table metadata is loaded."""
-        for col in self.cols_by_id.values():
-            _ = col.value_expr
-
     def _store_idx_name(self, idx_id: int) -> str:
         """Return name of index in the store, which needs to be globally unique"""
         return f'idx_{self.id.hex}_{idx_id}'
@@ -689,6 +702,7 @@ class TableVersion:
                     f'Cannot add non-nullable column {col.name!r} to table {self.name!r} with existing rows'
                 )
 
+        computed_values = 0
         num_excs = 0
         cols_with_excs: list[Column] = []
         for col in cols_to_add:
@@ -700,9 +714,6 @@ class TableVersion:
             if col.name is not None:
                 self.cols_by_name[col.name] = col
             self.cols_by_id[col.id] = col
-            if col.value_expr is not None:
-                col.check_value_expr()
-                self._record_refd_columns(col)
 
             # also add to stored md
             self._tbl_md.column_md[col.id] = schema.ColumnMd(
@@ -730,18 +741,19 @@ class TableVersion:
             # populate the column
             from pixeltable.plan import Planner
 
-            plan, value_expr_slot_idx = Planner.create_add_column_plan(self.path, col)
+            plan = Planner.create_add_column_plan(self.path, col)
             plan.ctx.num_rows = row_count
             try:
                 plan.open()
                 try:
-                    excs_per_col = self.store_tbl.load_column(col, plan, value_expr_slot_idx, on_error)
+                    excs_per_col = self.store_tbl.load_column(col, plan, on_error == 'abort')
                 except sql.exc.DBAPIError as exc:
                     # Wrap the DBAPIError in an excs.Error to unify processing in the subsequent except block
                     raise excs.Error(f'SQL error during execution of computed column `{col.name}`:\n{exc}') from exc
                 if excs_per_col > 0:
                     cols_with_excs.append(col)
                     num_excs += excs_per_col
+                computed_values += plan.ctx.num_computed_exprs * row_count
             finally:
                 # Ensure cleanup occurs if an exception or keyboard interruption happens during `load_column()`.
                 def cleanup_on_error() -> None:
@@ -760,14 +772,18 @@ class TableVersion:
                 run_cleanup_on_exception(cleanup_on_error)
                 plan.close()
 
+        pxt.catalog.Catalog.get().record_column_dependencies(self)
+
         if print_stats:
             plan.ctx.profile.print(num_rows=row_count)
-        # TODO(mkornacker): what to do about system columns with exceptions?
+
+        # TODO: what to do about system columns with exceptions?
+        row_counts = RowCountStats(
+            upd_rows=row_count, num_excs=num_excs, computed_values=computed_values
+        )  # add_columns
         return UpdateStatus(
-            num_rows=row_count,
-            num_computed_values=row_count,
-            num_excs=num_excs,
             cols_with_excs=[f'{col.tbl.name}.{col.name}' for col in cols_with_excs if col.name is not None],
+            row_count_stats=row_counts,
         )
 
     def drop_column(self, col: Column) -> None:
@@ -805,13 +821,6 @@ class TableVersion:
         assert not self.is_snapshot
 
         for col in cols:
-            if col.value_expr is not None:
-                # update Column.dependent_cols
-                for c in self.cols:
-                    if c == col:
-                        break
-                    c.dependent_cols.discard(col)
-
             col.schema_version_drop = self.schema_version
             if col.name is not None:
                 assert col.name in self.cols_by_name
@@ -828,6 +837,7 @@ class TableVersion:
             schema_col.pos = pos
 
         self.store_tbl.create_sa_tbl()
+        pxt.catalog.Catalog.get().record_column_dependencies(self)
 
     def rename_column(self, old_name: str, new_name: str) -> None:
         """Rename a column."""
@@ -913,14 +923,10 @@ class TableVersion:
         """Insert rows produced by exec_plan and propagate to views"""
         # we're creating a new version
         self.version += 1
-        result = UpdateStatus()
-        num_rows, num_excs, cols_with_excs = self.store_tbl.insert_rows(
+        cols_with_excs, result = self.store_tbl.insert_rows(
             exec_plan, v_min=self.version, rowids=rowids, abort_on_exc=abort_on_exc
         )
-        result.num_rows = num_rows
-        result.num_excs = num_excs
-        result.num_computed_values += exec_plan.ctx.num_computed_exprs * num_rows
-        result.cols_with_excs = [f'{self.name}.{self.cols_by_id[cid].name}' for cid in cols_with_excs]
+        result += UpdateStatus(cols_with_excs=[f'{self.name}.{self.cols_by_id[cid].name}' for cid in cols_with_excs])
         self._write_md(new_version=True, new_version_ts=timestamp, new_schema_version=False)
 
         # update views
@@ -929,14 +935,10 @@ class TableVersion:
 
             plan, _ = Planner.create_view_load_plan(view.get().path, propagates_insert=True)
             status = view.get()._insert(plan, timestamp, print_stats=print_stats)
-            result.num_rows += status.num_rows
-            result.num_excs += status.num_excs
-            result.num_computed_values += status.num_computed_values
-            result.cols_with_excs += status.cols_with_excs
+            result += status.to_cascade()
 
-        result.cols_with_excs = list(dict.fromkeys(result.cols_with_excs).keys())  # remove duplicates
         if print_stats:
-            plan.ctx.profile.print(num_rows=num_rows)
+            plan.ctx.profile.print(num_rows=result.num_rows)  # This is the net rows after all propagations
         _logger.info(f'TableVersion {self.name}: new version {self.version}')
         return result
 
@@ -976,7 +978,7 @@ class TableVersion:
             cascade=cascade,
             show_progress=True,
         )
-        result.updated_cols = updated_cols
+        result += UpdateStatus(updated_cols=updated_cols)
         return result
 
     def batch_update(
@@ -1003,7 +1005,7 @@ class TableVersion:
         result = self.propagate_update(
             plan, delete_where_clause, recomputed_cols, base_versions=[], timestamp=time.time(), cascade=cascade
         )
-        result.updated_cols = [c.qualified_name for c in updated_cols]
+        result += UpdateStatus(updated_cols=[c.qualified_name for c in updated_cols])
 
         unmatched_rows = row_update_node.unmatched_rows()
         if len(unmatched_rows) > 0:
@@ -1011,7 +1013,7 @@ class TableVersion:
                 raise excs.Error(f'batch_update(): {len(unmatched_rows)} row(s) not found')
             if insert_if_not_exists:
                 insert_status = self.insert(unmatched_rows, None, print_stats=False, fail_on_exception=False)
-                result += insert_status
+                result += insert_status.to_cascade()
         return result
 
     def _validate_update_spec(
@@ -1064,6 +1066,38 @@ class TableVersion:
 
         return update_targets
 
+    def recompute_columns(self, col_names: list[str], errors_only: bool = False, cascade: bool = True) -> UpdateStatus:
+        assert not self.is_snapshot
+        assert all(name in self.cols_by_name for name in col_names)
+        assert len(col_names) > 0
+        assert len(col_names) == 1 or not errors_only
+
+        from pixeltable.plan import Planner
+
+        target_columns = [self.cols_by_name[name] for name in col_names]
+        where_clause: Optional[exprs.Expr] = None
+        if errors_only:
+            where_clause = (
+                exprs.ColumnPropertyRef(exprs.ColumnRef(target_columns[0]), exprs.ColumnPropertyRef.Property.ERRORTYPE)
+                != None
+            )
+        plan, updated_cols, recomputed_cols = Planner.create_update_plan(
+            self.path, update_targets={}, recompute_targets=target_columns, where_clause=where_clause, cascade=cascade
+        )
+        from pixeltable.exprs import SqlElementCache
+
+        result = self.propagate_update(
+            plan,
+            where_clause.sql_expr(SqlElementCache()) if where_clause is not None else None,
+            recomputed_cols,
+            base_versions=[],
+            timestamp=time.time(),
+            cascade=cascade,
+            show_progress=True,
+        )
+        result += UpdateStatus(updated_cols=updated_cols)
+        return result
+
     def propagate_update(
         self,
         plan: Optional[exec.ExecNode],
@@ -1074,18 +1108,20 @@ class TableVersion:
         cascade: bool,
         show_progress: bool = True,
     ) -> UpdateStatus:
-        result = UpdateStatus()
         if plan is not None:
             # we're creating a new version
             self.version += 1
-            result.num_rows, result.num_excs, cols_with_excs = self.store_tbl.insert_rows(
-                plan, v_min=self.version, show_progress=show_progress
+            cols_with_excs, status = self.store_tbl.insert_rows(plan, v_min=self.version, show_progress=show_progress)
+            result = status.insert_to_update()
+            result += UpdateStatus(
+                cols_with_excs=[f'{self.name}.{self.cols_by_id[cid].name}' for cid in cols_with_excs]
             )
-            result.cols_with_excs = [f'{self.name}.{self.cols_by_id[cid].name}' for cid in cols_with_excs]
             self.store_tbl.delete_rows(
                 self.version, base_versions=base_versions, match_on_vmin=True, where_clause=where_clause
             )
             self._write_md(new_version=True, new_version_ts=timestamp, new_schema_version=False)
+        else:
+            result = UpdateStatus()
 
         if cascade:
             base_versions = [None if plan is None else self.version, *base_versions]  # don't update in place
@@ -1100,17 +1136,17 @@ class TableVersion:
                 status = view.get().propagate_update(
                     plan, None, recomputed_view_cols, base_versions=base_versions, timestamp=timestamp, cascade=True
                 )
-                result.num_rows += status.num_rows
-                result.num_excs += status.num_excs
-                result.cols_with_excs += status.cols_with_excs
+                result += status.to_cascade()
 
-        result.cols_with_excs = list(dict.fromkeys(result.cols_with_excs).keys())  # remove duplicates
         return result
 
     def delete(self, where: Optional[exprs.Expr] = None) -> UpdateStatus:
         """Delete rows in this table.
         Args:
             where: a predicate to filter rows to delete.
+
+        Returns:
+            UpdateStatus: an object containing the number of deleted rows and other statistics.
         """
         assert self.is_insertable
         from pixeltable.exprs import Expr
@@ -1126,14 +1162,12 @@ class TableVersion:
                 raise excs.Error(f'Filter {analysis_info.filter} not expressible in SQL')
             sql_where_clause = analysis_info.sql_where_clause
 
-        num_rows = self.propagate_delete(sql_where_clause, base_versions=[], timestamp=time.time())
-
-        status = UpdateStatus(num_rows=num_rows)
+        status = self.propagate_delete(sql_where_clause, base_versions=[], timestamp=time.time())
         return status
 
     def propagate_delete(
         self, where: Optional[exprs.Expr], base_versions: list[Optional[int]], timestamp: float
-    ) -> int:
+    ) -> UpdateStatus:
         """Delete rows in this table and propagate to views.
         Args:
             where: a predicate to filter rows to delete.
@@ -1149,18 +1183,21 @@ class TableVersion:
         # sql.sql.visitors.traverse(sql_where_clause, {}, {'column': collect_cols})
         # x = [f'{str(c)}:{hash(c)}:{id(c.table)}' for c in sql_cols]
         # print(f'where_clause cols: {x}')
-        num_rows = self.store_tbl.delete_rows(
+        del_rows = self.store_tbl.delete_rows(
             self.version + 1, base_versions=base_versions, match_on_vmin=False, where_clause=sql_where_clause
         )
-        if num_rows > 0:
+        row_counts = RowCountStats(del_rows=del_rows)  # delete
+        result = UpdateStatus(row_count_stats=row_counts)
+        if del_rows > 0:
             # we're creating a new version
             self.version += 1
             self._write_md(new_version=True, new_version_ts=timestamp, new_schema_version=False)
         for view in self.mutable_views:
-            num_rows += view.get().propagate_delete(
+            status = view.get().propagate_delete(
                 where=None, base_versions=[self.version, *base_versions], timestamp=timestamp
             )
-        return num_rows
+            result += status.to_cascade()
+        return result
 
     def revert(self) -> None:
         """Reverts the table to the previous version."""
@@ -1458,18 +1495,6 @@ class TableVersion:
         names = [c.name for c in self.cols_by_name.values() if c.is_computed]
         return names
 
-    def _record_refd_columns(self, col: Column) -> None:
-        """Update Column.dependent_cols for all cols referenced in col.value_expr."""
-        from pixeltable import exprs
-
-        if col.value_expr_dict is not None:
-            # if we have a value_expr_dict, use that instead of instantiating the value_expr
-            refd_cols = exprs.Expr.get_refd_columns(col.value_expr_dict)
-        else:
-            refd_cols = [e.col for e in col.value_expr.subexprs(expr_class=exprs.ColumnRef)]
-        for refd_col in refd_cols:
-            refd_col.dependent_cols.add(col)
-
     def get_idx_val_columns(self, cols: Iterable[Column]) -> set[Column]:
         result = {info.val_col for col in cols for info in col.get_idx_info().values()}
         return result
@@ -1478,7 +1503,8 @@ class TableVersion:
         """
         Return the set of columns that transitively depend on any of the given ones.
         """
-        result = {dependent_col for col in cols for dependent_col in col.dependent_cols}
+        cat = pxt.catalog.Catalog.get()
+        result = set().union(*[cat.get_column_dependents(col.tbl.id, col.id) for col in cols])
         if len(result) > 0:
             result.update(self.get_dependent_columns(result))
         return result

pixeltable/catalog/table_version_handle.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
 import logging
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Optional
 from uuid import UUID
 
+from pixeltable import exceptions as excs
+
 from .table_version import TableVersion
 
 if TYPE_CHECKING:
-    pass
+    from pixeltable.catalog import Column
 
 _logger = logging.getLogger('pixeltable')
 
@@ -34,6 +37,10 @@ class TableVersionHandle:
     def __hash__(self) -> int:
         return hash((self.id, self.effective_version))
 
+    @property
+    def is_snapshot(self) -> bool:
+        return self.effective_version is not None
+
     @classmethod
     def create(cls, tbl_version: TableVersion) -> TableVersionHandle:
         return cls(tbl_version.id, tbl_version.effective_version, tbl_version)
@@ -53,7 +60,6 @@ class TableVersionHandle:
             else:
                 self._tbl_version = Catalog.get().get_tbl_version(self.id, self.effective_version)
         if self.effective_version is None:
-            # make sure we don't see a discarded instance of a live TableVersion
             tvs = list(Catalog.get()._tbl_versions.values())
             assert self._tbl_version in tvs
         return self._tbl_version
@@ -64,3 +70,25 @@ class TableVersionHandle:
     @classmethod
     def from_dict(cls, d: dict) -> TableVersionHandle:
         return cls(UUID(d['id']), d['effective_version'])
+
+
+@dataclass(frozen=True)
+class ColumnHandle:
+    tbl_version: TableVersionHandle
+    col_id: int
+
+    def get(self) -> 'Column':
+        if self.col_id not in self.tbl_version.get().cols_by_id:
+            schema_version_drop = self.tbl_version.get()._tbl_md.column_md[self.col_id].schema_version_drop
+            raise excs.Error(
+                f'Column has been dropped (no record for column ID {self.col_id} in table '
+                f'{self.tbl_version.get().versioned_name!r}; it was dropped in table version {schema_version_drop})'
+            )
+        return self.tbl_version.get().cols_by_id[self.col_id]
+
+    def as_dict(self) -> dict:
+        return {'tbl_version': self.tbl_version.as_dict(), 'col_id': self.col_id}
+
+    @classmethod
+    def from_dict(cls, d: dict) -> ColumnHandle:
+        return cls(tbl_version=TableVersionHandle.from_dict(d['tbl_version']), col_id=d['col_id'])

pixeltable/catalog/table_version_path.py

@@ -8,6 +8,7 @@ from pixeltable.env import Env
 from pixeltable.metadata import schema
 
 from .column import Column
+from .globals import MediaValidation
 from .table_version import TableVersion
 from .table_version_handle import TableVersionHandle
 
@@ -83,6 +84,7 @@ class TableVersionPath:
         if self.base is not None:
             self.base.clear_cached_md()
 
+    @property
     def tbl_id(self) -> UUID:
         """Return the id of the table/view that this path represents"""
         return self.tbl_version.id
@@ -92,6 +94,11 @@ class TableVersionPath:
         self.refresh_cached_md()
         return self._cached_tbl_version.version
 
+    def schema_version(self) -> int:
+        """Return the version of the table/view that this path represents"""
+        self.refresh_cached_md()
+        return self._cached_tbl_version.schema_version
+
     def tbl_name(self) -> str:
         """Return the name of the table/view that this path represents"""
         self.refresh_cached_md()
@@ -103,10 +110,7 @@ class TableVersionPath:
 
     def is_snapshot(self) -> bool:
         """Return True if this is a path of snapshot versions"""
-        self.refresh_cached_md()
-        if not self._cached_tbl_version.is_snapshot:
-            return False
-        return self.base.is_snapshot() if self.base is not None else True
+        return self.tbl_version.is_snapshot
 
     def is_view(self) -> bool:
         self.refresh_cached_md()
@@ -116,10 +120,30 @@ class TableVersionPath:
         self.refresh_cached_md()
         return self._cached_tbl_version.is_component_view
 
+    def is_replica(self) -> bool:
+        self.refresh_cached_md()
+        return self._cached_tbl_version.is_replica
+
+    def is_mutable(self) -> bool:
+        self.refresh_cached_md()
+        return self._cached_tbl_version.is_mutable
+
     def is_insertable(self) -> bool:
         self.refresh_cached_md()
         return self._cached_tbl_version.is_insertable
 
+    def comment(self) -> str:
+        self.refresh_cached_md()
+        return self._cached_tbl_version.comment
+
+    def num_retained_versions(self) -> int:
+        self.refresh_cached_md()
+        return self._cached_tbl_version.num_retained_versions
+
+    def media_validation(self) -> MediaValidation:
+        self.refresh_cached_md()
+        return self._cached_tbl_version.media_validation
+
     def get_tbl_versions(self) -> list[TableVersionHandle]:
         """Return all tbl versions"""
         if self.base is None: