pixeltable 0.3.10__py3-none-any.whl → 0.3.12__py3-none-any.whl

pixeltable/catalog/table_version.py

@@ -5,7 +5,7 @@ import importlib
 import logging
 import time
 import uuid
-from typing import TYPE_CHECKING, Any, Iterable, Iterator, Literal, Optional
+from typing import TYPE_CHECKING, Any, Iterable, Iterator, Literal, Optional, Tuple
 from uuid import UUID
 
 import jsonschema.exceptions
@@ -13,12 +13,12 @@ import sqlalchemy as sql
 
 import pixeltable as pxt
 import pixeltable.exceptions as excs
-import pixeltable.exprs as exprs
-import pixeltable.index as index
 import pixeltable.type_system as ts
+from pixeltable import exprs, index
 from pixeltable.env import Env
 from pixeltable.iterators import ComponentIterator
 from pixeltable.metadata import schema
+from pixeltable.utils.exception_handler import run_cleanup_on_exception
 from pixeltable.utils.filecache import FileCache
 from pixeltable.utils.media_store import MediaStore
 
@@ -54,7 +54,9 @@ class TableVersion:
 
     id: UUID
     name: str
+    user: Optional[str]
     effective_version: Optional[int]
+    is_replica: bool
     version: int
     comment: str
     media_validation: MediaValidation
@@ -108,8 +110,10 @@ class TableVersion:
     ):
         self.id = id
         self.name = tbl_md.name
+        self.user = tbl_md.user
         self.effective_version = effective_version
         self.version = tbl_md.current_version if effective_version is None else effective_version
+        self.is_replica = tbl_md.is_replica
         self.comment = schema_version_md.comment
         self.num_retained_versions = schema_version_md.num_retained_versions
         self.schema_version = schema_version_md.schema_version
@@ -211,6 +215,7 @@ class TableVersion:
         view_md: Optional[schema.ViewMd] = None,
     ) -> tuple[UUID, Optional[TableVersion]]:
         session = Env.get().session
+        user = Env.get().user
 
         # assign ids
         cols_by_name: dict[str, Column] = {}
