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

pixeltable/catalog/column.py

@@ -42,11 +42,9 @@ class Column:
     sa_errortype_col: Optional[sql.schema.Column]
     _value_expr: Optional[exprs.Expr]
     value_expr_dict: Optional[dict[str, Any]]
-    dependent_cols: set[Column]
     # we store a TableVersion here, not a TableVersionHandle, because this column is owned by that TableVersion instance
     # (re-resolving it later to a different instance doesn't make sense)
     tbl: Optional[TableVersion]
-    # tbl: Optional[TableVersionHandle]
 
     def __init__(
         self,
@@ -62,6 +60,7 @@ class Column:
         sa_col_type: Optional[sql.sqltypes.TypeEngine] = None,
         records_errors: Optional[bool] = None,
         value_expr_dict: Optional[dict[str, Any]] = None,
+        tbl: Optional[TableVersion] = None,
     ):
         """Column constructor.
 
@@ -86,6 +85,7 @@ class Column:
         if name is not None and not is_valid_identifier(name):
             raise excs.Error(f"Invalid column name: '{name}'")
         self.name = name
+        self.tbl = tbl
         if col_type is None and computed_with is None:
             raise excs.Error(f'Column `{name}`: col_type is required if computed_with is not specified')
 
@@ -94,6 +94,7 @@ class Column:
         if computed_with is not None:
             value_expr = exprs.Expr.from_object(computed_with)
             if value_expr is None:
+                # TODO: this shouldn't be a user-facing error
                 raise excs.Error(
                     f'Column {name}: computed_with needs to be a valid Pixeltable expression, '
                     f'but it is a {type(computed_with)}'
@@ -101,13 +102,15 @@ class Column:
             else:
                 self._value_expr = value_expr.copy()
                 self.col_type = self._value_expr.col_type
+        if self._value_expr is not None and self.value_expr_dict is None:
+            self.value_expr_dict = self._value_expr.as_dict()
 
         if col_type is not None:
             self.col_type = col_type
         assert self.col_type is not None
 
         self.stored = stored
-        self.dependent_cols = set()  # cols with value_exprs that reference us; set by TableVersion
+        # self.dependent_cols = set()  # cols with value_exprs that reference us; set by TableVersion
         self.id = col_id
         self.is_pk = is_pk
         self._media_validation = media_validation
@@ -124,36 +127,35 @@ class Column:
         self.sa_errormsg_col = None
         self.sa_errortype_col = None
 
-        self.tbl = None  # set by owning TableVersion
+    def init_value_expr(self) -> None:
+        from pixeltable import exprs
+
+        if self._value_expr is not None or self.value_expr_dict is None:
+            return
+        self._value_expr = exprs.Expr.from_dict(self.value_expr_dict)
+        self._value_expr.bind_rel_paths()
+        if not self._value_expr.is_valid:
+            message = (
+                dedent(
+                    f"""
+                    The computed column {self.name!r} in table {self.tbl.name!r} is no longer valid.
+                    {{validation_error}}
+                    You can continue to query existing data from this column, but evaluating it on new data will raise an error.
+                    """  # noqa: E501
+                )
+                .strip()
+                .format(validation_error=self._value_expr.validation_error)
+            )
+            warnings.warn(message, category=excs.PixeltableWarning, stacklevel=2)
 
     @property
     def value_expr(self) -> Optional[exprs.Expr]:
-        """Instantiate value_expr on-demand"""
-        # TODO: instantiate expr in the c'tor and add an Expr.prepare() that can create additional state after the
-        # catalog has been fully loaded; that way, we encounter bugs in the serialization/deserialization logic earlier
-        if self.value_expr_dict is not None and self._value_expr is None:
-            from pixeltable import exprs
-
-            self._value_expr = exprs.Expr.from_dict(self.value_expr_dict)
-            self._value_expr.bind_rel_paths()
-            if not self._value_expr.is_valid:
-                message = (
-                    dedent(
-                        f"""
-                        The computed column {self.name!r} in table {self.tbl.name!r} is no longer valid.
-                        {{validation_error}}
-                        You can continue to query existing data from this column, but evaluating it on new data will raise an error.
-                        """  # noqa: E501
-                    )
-                    .strip()
-                    .format(validation_error=self._value_expr.validation_error)
-                )
-                warnings.warn(message, category=excs.PixeltableWarning, stacklevel=2)
+        assert self.value_expr_dict is None or self._value_expr is not None
         return self._value_expr
 
     def set_value_expr(self, value_expr: exprs.Expr) -> None:
         self._value_expr = value_expr
-        self.value_expr_dict = None
+        self.value_expr_dict = self._value_expr.as_dict()
 
     def check_value_expr(self) -> None:
         assert self._value_expr is not None

pixeltable/catalog/globals.py

@@ -5,6 +5,7 @@ import enum
 import itertools
 import logging
 from typing import Optional
+from uuid import UUID
 
 from typing_extensions import Self
 
@@ -21,6 +22,17 @@ _ROWID_COLUMN_NAME = '_rowid'
 _PREDEF_SYMBOLS: Optional[set[str]] = None
 
 
+@dataclasses.dataclass(frozen=True)
+class QColumnId:
+    """Qualified column id"""
+
+    tbl_id: UUID
+    col_id: int
+
+    # def __hash__(self) -> int:
+    #     return hash((self.tbl_id, self.col_id))
+
+
 @dataclasses.dataclass
 class UpdateStatus:
     """

