pixeltable 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

pixeltable/catalog/table_version.py

@@ -89,8 +89,6 @@ class TableVersion:
             self.next_idx_id = tbl_md.next_idx_id
             self.next_rowid = tbl_md.next_row_id
 
-        self.remotes = dict(TableVersion._init_remote(remote_md) for remote_md in tbl_md.remotes)
-
         # view-specific initialization
         from pixeltable import exprs
         predicate_dict = None if not is_view or tbl_md.view_md.predicate is None else tbl_md.view_md.predicate
@@ -124,8 +122,13 @@ class TableVersion:
         self.cols_by_id: dict[int, Column] = {}  # contains only columns visible in this version, both system and user
         self.idx_md = tbl_md.index_md  # needed for _create_tbl_md()
         self.idxs_by_name: dict[str, TableVersion.IndexInfo] = {}  # contains only actively maintained indices
+        self.external_stores: dict[str, pixeltable.io.ExternalStore] = {}
+
         self._init_schema(tbl_md, schema_version_md)
 
+        # Init external stores (this needs to happen after the schema is created)
+        self._init_external_stores(tbl_md)
+
     def __hash__(self) -> int:
         return hash(self.id)
 
@@ -160,7 +163,7 @@ class TableVersion:
         column_md = cls._create_column_md(cols)
         table_md = schema.TableMd(
             name=name, current_version=0, current_schema_version=0, next_col_id=len(cols),
-            next_idx_id=0, next_row_id=0, column_md=column_md, index_md={}, remotes=[], view_md=view_md)
+            next_idx_id=0, next_row_id=0, column_md=column_md, index_md={}, external_stores=[], view_md=view_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_id = uuid.uuid4()
@@ -240,6 +243,8 @@ class TableVersion:
     def _init_cols(self, tbl_md: schema.TableMd, schema_version_md: schema.TableSchemaVersionMd) -> None:
         """Initialize self.cols with the columns visible in our effective version"""
         import pixeltable.exprs as exprs
+        from pixeltable.catalog import Catalog
+
         self.cols = []
         self.cols_by_name = {}
         self.cols_by_id = {}
@@ -248,7 +253,8 @@ class TableVersion:
             col = Column(
                 col_id=col_md.id, name=col_name, col_type=ts.ColumnType.from_dict(col_md.col_type),
                 is_pk=col_md.is_pk, stored=col_md.stored,
-                schema_version_add=col_md.schema_version_add, schema_version_drop=col_md.schema_version_drop)
+                schema_version_add=col_md.schema_version_add, schema_version_drop=col_md.schema_version_drop,
+                value_expr_dict=col_md.value_expr)
             col.tbl = self
             self.cols.append(col)
 
@@ -266,18 +272,8 @@ 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:
-                col.value_expr = exprs.Expr.from_dict(col_md.value_expr)
-                self._record_value_expr(col)
-
-            # if this is a stored proxy column, resolve the relationships with its proxy base.
-            if col_md.proxy_base is not None:
-                # proxy_base must have a strictly smaller id, so we must already have encountered it
-                # in traversal order; and if the proxy column is active at this version, then the
-                # proxy base must necessarily be active as well. This motivates the following assertion.
-                assert col_md.proxy_base in self.cols_by_id
-                base_col = self.cols_by_id[col_md.proxy_base]
-                base_col.stored_proxy = col
-                col.proxy_base = base_col
+                refd_cols = exprs.Expr.get_refd_columns(col_md.value_expr)
+                self._record_refd_columns(col)
 
     def _init_idxs(self, tbl_md: schema.TableMd) -> None:
         self.idx_md = tbl_md.index_md
@@ -317,22 +313,30 @@ class TableVersion:
             self.store_tbl: StoreBase = StoreTable(self)
 
     def _update_md(
-            self, timestamp: float, preceding_schema_version: Optional[int], conn: sql.engine.Connection
+            self, timestamp: float, conn: sql.engine.Connection, update_tbl_version: bool = True, preceding_schema_version: Optional[int] = None
     ) -> None:
-        """Update all recorded metadata in response to a data or schema change.
+        """Writes table metadata to the database.
+
         Args:
             timestamp: timestamp of the change
-            preceding_schema_version: last schema version if schema change, else None
+            conn: database connection to use
+            update_tbl_version: if `True`, will also write `TableVersion` metadata
+            preceding_schema_version: if specified, will also write `TableSchemaVersion` metadata, recording the
+                specified preceding schema version
         """
+        assert update_tbl_version or preceding_schema_version is None
+
         conn.execute(
             sql.update(schema.Table.__table__)
                 .values({schema.Table.md: dataclasses.asdict(self._create_tbl_md())})
                 .where(schema.Table.id == self.id))
 
-        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 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(
@@ -352,7 +356,7 @@ class TableVersion:
         self.schema_version = self.version
         with Env.get().engine.begin() as conn:
             status = self._add_index(col, idx_name, idx, conn)
-            self._update_md(time.time(), preceding_schema_version, conn)
+            self._update_md(time.time(), conn, preceding_schema_version=preceding_schema_version)
             _logger.info(f'Added index {idx_name} on column {col.name} to table {self.name}')
             return status
 
@@ -435,7 +439,7 @@ class TableVersion:
 
         with Env.get().engine.begin() as conn:
             self._drop_columns([idx_info.val_col, idx_info.undo_col])
-            self._update_md(time.time(), preceding_schema_version, conn)
+            self._update_md(time.time(), conn, preceding_schema_version=preceding_schema_version)
             _logger.info(f'Dropped index {idx_md.name} on table {self.name}')
 
     def add_column(self, col: Column, print_stats: bool = False) -> UpdateStatus:
@@ -461,7 +465,7 @@ class TableVersion:
             status = self._add_columns([col], conn, print_stats=print_stats)
             _ = self._add_default_index(col, conn)
             # TODO: what to do about errors?
-            self._update_md(time.time(), preceding_schema_version, conn)
+            self._update_md(time.time(), conn, preceding_schema_version=preceding_schema_version)
         _logger.info(f'Added column {col.name} to table {self.name}, new version: {self.version}')
 
         msg = (
@@ -472,8 +476,9 @@ class TableVersion:
         _logger.info(f'Column {col.name}: {msg}')
         return status
 
-    def _add_columns(self, cols: List[Column], conn: sql.engine.Connection, print_stats: bool = False) -> UpdateStatus:
+    def _add_columns(self, cols: Iterable[Column], conn: sql.engine.Connection, print_stats: bool = False) -> UpdateStatus:
         """Add and populate columns within the current transaction"""
+        cols = list(cols)
         row_count = self.store_tbl.count(conn=conn)
         for col in cols:
             if not col.col_type.nullable and not col.is_computed:
@@ -493,7 +498,7 @@ class TableVersion:
             self.cols_by_id[col.id] = col
             if col.value_expr is not None:
                 col.check_value_expr()
-                self._record_value_expr(col)
+                self._record_refd_columns(col)
 
             if col.is_stored:
                 self.store_tbl.add_column(col, conn)
@@ -507,7 +512,7 @@ class TableVersion:
             plan.ctx.num_rows = row_count
 
             try:
-                plan.ctx.conn = conn
+                plan.ctx.set_conn(conn)
                 plan.open()
                 num_excs = self.store_tbl.load_column(col, plan, value_expr_slot_idx, conn)
                 if num_excs > 0:
@@ -537,6 +542,8 @@ class TableVersion:
     def drop_column(self, name: str) -> None:
         """Drop a column from the table.
         """
+        from pixeltable.catalog import Catalog
+
         assert not self.is_snapshot
         if name not in self.cols_by_name:
             raise excs.Error(f'Unknown column: {name}')
@@ -547,13 +554,24 @@ class TableVersion:
                 f'Cannot drop column `{name}` because the following columns depend on it:\n'
                 f'{", ".join(c.name for c in dependent_user_cols)}'
             )
-        dependent_remotes = [remote for remote, col_mapping in self.remotes.items() if name in col_mapping]
-        if len(dependent_remotes) > 0:
+        # See if this column has a dependent store. We need to look through all stores in all
+        # (transitive) views of this table.
+        transitive_views = Catalog.get().tbls[self.id].get_views(recursive=True)
+        dependent_stores = [
+            (view, store)
+            for view in transitive_views
+            for store in view._tbl_version.external_stores.values()
+            if col in store.get_local_columns()
+        ]
+        if len(dependent_stores) > 0:
+            dependent_store_names = [
+                store.name if view._get_id() == self.id else f'{store.name} (in view `{view.get_name()}`)'
+                for view, store in dependent_stores
+            ]
             raise excs.Error(
-                f'Cannot drop column `{name}` because the following remotes depend on it:\n'
-                f'{", ".join(str(r) for r in dependent_remotes)}'
+                f'Cannot drop column `{name}` because the following external stores depend on it:\n'
+                f'{", ".join(dependent_store_names)}'
             )
-        assert col.stored_proxy is None  # since there are no dependent remotes
 
         # we're creating a new schema version
         self.version += 1
@@ -576,10 +594,10 @@ class TableVersion:
             for idx_name in dropped_idx_names:
                 del self.idxs_by_name[idx_name]
             self._drop_columns(dropped_cols)
-            self._update_md(time.time(), preceding_schema_version, conn)
+            self._update_md(time.time(), conn, preceding_schema_version=preceding_schema_version)
         _logger.info(f'Dropped column {name} from table {self.name}, new version: {self.version}')
 
-    def _drop_columns(self, cols: list[Column]) -> None:
+    def _drop_columns(self, cols: Iterable[Column]) -> None:
         """Mark columns as dropped"""
         assert not self.is_snapshot
 
@@ -621,7 +639,7 @@ class TableVersion:
         self.schema_version = self.version
 
         with Env.get().engine.begin() as conn:
-            self._update_md(time.time(), preceding_schema_version, conn)
+            self._update_md(time.time(), conn, 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]):
@@ -640,7 +658,7 @@ class TableVersion:
         preceding_schema_version = self.schema_version
         self.schema_version = self.version
         with Env.get().engine.begin() as conn:
-            self._update_md(time.time(), preceding_schema_version, conn)
+            self._update_md(time.time(), conn, preceding_schema_version=preceding_schema_version)
         _logger.info(f'[{self.name}] Updating table schema to version: {self.version}')
 
     def insert(
@@ -667,7 +685,7 @@ class TableVersion:
         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]
-        self._update_md(timestamp, None, conn)
+        self._update_md(timestamp, conn)
 
         # update views
         for view in self.mutable_views:
@@ -781,7 +799,7 @@ class TableVersion:
             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, conn=conn)
-            self._update_md(timestamp, None, conn)
+            self._update_md(timestamp, conn)
 
         if cascade:
             base_versions = [None if plan is None else self.version] + base_versions  # don't update in place
@@ -831,7 +849,7 @@ class TableVersion:
         if num_rows > 0:
             # we're creating a new version
             self.version += 1
-            self._update_md(timestamp, None, conn)
+            self._update_md(timestamp, conn)
         else:
             pass
         for view in self.mutable_views:
@@ -962,93 +980,29 @@ class TableVersion:
             view._revert(session)
         _logger.info(f'TableVersion {self.name}: reverted to version {self.version}')
 
-    @classmethod
-    def _init_remote(cls, remote_md: dict[str, Any]) -> Tuple[pixeltable.datatransfer.Remote, dict[str, str]]:
-        remote_cls = resolve_symbol(remote_md['class'])
-        assert isinstance(remote_cls, type) and issubclass(remote_cls, pixeltable.datatransfer.Remote)
-        remote = remote_cls.from_dict(remote_md['remote_md'])
-        col_mapping = remote_md['col_mapping']
-        return remote, col_mapping
-
-    def link(self, remote: pixeltable.datatransfer.Remote, col_mapping: dict[str, str]) -> None:
-        # All of the media columns being linked need to either be stored, computed columns or have stored proxies.
-        # This ensures that the media in those columns resides in the media cache, where it can be served.
-        # First determine which columns (if any) need stored proxies, but don't have one yet.
-        cols_by_name = self.path.cols_by_name()  # Includes base columns
-        stored_proxies_needed = []
-        for col_name in col_mapping.keys():
-            col = cols_by_name[col_name]
-            if col.col_type.is_media_type() and not (col.is_stored and col.compute_func) and not col.stored_proxy:
-                stored_proxies_needed.append(col)
-        with Env.get().engine.begin() as conn:
-            self.version += 1
-            self.remotes[remote] = col_mapping
-            preceding_schema_version = None
-            if len(stored_proxies_needed) > 0:
-                _logger.info(f'Creating stored proxies for columns: {[col.name for col in stored_proxies_needed]}')
-                # Create stored proxies for columns that need one. Increment the schema version
-                # accordingly.
-                preceding_schema_version = self.schema_version
-                self.schema_version = self.version
-                proxy_cols = [self.create_stored_proxy(col) for col in stored_proxies_needed]
-                # Add the columns; this will also update table metadata.
-                # TODO Add to base tables
-                self._add_columns(proxy_cols, conn)
-                # We don't need to retain `UpdateStatus` since the stored proxies are intended to be
-                # invisible to the user.
-            self._update_md(time.time(), preceding_schema_version, conn)
-
-    def create_stored_proxy(self, col: Column) -> Column:
-        from pixeltable import exprs
+    def _init_external_stores(self, tbl_md: schema.TableMd) -> None:
+        for store_md in tbl_md.external_stores:
+            store_cls = resolve_symbol(store_md['class'])
+            assert isinstance(store_cls, type) and issubclass(store_cls, pixeltable.io.ExternalStore)
+            store = store_cls.from_dict(store_md['md'])
+            self.external_stores[store.name] = store
 
-        assert col.col_type.is_media_type() and not (col.is_stored and col.compute_func) and not col.stored_proxy
-        proxy_col = Column(
-            name=None,
-            computed_with=exprs.ColumnRef(col).apply(lambda x: x, col_type=col.col_type),
-            stored=True,
-            col_id=self.next_col_id,
-            sa_col_type=col.col_type.to_sa_type(),
-            schema_version_add=self.schema_version
-        )
-        proxy_col.tbl = self
-        self.next_col_id += 1
-        col.stored_proxy = proxy_col
-        proxy_col.proxy_base = col
-        return proxy_col
+    def link_external_store(self, store: pixeltable.io.ExternalStore) -> None:
+        with Env.get().engine.begin() as conn:
+            store.link(self, conn)  # May result in additional metadata changes
+            self.external_stores[store.name] = store
+            self._update_md(time.time(), conn, update_tbl_version=False)
 
-    def unlink(self, remote: pixeltable.datatransfer.Remote) -> None:
-        assert remote in self.remotes
-        timestamp = time.time()
-        this_remote_col_names = list(self.remotes[remote].keys())
-        other_remote_col_names = {
-            col_name
-            for other_remote, col_mapping in self.remotes.items() if other_remote != remote
-            for col_name in col_mapping.keys()
-        }
-        cols_by_name = self.path.cols_by_name()  # Includes base columns
-        stored_proxy_deletions_needed = [
-            cols_by_name[col_name]
-            for col_name in this_remote_col_names
-            if col_name not in other_remote_col_names and cols_by_name[col_name].stored_proxy
-        ]
+    def unlink_external_store(self, store_name: str, delete_external_data: bool) -> None:
+        assert store_name in self.external_stores
+        store = self.external_stores[store_name]
         with Env.get().engine.begin() as conn:
-            self.version += 1
-            del self.remotes[remote]
-            preceding_schema_version = None
-            if len(stored_proxy_deletions_needed) > 0:
-                preceding_schema_version = self.schema_version
-                self.schema_version = self.version
-                proxy_cols = [col.stored_proxy for col in stored_proxy_deletions_needed]
-                for col in stored_proxy_deletions_needed:
-                    assert col.stored_proxy is not None and col.stored_proxy.proxy_base == col
-                    col.stored_proxy.proxy_base = None
-                    col.stored_proxy = None
-                # TODO Drop from base tables
-                self._drop_columns(proxy_cols)
-            self._update_md(timestamp, preceding_schema_version, conn)
-
-    def get_remotes(self) -> dict[pixeltable.datatransfer.Remote, dict[str, str]]:
-        return self.remotes
+            store.unlink(self, conn)  # May result in additional metadata changes
+            del self.external_stores[store_name]
+            self._update_md(time.time(), conn, update_tbl_version=False)
+
+        if delete_external_data and isinstance(store, pixeltable.io.external_store.Project):
+            store.delete()
 
     def is_view(self) -> bool:
         return self.base is not None
@@ -1110,14 +1064,17 @@ class TableVersion:
             args.append(exprs.ColumnRef(param))
         fn = func.make_function(
             col.compute_func, return_type=col.col_type, param_types=[arg.col_type for arg in args])
-        col.value_expr = fn(*args)
+        col.set_value_expr(fn(*args))
 
-    def _record_value_expr(self, col: Column) -> None:
+    def _record_refd_columns(self, col: Column) -> None:
         """Update Column.dependent_cols for all cols referenced in col.value_expr.
         """
-        assert col.value_expr is not None
-        from pixeltable.exprs import ColumnRef
-        refd_cols = [e.col for e in col.value_expr.subexprs(expr_class=ColumnRef)]
+        import pixeltable.exprs as 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)
 
@@ -1145,25 +1102,23 @@ class TableVersion:
 
     @classmethod
     def _create_column_md(cls, cols: List[Column]) -> dict[int, schema.ColumnMd]:
-        column_md: Dict[int, schema.ColumnMd] = {}
+        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
             column_md[col.id] = schema.ColumnMd(
                 id=col.id, col_type=col.col_type.as_dict(), is_pk=col.is_pk,
                 schema_version_add=col.schema_version_add, schema_version_drop=col.schema_version_drop,
-                value_expr=value_expr_dict, stored=col.stored,
-                proxy_base=col.proxy_base.id if col.proxy_base else None)
+                value_expr=value_expr_dict, stored=col.stored)
         return column_md
 
     @classmethod
-    def _create_remotes_md(cls, remotes: dict['pixeltable.datatransfer.Remote', dict[str, str]]) -> list[dict[str, Any]]:
+    def _create_stores_md(cls, stores: Iterable['pixeltable.io.ExternalStore']) -> list[dict[str, Any]]:
         return [
             {
-                'class': f'{type(remote).__module__}.{type(remote).__qualname__}',
-                'remote_md': remote.to_dict(),
-                'col_mapping': col_mapping
+                'class': f'{type(store).__module__}.{type(store).__qualname__}',
+                'md': store.as_dict()
             }
-            for remote, col_mapping in remotes.items()
+            for store in stores
         ]
 
     def _create_tbl_md(self) -> schema.TableMd:
@@ -1171,7 +1126,7 @@ class TableVersion:
             name=self.name, current_version=self.version, current_schema_version=self.schema_version,
             next_col_id=self.next_col_id, next_idx_id=self.next_idx_id, next_row_id=self.next_rowid,
             column_md=self._create_column_md(self.cols), index_md=self.idx_md,
-            remotes=self._create_remotes_md(self.remotes), view_md=self.view_md)
+            external_stores=self._create_stores_md(self.external_stores.values()), view_md=self.view_md)
 
     def _create_version_md(self, timestamp: float) -> schema.TableVersionMd:
         return schema.TableVersionMd(created_at=timestamp, version=self.version, schema_version=self.schema_version)
@@ -1184,3 +1139,13 @@ class TableVersion:
         return schema.TableSchemaVersionMd(
             schema_version=self.schema_version, preceding_schema_version=preceding_schema_version,
             columns=column_md, num_retained_versions=self.num_retained_versions, comment=self.comment)
+
+    def as_dict(self) -> dict:
+        return {'id': str(self.id), 'effective_version': self.effective_version}
+
+    @classmethod
+    def from_dict(cls, d: dict) -> 'TableVersion':
+        import pixeltable.catalog as catalog
+        id = UUID(d['id'])
+        effective_version = d['effective_version']
+        return catalog.Catalog.get().tbl_versions[(id, effective_version)]

pixeltable/catalog/table_version_path.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional, List, Union
+from typing import Optional, Union
 from uuid import UUID
 
 import pixeltable
+import pixeltable.catalog as catalog
 from .column import Column
 from .globals import POS_COLUMN_NAME
 from .table_version import TableVersion
@@ -59,13 +60,13 @@ class TableVersionPath:
     def is_insertable(self) -> bool:
         return self.tbl_version.is_insertable()
 
-    def get_tbl_versions(self) -> List[TableVersion]:
+    def get_tbl_versions(self) -> list[TableVersion]:
         """Return all tbl versions"""
         if self.base is None:
             return [self.tbl_version]
         return [self.tbl_version] + self.base.get_tbl_versions()
 
-    def get_bases(self) -> List[TableVersion]:
+    def get_bases(self) -> list[TableVersion]:
         """Return all tbl versions"""
         if self.base is None:
             return []
@@ -100,7 +101,7 @@ class TableVersionPath:
         from pixeltable.dataframe import DataFrame
         return DataFrame(self).__getitem__(index)
 
-    def columns(self) -> List[Column]:
+    def columns(self) -> list[Column]:
         """Return all user columns visible in this tbl version path, including columns from bases"""
         result = list(self.tbl_version.cols_by_name.values())
         if self.base is not None:
@@ -114,6 +115,11 @@ class TableVersionPath:
         cols = self.columns()
         return {col.name: col for col in cols}
 
+    def cols_by_id(self) -> dict[int, Column]:
+        """Return a dict of all user columns visible in this tbl version path, including columns from bases"""
+        cols = self.columns()
+        return {col.id: col for col in cols}
+
     def get_column(self, name: str, include_bases: bool = True) -> Optional[Column]:
         """Return the column with the given name, or None if not found"""
         col = self.tbl_version.cols_by_name.get(name)
@@ -136,3 +142,15 @@ class TableVersionPath:
             return self.base.has_column(col)
         else:
             return False
+
+    def as_dict(self) -> dict:
+        return {
+            'tbl_version': self.tbl_version.as_dict(),
+            'base': self.base.as_dict() if self.base is not None else None
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> TableVersionPath:
+        tbl_version = TableVersion.from_dict(d['tbl_version'])
+        base = TableVersionPath.from_dict(d['base']) if d['base'] is not None else None
+        return cls(tbl_version, base)

pixeltable/catalog/view.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import logging
-from typing import List, Optional, Type, Dict, Set, Any
+from typing import List, Optional, Type, Dict, Set, Any, Iterable
 from uuid import UUID
 import inspect
 
@@ -11,7 +11,7 @@ from .table_version import TableVersion
 from .table_version_path import TableVersionPath
 from .column import Column
 from .catalog import Catalog
-from .globals import POS_COLUMN_NAME
+from .globals import POS_COLUMN_NAME, UpdateStatus
 from pixeltable.env import Env
 from pixeltable.iterators import ComponentIterator
 from pixeltable.exceptions import Error
@@ -55,7 +55,7 @@ class View(Table):
 
         # verify that filter can be evaluated in the context of the base
         if predicate is not None:
-            if not predicate.is_bound_by(base.tbl_version_path):
+            if not predicate.is_bound_by(base._tbl_version_path):
                 raise excs.Error(f'Filter cannot be computed in the context of the base {base._name}')
             # create a copy that we can modify and store
             predicate = predicate.copy()
@@ -65,7 +65,7 @@ class View(Table):
             if not col.is_computed:
                 continue
             # 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.tbl_version_path):
+            if col.value_expr is not None and not col.value_expr.is_bound_by(base._tbl_version_path):
                 raise excs.Error(
                     f'Column {col.name}: value expression cannot be computed in the context of the base {base._name}')
 
@@ -83,7 +83,7 @@ class View(Table):
 
                 # construct Signature and type-check bound_args
                 params = [
-                    func.Parameter(param_name, param_type, inspect.Parameter.POSITIONAL_OR_KEYWORD)
+                    func.Parameter(param_name, param_type, kind=inspect.Parameter.POSITIONAL_OR_KEYWORD)
                     for param_name, param_type in iterator_cls.input_schema().items()
                 ]
                 sig = func.Signature(InvalidType(), params)
@@ -114,7 +114,7 @@ class View(Table):
             iterator_args_expr = InlineDict(iterator_args) if iterator_args is not None else None
             iterator_class_fqn = f'{iterator_cls.__module__}.{iterator_cls.__name__}' if iterator_cls is not None \
                 else None
-            base_version_path = cls._get_snapshot_path(base.tbl_version_path) if is_snapshot else base.tbl_version_path
+            base_version_path = cls._get_snapshot_path(base._tbl_version_path) if is_snapshot else base._tbl_version_path
             base_versions = [
                 (tbl_version.id.hex, tbl_version.version if is_snapshot or tbl_version.is_snapshot else None)
                 for tbl_version in base_version_path.get_tbl_versions()
@@ -127,7 +127,7 @@ class View(Table):
                     if iterator_args_expr is not None else None
                 for col in columns:
                     if col.value_expr is not None:
-                        col.value_expr = col.value_expr.retarget(base_version_path)
+                        col.set_value_expr(col.value_expr.retarget(base_version_path))
 
             view_md = md_schema.ViewMd(
                 is_snapshot=is_snapshot, predicate=predicate.as_dict() if predicate is not None else None,
@@ -148,7 +148,7 @@ class View(Table):
                 _logger.info(f'Created view `{name}`, id={tbl_version.id}')
 
                 from pixeltable.plan import Planner
-                plan, num_values_per_row = Planner.create_view_load_plan(view.tbl_version_path)
+                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, session.connection(), v_min=tbl_version.version)
                 print(f'Created view `{name}` with {num_rows} rows, {num_excs} exceptions.')
@@ -161,11 +161,13 @@ class View(Table):
             return view
 
     @classmethod
-    def _verify_column(cls, col: Column, existing_column_names: Set[str]) -> None:
+    def _verify_column(
+            cls, col: Column, existing_column_names: Set[str], existing_query_names: Optional[Set[str]] = None
+    ) -> None:
         # make sure that columns are nullable or have a default
         if not col.col_type.nullable and not col.is_computed:
             raise Error(f'Column {col.name}: non-computed columns in views must be nullable')
-        super()._verify_column(col, existing_column_names)
+        super()._verify_column(col, existing_column_names, existing_query_names)
 
     @classmethod
     def _get_snapshot_path(cls, tbl_version_path: TableVersionPath) -> TableVersionPath:
@@ -201,3 +203,11 @@ class View(Table):
         cat.tbl_dependents[self._base._id].remove(self)
         del cat.tbl_dependents[self._id]
 
+    def insert(
+            self, rows: Optional[Iterable[dict[str, Any]]] = None, /, *, print_stats: bool = False,
+            fail_on_exception: bool = True, **kwargs: Any
+    ) -> UpdateStatus:
+        raise excs.Error(f'{self.display_name()} {self._name!r}: cannot insert into view')
+
+    def delete(self, where: Optional['pixeltable.exprs.Predicate'] = None) -> UpdateStatus:
+        raise excs.Error(f'{self.display_name()} {self._name!r}: cannot delete from view')