@@ -229,7 +234,8 @@ class TableVersion:
         table_md = schema.TableMd(
             tbl_id=str(tbl_id),
             name=name,
-            user=None,
+            user=user,
+            is_replica=False,
             current_version=0,
             current_schema_version=0,
             next_col_id=len(cols),
@@ -308,24 +314,16 @@ class TableVersion:
         session.add(schema_version_record)
         return tbl_record.id, tbl_version
 
-    @classmethod
-    def delete_md(cls, tbl_id: UUID) -> None:
-        conn = Env.get().conn
-        conn.execute(sql.delete(schema.TableSchemaVersion.__table__).where(schema.TableSchemaVersion.tbl_id == tbl_id))
-        conn.execute(sql.delete(schema.TableVersion.__table__).where(schema.TableVersion.tbl_id == tbl_id))
-        conn.execute(sql.delete(schema.Table.__table__).where(schema.Table.id == tbl_id))
-
     def drop(self) -> None:
+        from .catalog import Catalog
+
+        cat = Catalog.get()
         # delete this table and all associated data
         MediaStore.delete(self.id)
         FileCache.get().clear(tbl_id=self.id)
-        self.delete_md(self.id)
+        cat.delete_tbl_md(self.id)
         self.store_tbl.drop()
-
         # de-register table version from catalog
-        from .catalog import Catalog
-
-        cat = Catalog.get()
         cat.remove_tbl_version(self)
 
     def _init_schema(self, tbl_md: schema.TableMd, schema_version_md: schema.TableSchemaVersionMd) -> None:
@@ -341,8 +339,11 @@ class TableVersion:
         self.cols = []
         self.cols_by_name = {}
         self.cols_by_id = {}
-        for col_md in tbl_md.column_md.values():
-            schema_col_md = schema_version_md.columns[col_md.id] if col_md.id in schema_version_md.columns else None
+        # Sort columns in column_md by the position specified in col_md.id to guarantee that all references
+        # point backward.
+        sorted_column_md = sorted(tbl_md.column_md.values(), key=lambda item: item.id)
+        for col_md in sorted_column_md:
+            schema_col_md = schema_version_md.columns.get(col_md.id)
             col_name = schema_col_md.name if schema_col_md is not None else None
             media_val = (
                 MediaValidation[schema_col_md.media_validation.upper()]
@@ -376,7 +377,7 @@ class TableVersion:
 
             # make sure to traverse columns ordered by position = order in which cols were created;
             # this guarantees that references always point backwards
-            if col_md.value_expr is not None:
+            if not self.is_snapshot and col_md.value_expr is not None:
                 self._record_refd_columns(col)
 
     def _init_idxs(self, tbl_md: schema.TableMd) -> None:
@@ -385,10 +386,8 @@ class TableVersion:
         import pixeltable.index as index_module
 
         for md in tbl_md.index_md.values():
-            if (
-                md.schema_version_add > self.schema_version
-                or md.schema_version_drop is not None
-                and md.schema_version_drop <= self.schema_version
+            if md.schema_version_add > self.schema_version or (
+                md.schema_version_drop is not None and md.schema_version_drop <= self.schema_version
             ):
                 # index not visible in this schema version
                 continue
@@ -434,29 +433,15 @@ class TableVersion:
                 specified preceding schema version
         """
         assert update_tbl_version or preceding_schema_version is None
+        from pixeltable.catalog import Catalog
 
-        conn = Env.get().conn
-        conn.execute(
-            sql.update(schema.Table.__table__)
-            .values({schema.Table.md: dataclasses.asdict(self._create_tbl_md())})
-            .where(schema.Table.id == self.id)
+        tbl_md = self._create_tbl_md()
+        version_md = self._create_version_md(timestamp) if update_tbl_version else None
+        schema_version_md = (
+            self._create_schema_version_md(preceding_schema_version) if preceding_schema_version is not None else None
         )
 
-        if update_tbl_version:
-            version_md = self._create_version_md(timestamp)
-            conn.execute(
-                sql.insert(schema.TableVersion.__table__).values(
-                    tbl_id=self.id, version=self.version, md=dataclasses.asdict(version_md)
-                )
-            )
-
-        if preceding_schema_version is not None:
-            schema_version_md = self._create_schema_version_md(preceding_schema_version)
-            conn.execute(
-                sql.insert(schema.TableSchemaVersion.__table__).values(
-                    tbl_id=self.id, schema_version=self.schema_version, md=dataclasses.asdict(schema_version_md)
-                )
-            )
+        Catalog.get().store_tbl_md(self.id, tbl_md, version_md, schema_version_md)
 
     def ensure_md_loaded(self) -> None:
         """Ensure that table metadata is loaded."""
@@ -477,33 +462,36 @@ class TableVersion:
         _logger.info(f'Added index {idx_name} on column {col.name} to table {self.name}')
         return status
 
-    def _add_default_index(self, col: Column) -> Optional[UpdateStatus]:
-        """Add a B-tree index on this column if it has a compatible type"""
+    def _is_btree_indexable(self, col: Column) -> bool:
         if not col.stored:
             # if the column is intentionally not stored, we want to avoid the overhead of an index
-            return None
+            return False
         # Skip index for stored media columns produced by an iterator
         if col.col_type.is_media_type() and self.is_iterator_column(col):
-            return None
+            return False
         if not col.col_type.is_scalar_type() and not (col.col_type.is_media_type() and not col.is_computed):
             # wrong type for a B-tree
-            return None
-        if col.col_type.is_bool_type():
+            return False
+        if col.col_type.is_bool_type():  # noqa : SIM103 Supress `Return the negated condition directly` check
             # B-trees on bools aren't useful
+            return False
+        return True
+
+    def _add_default_index(self, col: Column) -> Optional[UpdateStatus]:
+        """Add a B-tree index on this column if it has a compatible type"""
+        if not self._is_btree_indexable(col):
             return None
         status = self._add_index(col, idx_name=None, idx=index.BtreeIndex(col))
         return status
 
-    def _add_index(self, col: Column, idx_name: Optional[str], idx: index.IndexBase) -> UpdateStatus:
+    def _create_index_columns(self, idx: index.IndexBase) -> Tuple[Column, Column]:
+        """Create value and undo columns for the given index.
+        Args:
+            idx:  index for which columns will be created.
+        Returns:
+            A tuple containing the value column and the undo column.
+        """
         assert not self.is_snapshot
-        idx_id = self.next_idx_id
-        self.next_idx_id += 1
-        if idx_name is None:
-            idx_name = f'idx{idx_id}'
-        else:
-            assert is_valid_identifier(idx_name)
-            assert idx_name not in [i.name for i in self.idx_md.values()]
-
         # add the index value and undo columns (which need to be nullable)
         val_col = Column(
             col_id=self.next_col_id,
@@ -532,7 +520,19 @@ class TableVersion:
         undo_col.tbl = self.create_handle()
         undo_col.col_type = undo_col.col_type.copy(nullable=True)
         self.next_col_id += 1
+        return val_col, undo_col
 
+    def _create_index(
+        self, col: Column, val_col: Column, undo_col: Column, idx_name: Optional[str], idx: index.IndexBase
+    ) -> None:
+        """Create the given index along with index md"""
+        idx_id = self.next_idx_id
+        self.next_idx_id += 1
+        if idx_name is None:
+            idx_name = f'idx{idx_id}'
+        else:
+            assert is_valid_identifier(idx_name)
+            assert idx_name not in [i.name for i in self.idx_md.values()]
         # create and register the index metadata
         idx_cls = type(idx)
         idx_md = schema.IndexMd(
@@ -550,14 +550,27 @@ class TableVersion:
         idx_info = self.IndexInfo(id=idx_id, name=idx_name, idx=idx, col=col, val_col=val_col, undo_col=undo_col)
         self.idx_md[idx_id] = idx_md
         self.idxs_by_name[idx_name] = idx_info
+        try:
+            idx.create_index(self._store_idx_name(idx_id), val_col)
+        finally:
+
+            def cleanup_index() -> None:
+                """Delete the newly added in-memory index structure"""
+                del self.idxs_by_name[idx_name]
+                del self.idx_md[idx_id]
+                self.next_idx_id = idx_id
 
+            # Run cleanup only if there has been an exception; otherwise, skip cleanup.
+            run_cleanup_on_exception(cleanup_index)
+
+    def _add_index(self, col: Column, idx_name: Optional[str], idx: index.IndexBase) -> UpdateStatus:
+        val_col, undo_vol = self._create_index_columns(idx)
         # add the columns and update the metadata
         # TODO support on_error='abort' for indices; it's tricky because of the way metadata changes are entangled
         # with the database operations
-        status = self._add_columns([val_col, undo_col], print_stats=False, on_error='ignore')
+        status = self._add_columns([val_col, undo_vol], print_stats=False, on_error='ignore')
         # now create the index structure
-        idx.create_index(self._store_idx_name(idx_id), val_col)
-
+        self._create_index(col, val_col, undo_vol, idx_name, idx)
         return status
 
     def drop_index(self, idx_id: int) -> None:
@@ -598,9 +611,21 @@ class TableVersion:
         self.version += 1
         preceding_schema_version = self.schema_version
         self.schema_version = self.version
-        status = self._add_columns(cols, print_stats=print_stats, on_error=on_error)
+        index_cols: dict[Column, tuple[index.BtreeIndex, Column, Column]] = {}
+        all_cols: list[Column] = []
         for col in cols:
-            _ = self._add_default_index(col)
+            all_cols.append(col)
+            if self._is_btree_indexable(col):
+                idx = index.BtreeIndex(col)
+                val_col, undo_col = self._create_index_columns(idx)
+                index_cols[col] = (idx, val_col, undo_col)
+                all_cols.append(val_col)
+                all_cols.append(undo_col)
+        # Add all columns
+        status = self._add_columns(all_cols, print_stats=print_stats, on_error=on_error)
+        # Create indices and their mds
+        for col, (idx, val_col, undo_col) in index_cols.items():
+            self._create_index(col, val_col, undo_col, idx_name=None, idx=idx)
         self._update_md(time.time(), preceding_schema_version=preceding_schema_version)
         _logger.info(f'Added columns {[col.name for col in cols]} to table {self.name}, new version: {self.version}')
 
@@ -616,18 +641,18 @@ class TableVersion:
         self, cols: Iterable[Column], print_stats: bool, on_error: Literal['abort', 'ignore']
     ) -> UpdateStatus:
         """Add and populate columns within the current transaction"""
-        cols = list(cols)
+        cols_to_add = list(cols)
         row_count = self.store_tbl.count()
-        for col in cols:
-            if not col.col_type.nullable and not col.is_computed:
-                if row_count > 0:
-                    raise excs.Error(
-                        f'Cannot add non-nullable column "{col.name}" to table {self.name} with existing rows'
-                    )
+        for col in cols_to_add:
+            if not col.col_type.nullable and not col.is_computed and row_count > 0:
+                raise excs.Error(
+                    f'Cannot add non-nullable column {col.name!r} to table {self.name!r} with existing rows'
+                )
 
         num_excs = 0
         cols_with_excs: list[Column] = []
-        for col in cols:
+        for col in cols_to_add:
+            excs_per_col = 0
             col.schema_version_add = self.schema_version
             # add the column to the lookup structures now, rather than after the store changes executed successfully,
             # because it might be referenced by the next column's value_expr
@@ -650,29 +675,32 @@ class TableVersion:
 
             plan, value_expr_slot_idx = Planner.create_add_column_plan(self.path, col)
             plan.ctx.num_rows = row_count
-
             try:
                 plan.open()
                 try:
-                    num_excs = self.store_tbl.load_column(col, plan, value_expr_slot_idx, on_error)
+                    excs_per_col = self.store_tbl.load_column(col, plan, value_expr_slot_idx, on_error)
                 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 num_excs > 0:
+                if excs_per_col > 0:
                     cols_with_excs.append(col)
-            except excs.Error as exc:
-                self.cols.pop()
-                for col in cols:
-                    # remove columns that we already added
-                    if col.id not in self.cols_by_id:
-                        continue
-                    if col.name is not None:
-                        del self.cols_by_name[col.name]
-                    del self.cols_by_id[col.id]
-                # we need to re-initialize the sqlalchemy schema
-                self.store_tbl.create_sa_tbl()
-                raise exc
+                    num_excs += excs_per_col
             finally:
+                # Ensure cleanup occurs if an exception or keyboard interruption happens during `load_column()`.
+                def cleanup_on_error() -> None:
+                    """Delete columns that are added as part of current add_columns operation and re-initialize
+                    the sqlalchemy schema"""
+                    self.cols = [col for col in self.cols if col not in cols_to_add]
+                    for col in cols_to_add:
+                        # remove columns that we already added
+                        if col.id in self.cols_by_id:
+                            del self.cols_by_id[col.id]
+                        if col.name is not None and col.name in self.cols_by_name:
+                            del self.cols_by_name[col.name]
+                    self.store_tbl.create_sa_tbl()
+
+                # Run cleanup only if there has been an exception; otherwise, skip cleanup.
+                run_cleanup_on_exception(cleanup_on_error)
                 plan.close()
 
         if print_stats:
@@ -756,19 +784,20 @@ class TableVersion:
         self._update_md(time.time(), preceding_schema_version=preceding_schema_version)
         _logger.info(f'Renamed column {old_name} to {new_name} in table {self.name}, new version: {self.version}')
 
-    def set_comment(self, new_comment: Optional[str]):
+    def set_comment(self, new_comment: Optional[str]) -> None:
         _logger.info(f'[{self.name}] Updating comment: {new_comment}')
         self.comment = new_comment
         self._create_schema_version()
 
-    def set_num_retained_versions(self, new_num_retained_versions: int):
+    def set_num_retained_versions(self, new_num_retained_versions: int) -> None:
         _logger.info(
-            f'[{self.name}] Updating num_retained_versions: {new_num_retained_versions} (was {self.num_retained_versions})'
+            f'[{self.name}] Updating num_retained_versions: {new_num_retained_versions} '
+            f'(was {self.num_retained_versions})'
         )
         self.num_retained_versions = new_num_retained_versions
         self._create_schema_version()
 
-    def _create_schema_version(self):
+    def _create_schema_version(self) -> None:
         # we're creating a new schema version
         self.version += 1
         preceding_schema_version = self.schema_version
@@ -858,7 +887,7 @@ class TableVersion:
 
         from pixeltable.plan import Planner
 
-        update_spec = self._validate_update_spec(value_spec, allow_pk=False, allow_exprs=True)
+        update_spec = self._validate_update_spec(value_spec, allow_pk=False, allow_exprs=True, allow_media=True)
         if where is not None:
             if not isinstance(where, exprs.Expr):
                 raise excs.Error(f"'where' argument must be a predicate, got {type(where)}")
@@ -897,7 +926,6 @@ class TableVersion:
         """
         # if we do lookups of rowids, we must have one for each row in the batch
         assert len(rowids) == 0 or len(rowids) == len(batch)
-        cols_with_excs: set[str] = set()
 
         from pixeltable.plan import Planner
 
@@ -919,7 +947,7 @@ class TableVersion:
         return result
 
     def _validate_update_spec(
-        self, value_spec: dict[str, Any], allow_pk: bool, allow_exprs: bool
+        self, value_spec: dict[str, Any], allow_pk: bool, allow_exprs: bool, allow_media: bool
     ) -> dict[Column, exprs.Expr]:
         update_targets: dict[Column, exprs.Expr] = {}
         for col_name, val in value_spec.items():
@@ -939,27 +967,31 @@ class TableVersion:
                 raise excs.Error(f'Column {col_name} is computed and cannot be updated')
             if col.is_pk and not allow_pk:
                 raise excs.Error(f'Column {col_name} is a primary key column and cannot be updated')
+            if col.col_type.is_media_type() and not allow_media:
+                raise excs.Error(f'Column {col_name} is a media column and cannot be updated')
 
             # make sure that the value is compatible with the column type
             value_expr: exprs.Expr
             try:
                 # check if this is a literal
                 value_expr = exprs.Literal(val, col_type=col.col_type)
-            except (TypeError, jsonschema.exceptions.ValidationError):
+            except (TypeError, jsonschema.exceptions.ValidationError) as exc:
                 if not allow_exprs:
                     raise excs.Error(
                         f'Column {col_name}: value {val!r} is not a valid literal for this column '
                         f'(expected {col.col_type})'
-                    )
+                    ) from exc
                 # it's not a literal, let's try to create an expr from it
                 value_expr = exprs.Expr.from_object(val)
                 if value_expr is None:
-                    raise excs.Error(f'Column {col_name}: value {val!r} is not a recognized literal or expression')
+                    raise excs.Error(
+                        f'Column {col_name}: value {val!r} is not a recognized literal or expression'
+                    ) from exc
                 if not col.col_type.is_supertype_of(value_expr.col_type, ignore_nullable=True):
                     raise excs.Error(
                         f'Type of value {val!r} ({value_expr.col_type}) is not compatible with the type of column '
                         f'{col_name} ({col.col_type})'
-                    )
+                    ) from exc
             update_targets[col] = value_expr
 
         return update_targets
@@ -988,7 +1020,7 @@ class TableVersion:
             self._update_md(timestamp)
 
         if cascade:
-            base_versions = [None if plan is None else self.version] + base_versions  # don't update in place
+            base_versions = [None if plan is None else self.version, *base_versions]  # don't update in place
             # propagate to views
             for view in self.mutable_views:
                 recomputed_cols = [col for col in recomputed_view_cols if col.tbl == view]
@@ -1048,11 +1080,9 @@ class TableVersion:
             # we're creating a new version
             self.version += 1
             self._update_md(timestamp)
-        else:
-            pass
         for view in self.mutable_views:
             num_rows += view.get().propagate_delete(
-                where=None, base_versions=[self.version] + base_versions, timestamp=timestamp
+                where=None, base_versions=[self.version, *base_versions], timestamp=timestamp
             )
         return num_rows
 
@@ -1232,9 +1262,7 @@ class TableVersion:
 
     def is_system_column(self, col: Column) -> bool:
         """Return True if column was created by Pixeltable"""
-        if col.name == _POS_COLUMN_NAME and self.is_component_view:
-            return True
-        return False
+        return col.name == _POS_COLUMN_NAME and self.is_component_view
 
     def user_columns(self) -> list[Column]:
         """Return all non-system columns"""
@@ -1262,7 +1290,7 @@ class TableVersion:
 
     def _record_refd_columns(self, col: Column) -> None:
         """Update Column.dependent_cols for all cols referenced in col.value_expr."""
-        import pixeltable.exprs as exprs
+        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
@@ -1296,6 +1324,7 @@ class TableVersion:
         column_md: dict[int, schema.ColumnMd] = {}
         for col in cols:
             value_expr_dict = col.value_expr.as_dict() if col.value_expr is not None else None
+            assert col.is_pk is not None
             column_md[col.id] = schema.ColumnMd(
                 id=col.id,
                 col_type=col.col_type.as_dict(),
@@ -1317,7 +1346,8 @@ class TableVersion:
         return schema.TableMd(
             tbl_id=str(self.id),
             name=self.name,
-            user=None,
+            user=self.user,
+            is_replica=self.is_replica,
             current_version=self.version,
             current_schema_version=self.schema_version,
             next_col_id=self.next_col_id,
@@ -1364,7 +1394,7 @@ class TableVersion:
 
     @classmethod
     def from_dict(cls, d: dict) -> TableVersion:
-        import pixeltable.catalog as catalog
+        from pixeltable import catalog
 
         id = UUID(d['id'])
         effective_version = d['effective_version']

pixeltable/catalog/table_version_handle.py

@@ -31,6 +31,9 @@ class TableVersionHandle:
             return False
         return self.id == other.id and self.effective_version == other.effective_version
 
+    def __hash__(self) -> int:
+        return hash((self.id, self.effective_version))
+
     @classmethod
     def create(cls, tbl_version: TableVersion) -> TableVersionHandle:
         return cls(tbl_version.id, tbl_version.effective_version, tbl_version)

pixeltable/catalog/table_version_path.py

@@ -82,7 +82,7 @@ class TableVersionPath:
         """Return all tbl versions"""
         if self.base is None:
             return [self.tbl_version]
-        return [self.tbl_version] + self.base.get_tbl_versions()
+        return [self.tbl_version, *self.base.get_tbl_versions()]
 
     def get_bases(self) -> list[TableVersionHandle]:
         """Return all tbl versions"""

pixeltable/catalog/view.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import inspect
 import logging
-from typing import TYPE_CHECKING, Any, Iterable, List, Literal, Optional
+from typing import TYPE_CHECKING, Any, List, Literal, Optional
 from uuid import UUID
 
 import pixeltable.exceptions as excs
@@ -20,7 +20,7 @@ from .table_version_handle import TableVersionHandle
 from .table_version_path import TableVersionPath
 
 if TYPE_CHECKING:
-    import pixeltable as pxt
+    from pixeltable.globals import TableDataSource
 
 _logger = logging.getLogger('pixeltable')
 
@@ -65,7 +65,7 @@ class View(Table):
         base: TableVersionPath,
         select_list: Optional[list[tuple[exprs.Expr, Optional[str]]]],
         additional_columns: dict[str, Any],
-        predicate: Optional['pxt.exprs.Expr'],
+        predicate: Optional['exprs.Expr'],
         is_snapshot: bool,
         num_retained_versions: int,
         comment: str,
@@ -98,7 +98,8 @@ class View(Table):
             # make sure that the value can be computed in the context of the base
             if col.value_expr is not None and not col.value_expr.is_bound_by([base]):
                 raise excs.Error(
-                    f'Column {col.name}: value expression cannot be computed in the context of the base {base.tbl_name()}'
+                    f'Column {col.name}: value expression cannot be computed in the context of the '
+                    f'base {base.tbl_name()}'
                 )
 
         if iterator_cls is not None:
@@ -111,8 +112,8 @@ class View(Table):
             bound_args: dict[str, Any]
             try:
                 bound_args = py_signature.bind(None, **iterator_args).arguments  # None: arg for self
-            except TypeError as e:
-                raise excs.Error(f'Invalid iterator arguments: {e}')
+            except TypeError as exc:
+                raise excs.Error(f'Invalid iterator arguments: {exc}') from exc
             # we ignore 'self'
             first_param_name = next(iter(py_signature.parameters))  # can't guarantee it's actually 'self'
             del bound_args[first_param_name]
@@ -203,8 +204,8 @@ class View(Table):
 
             from pixeltable.plan import Planner
 
-            plan, num_values_per_row = Planner.create_view_load_plan(view._tbl_version_path)
-            num_rows, num_excs, cols_with_excs = tbl_version.store_tbl.insert_rows(plan, v_min=tbl_version.version)
+            plan, _ = Planner.create_view_load_plan(view._tbl_version_path)
+            num_rows, num_excs, _ = tbl_version.store_tbl.insert_rows(plan, v_min=tbl_version.version)
             Env.get().console_logger.info(f'Created view `{name}` with {num_rows} rows, {num_excs} exceptions.')
 
         session.commit()
@@ -241,7 +242,7 @@ class View(Table):
             # there is not TableVersion to drop
             self._check_is_dropped()
             self.is_dropped = True
-            TableVersion.delete_md(self._id)
+            catalog.Catalog.get().delete_tbl_md(self._id)
         else:
             super()._drop()
 
@@ -251,11 +252,6 @@ class View(Table):
         md['is_snapshot'] = self._tbl_version_path.is_snapshot()
         return md
 
-    if TYPE_CHECKING:
-        import datasets  # type: ignore[import-untyped]
-
-        from pixeltable.globals import RowData, TableDataSource
-
     def insert(
         self,
         source: Optional[TableDataSource] = None,

pixeltable/dataframe.py

@@ -88,12 +88,12 @@ class DataFrameResultSet:
     def __iter__(self) -> Iterator[dict[str, Any]]:
         return (self._row_to_dict(i) for i in range(len(self)))
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if not isinstance(other, DataFrameResultSet):
             return False
         return self.to_pandas().equals(other.to_pandas())
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self.to_pandas())
 
 
@@ -571,7 +571,7 @@ class DataFrame:
             expr = exprs.Expr.from_object(raw_expr)
             if expr is None:
                 raise excs.Error(f'Invalid expression: {raw_expr}')
-            if expr.col_type.is_invalid_type():
+            if expr.col_type.is_invalid_type() and not (isinstance(expr, exprs.Literal) and expr.val is None):
                 raise excs.Error(f'Invalid type: {raw_expr}')
             if not expr.is_bound_by(self._from_clause.tbls):
                 raise excs.Error(
@@ -624,6 +624,8 @@ class DataFrame:
 
             >>> df = person.where(t.age > 30)
         """
+        if self.where_clause is not None:
+            raise excs.Error('Where clause already specified')
         if not isinstance(pred, exprs.Expr):
             raise excs.Error(f'Where() requires a Pixeltable expression, but instead got {type(pred)}')
         if not pred.col_type.is_bool_type():