pixeltable/catalog/insertable_table.py

@@ -51,6 +51,7 @@ class InsertableTable(Table):
     def __init__(self, dir_id: UUID, tbl_version: TableVersionHandle):
         tbl_version_path = TableVersionPath(tbl_version)
         super().__init__(tbl_version.id, dir_id, tbl_version.get().name, tbl_version_path)
+        self._tbl_version = tbl_version
 
     @classmethod
     def _display_name(cls) -> str:
@@ -103,8 +104,8 @@ class InsertableTable(Table):
         Env.get().console_logger.info(f'Created table `{name}`.')
         return tbl
 
-    def get_metadata(self) -> dict[str, Any]:
-        md = super().get_metadata()
+    def _get_metadata(self) -> dict[str, Any]:
+        md = super()._get_metadata()
         md['is_view'] = False
         md['is_snapshot'] = False
         return md
@@ -141,7 +142,7 @@ class InsertableTable(Table):
         from pixeltable.catalog import Catalog
         from pixeltable.io.table_data_conduit import UnkTableDataConduit
 
-        with Catalog.get().begin_xact(tbl_id=self._id, for_write=True):
+        with Catalog.get().begin_xact(tbl=self._tbl_version_path, for_write=True, lock_mutable_tree=True):
             table = self
             if source is None:
                 source = [kwargs]
@@ -171,7 +172,7 @@ class InsertableTable(Table):
         from pixeltable.io.table_data_conduit import DFTableDataConduit
 
         status = pxt.UpdateStatus()
-        with Catalog.get().begin_xact(tbl_id=self._id, for_write=True):
+        with Catalog.get().begin_xact(tbl=self._tbl_version_path, for_write=True, lock_mutable_tree=True):
             if isinstance(data_source, DFTableDataConduit):
                 status += self._tbl_version.get().insert(
                     rows=None, df=data_source.pxt_df, print_stats=print_stats, fail_on_exception=fail_on_exception
@@ -189,7 +190,7 @@ class InsertableTable(Table):
 
     def _validate_input_rows(self, rows: list[dict[str, Any]]) -> None:
         """Verify that the input rows match the table schema"""
-        valid_col_names = set(self._schema.keys())
+        valid_col_names = set(self._get_schema().keys())
         reqd_col_names = set(self._tbl_version_path.tbl_version.get().get_required_col_names())
         computed_col_names = set(self._tbl_version_path.tbl_version.get().get_computed_col_names())
         for row in rows:
@@ -231,11 +232,10 @@ class InsertableTable(Table):
         """
         from pixeltable.catalog import Catalog
 
-        with Catalog.get().begin_xact(tbl_id=self._id, for_write=True):
+        with Catalog.get().begin_xact(tbl=self._tbl_version_path, for_write=True, lock_mutable_tree=True):
             return self._tbl_version.get().delete(where=where)
 
-    @property
-    def _base_table(self) -> Optional['Table']:
+    def _get_base_table(self) -> Optional['Table']:
         return None
 
     @property

pixeltable/catalog/schema_object.py

@@ -42,6 +42,12 @@ class SchemaObject:
 
     def get_metadata(self) -> dict[str, Any]:
         """Returns metadata associated with this schema object."""
+        from pixeltable.catalog import Catalog
+
+        with Catalog.get().begin_xact(for_write=False):
+            return self._get_metadata()
+
+    def _get_metadata(self) -> dict[str, Any]:
         return {'name': self._name, 'path': self._path()}
 
     @classmethod