pixeltable 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl

pixeltable/catalog/column.py

@@ -4,10 +4,8 @@ import logging
 from typing import Optional, Union, Callable, Set
 
 import sqlalchemy as sql
-from pgvector.sqlalchemy import Vector
 
 from pixeltable import exceptions as excs
-from pixeltable.metadata import schema
 from pixeltable.type_system import ColumnType, StringType
 from .globals import is_valid_identifier
 
@@ -20,44 +18,38 @@ class Column:
     table/view.
     """
     def __init__(
-            self, name: str, col_type: Optional[ColumnType] = None,
+            self, name: Optional[str], col_type: Optional[ColumnType] = None,
             computed_with: Optional[Union['Expr', Callable]] = None,
-            primary_key: bool = False, stored: Optional[bool] = None,
-            indexed: bool = False,
-            # these parameters aren't set by users
-            col_id: Optional[int] = None):
+            is_pk: bool = False, stored: Optional[bool] = None,
+            col_id: Optional[int] = None, schema_version_add: Optional[int] = None,
+            schema_version_drop: Optional[int] = None, sa_col_type: Optional[sql.sqltypes.TypeEngine] = None
+    ):
         """Column constructor.
 
         Args:
-            name: column name
+            name: column name; None for system columns (eg, index columns)
             col_type: column type; can be None if the type can be derived from ``computed_with``
             computed_with: a callable or an Expr object that computes the column value
-            primary_key: if True, this column is part of the primary key
+            is_pk: if True, this column is part of the primary key
             stored: determines whether a computed column is present in the stored table or recomputed on demand
-            indexed: if True, this column has a nearest neighbor index (only valid for image columns)
             col_id: column ID (only used internally)
 
         Computed columns: those have a non-None ``computed_with`` argument
-
         - when constructed by the user: ``computed_with`` was constructed explicitly and is passed in;
           col_type is None
         - when loaded from md store: ``computed_with`` is set and col_type is set
 
         ``computed_with`` is a Callable:
-
         - the callable's parameter names must correspond to existing columns in the table for which this Column
           is being used
         - ``col_type`` needs to be set to the callable's return type
 
         ``stored`` (only valid for computed image columns):
-
         - if True: the column is present in the stored table
         - if False: the column is not present in the stored table and recomputed during a query
         - if None: the system chooses for you (at present, this is always False, but this may change in the future)
-
-        indexed: only valid for image columns; if true, maintains an NN index for this column
         """
-        if not is_valid_identifier(name):
+        if name is not None and not is_valid_identifier(name):
             raise excs.Error(f"Invalid column name: '{name}'")
         self.name = name
         if col_type is None and computed_with is None:
@@ -90,35 +82,20 @@ class Column:
         self.stored = stored
         self.dependent_cols: Set[Column] = set()  # cols with value_exprs that reference us; set by TableVersion
         self.id = col_id
-        self.primary_key = primary_key
+        self.is_pk = is_pk
+        self.schema_version_add = schema_version_add
+        self.schema_version_drop = schema_version_drop
 
         # column in the stored table for the values of this Column
         self.sa_col: Optional[sql.schema.Column] = None
+        self.sa_col_type = sa_col_type
 
         # computed cols also have storage columns for the exception string and type
         self.sa_errormsg_col: Optional[sql.schema.Column] = None
         self.sa_errortype_col: Optional[sql.schema.Column] = None
-        # indexed columns also have a column for the embeddings
-        self.sa_idx_col: Optional[sql.schema.Column] = None
         from .table_version import TableVersion
         self.tbl: Optional[TableVersion] = None  # set by owning TableVersion
 
-        if indexed and not self.col_type.is_image_type():
-            raise excs.Error(f'Column {name}: indexed=True requires ImageType')
-        self.is_indexed = indexed
-
-    @classmethod
-    def from_md(cls, col_id: int, md: schema.SchemaColumn, tbl: 'TableVersion') -> Column:
-        """Construct a Column from metadata.
-
-        Leaves out value_expr, because that requires TableVersion.cols to be complete.
-        """
-        col = cls(
-            md.name, col_type=ColumnType.from_dict(md.col_type), primary_key=md.is_pk,
-            stored=md.stored, indexed=md.is_indexed, col_id=col_id)
-        col.tbl = tbl
-        return col
-
     def __hash__(self) -> int:
         assert self.tbl is not None
         return hash((self.tbl.id, self.id))
@@ -167,26 +144,26 @@ class Column:
         """
         assert self.is_stored
         # all storage columns are nullable (we deal with null errors in Pixeltable directly)
-        self.sa_col = sql.Column(self.storage_name(), self.col_type.to_sa_type(), nullable=True)
+        self.sa_col = sql.Column(
+            self.store_name(), self.col_type.to_sa_type() if self.sa_col_type is None else self.sa_col_type,
+            nullable=True)
         if self.is_computed or self.col_type.is_media_type():
-            self.sa_errormsg_col = sql.Column(self.errormsg_storage_name(), StringType().to_sa_type(), nullable=True)
-            self.sa_errortype_col = sql.Column(self.errortype_storage_name(), StringType().to_sa_type(), nullable=True)
-        if self.is_indexed:
-            self.sa_idx_col = sql.Column(self.index_storage_name(), Vector(512), nullable=True)
+            self.sa_errormsg_col = sql.Column(self.errormsg_store_name(), StringType().to_sa_type(), nullable=True)
+            self.sa_errortype_col = sql.Column(self.errortype_store_name(), StringType().to_sa_type(), nullable=True)
 
-    def storage_name(self) -> str:
+    def get_sa_col_type(self) -> sql.sqltypes.TypeEngine:
+        return self.col_type.to_sa_type() if self.sa_col_type is None else self.sa_col_type
+
+    def store_name(self) -> str:
         assert self.id is not None
         assert self.is_stored
         return f'col_{self.id}'
 
-    def errormsg_storage_name(self) -> str:
-        return f'{self.storage_name()}_errormsg'
-
-    def errortype_storage_name(self) -> str:
-        return f'{self.storage_name()}_errortype'
+    def errormsg_store_name(self) -> str:
+        return f'{self.store_name()}_errormsg'
 
-    def index_storage_name(self) -> str:
-        return f'{self.storage_name()}_idx_0'
+    def errortype_store_name(self) -> str:
+        return f'{self.store_name()}_errortype'
 
     def __str__(self) -> str:
         return f'{self.name}: {self.col_type}'

pixeltable/catalog/insertable_table.py

@@ -11,14 +11,17 @@ import pixeltable.type_system as ts
 from pixeltable import exceptions as excs
 from pixeltable.env import Env
 from .catalog import Catalog
+from .globals import UpdateStatus
 from .table import Table
 from .table_version import TableVersion
 from .table_version_path import TableVersionPath
 
 _logger = logging.getLogger('pixeltable')
 
+
 class InsertableTable(Table):
     """A `Table` that allows inserting and deleting rows."""
+
     def __init__(self, dir_id: UUID, tbl_version: TableVersion):
         tbl_version_path = TableVersionPath(tbl_version)
         super().__init__(tbl_version.id, dir_id, tbl_version.name, tbl_version_path)
@@ -42,7 +45,7 @@ class InsertableTable(Table):
             col = columns[column_names.index(pk_col)]
             if col.col_type.nullable:
                 raise excs.Error(f'Primary key column {pk_col} cannot be nullable')
-            col.primary_key = True
+            col.is_pk = True
 
         with orm.Session(Env.get().engine, future=True) as session:
             _, tbl_version = TableVersion.create(session, dir_id, name, columns, num_retained_versions, comment)
@@ -62,7 +65,7 @@ class InsertableTable(Table):
     @overload
     def insert(self, print_stats: bool = False, fail_on_exception: bool = True, **kwargs: Any): ...
 
-    def insert(self, *args, **kwargs) -> Table.UpdateStatus:
+    def insert(self, *args, **kwargs) -> UpdateStatus:
         """Insert rows into table.
 
         To insert multiple rows at a time:
@@ -161,7 +164,7 @@ class InsertableTable(Table):
                     msg = str(e)
                     raise excs.Error(f'Error in column {col.name}: {msg[0].lower() + msg[1:]}\nRow: {row}')
 
-    def delete(self, where: Optional['pixeltable.exprs.Predicate'] = None) -> Table.UpdateStatus:
+    def delete(self, where: Optional['pixeltable.exprs.Predicate'] = None) -> UpdateStatus:
         """Delete rows in this table.
 
         Args:
@@ -181,7 +184,7 @@ class InsertableTable(Table):
         if where is not None:
             if not isinstance(where, Predicate):
                 raise excs.Error(f"'where' argument must be a Predicate, got {type(where)}")
-            analysis_info = Planner.analyze(self.tbl_version, where)
+            analysis_info = Planner.analyze(self.tbl_version_path, where)
             if analysis_info.similarity_clause is not None:
                 raise excs.Error('nearest() cannot be used with delete()')
             # for now we require that the updated rows can be identified via SQL, rather than via a Python filter

pixeltable/catalog/table.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
-import dataclasses
 import json
 import logging
 from pathlib import Path
-from typing import Union, Any, List, Dict, Optional, Callable, Set, Tuple
+from typing import Union, Any, List, Dict, Optional, Callable, Set, Tuple, Iterable
 from uuid import UUID
 
 import pandas as pd
@@ -18,7 +17,7 @@ import pixeltable.exprs as exprs
 import pixeltable.metadata.schema as schema
 import pixeltable.type_system as ts
 from .column import Column
-from .globals import is_valid_identifier, is_system_column_name
+from .globals import is_valid_identifier, is_system_column_name, UpdateStatus
 from .schema_object import SchemaObject
 from .table_version import TableVersion
 from .table_version_path import TableVersionPath
@@ -28,14 +27,7 @@ _logger = logging.getLogger('pixeltable')
 class Table(SchemaObject):
     """Base class for all tabular SchemaObjects."""
 
-    @dataclasses.dataclass
-    class UpdateStatus:
-        num_rows: int = 0
-        # TODO: change to num_computed_columns (the number of computed slots isn't really meaningful to the user)
-        num_computed_values: int = 0
-        num_excs: int = 0
-        updated_cols: List[str] = dataclasses.field(default_factory=list)
-        cols_with_excs: List[str] = dataclasses.field(default_factory=list)
+    ROWID_COLUMN_NAME = '_rowid'
 
     def __init__(self, id: UUID, dir_id: UUID, name: str, tbl_version_path: TableVersionPath):
         super().__init__(id, name, dir_id)
@@ -225,7 +217,7 @@ class Table(SchemaObject):
             value: column type or value expression or column specification dictionary:
                 column type: a Pixeltable column type (if the table already contains rows, it must be nullable)
                 value expression: a Pixeltable expression that computes the column values
-                column specification: a dictionary with possible keys 'type', 'value', 'stored', 'indexed'
+                column specification: a dictionary with possible keys 'type', 'value', 'stored'
         Examples:
             Add an int column with ``None`` values:
 
@@ -247,11 +239,6 @@ class Table(SchemaObject):
             Do the same, but now the column is stored:
 
             >>> tbl['rotated'] = {'value': tbl.frame.rotate(90), 'stored': True}
-
-            Add a resized version of the ``frame`` column and index it. The column does not need to be stored in order
-            to be indexed:
-
-            >>> tbl['small_frame'] = {'value': tbl.frame.resize([224, 224]), 'indexed': True}
         """
         if not isinstance(column_name, str):
             raise excs.Error(f'Column name must be a string, got {type(column_name)}')
@@ -264,8 +251,8 @@ class Table(SchemaObject):
 
     def add_column(
             self, *,
-            type: Optional[ts.ColumnType] = None, stored: Optional[bool] = None, indexed: Optional[bool] = None,
-            print_stats: bool = False, **kwargs: Any
+            type: Optional[ts.ColumnType] = None, stored: Optional[bool] = None, print_stats: bool = False,
+            **kwargs: Any
     ) -> UpdateStatus:
         """Adds a column to the table.
 
@@ -273,7 +260,6 @@ class Table(SchemaObject):
             kwargs: Exactly one keyword argument of the form ``column-name=type|value-expression``.
             type: The type of the column. Only valid and required if ``value-expression`` is a Callable.
             stored: Whether the column is materialized and stored or computed on demand. Only valid for image columns.
-            indexed: Whether the column is indexed.
             print_stats: If ``True``, print execution metrics.
 
         Returns:
@@ -318,15 +304,6 @@ class Table(SchemaObject):
             Alternatively, this can also be expressed as:
 
             >>> tbl['rotated'] = {'value': tbl.frame.rotate(90), 'stored': True}
-
-            Add a resized version of the ``frame`` column and index it. The column does not need to be stored in order
-            to be indexed:
-
-            >>> tbl.add_column(small_frame=tbl.frame.resize([224, 224]), indexed=True)
-
-            Alternatively, this can also be expressed as:
-
-            >>> tbl['small_frame'] = {'value': tbl.frame.resize([224, 224]), 'indexed': True}
         """
         self._check_is_dropped()
         # verify kwargs and construct column schema dict
@@ -349,8 +326,6 @@ class Table(SchemaObject):
             col_schema['type'] = type
         if stored is not None:
             col_schema['stored'] = stored
-        if indexed is not None:
-            col_schema['indexed'] = indexed
 
         new_col = self._create_columns({col_name: col_schema})[0]
         self._verify_column(new_col, self.column_names())
@@ -364,7 +339,7 @@ class Table(SchemaObject):
         (on account of containing Python Callables or Exprs).
         """
         assert isinstance(spec, dict)
-        valid_keys = {'type', 'value', 'stored', 'indexed'}
+        valid_keys = {'type', 'value', 'stored'}
         has_type = False
         for k in spec.keys():
             if k not in valid_keys:
@@ -393,8 +368,6 @@ class Table(SchemaObject):
 
         if 'stored' in spec and not isinstance(spec['stored'], bool):
             raise excs.Error(f'Column {name}: "stored" must be a bool, got {spec["stored"]}')
-        if 'indexed' in spec and not isinstance(spec['indexed'], bool):
-            raise excs.Error(f'Column {name}: "indexed" must be a bool, got {spec["indexed"]}')
         if not has_type:
             raise excs.Error(f'Column {name}: "type" is required')
 
@@ -406,7 +379,6 @@ class Table(SchemaObject):
             col_type: Optional[ts.ColumnType] = None
             value_expr: Optional[exprs.Expr] = None
             stored: Optional[bool] = None
-            indexed: Optional[bool] = None
             primary_key: Optional[bool] = None
 
             if isinstance(spec, ts.ColumnType):
@@ -428,12 +400,10 @@ class Table(SchemaObject):
                     # create copy so we can modify it
                     value_expr = value_expr.copy()
                 stored = spec.get('stored')
-                indexed = spec.get('indexed')
                 primary_key = spec.get('primary_key')
 
             column = Column(
-                name, col_type=col_type, computed_with=value_expr, stored=stored, indexed=indexed,
-                primary_key=primary_key)
+                name, col_type=col_type, computed_with=value_expr, stored=stored, is_pk=primary_key)
             columns.append(column)
         return columns
 
@@ -498,9 +468,85 @@ class Table(SchemaObject):
         self._check_is_dropped()
         self.tbl_version_path.tbl_version.rename_column(old_name, new_name)
 
+    def add_embedding_index(
+            self, col_name: str, *, idx_name: Optional[str] = None,
+            text_embed: Optional[pixeltable.Function] = None, img_embed: Optional[pixeltable.Function] = None
+    ) -> None:
+        """Add an index to the table.
+        Args:
+            col_name: name of column to index
+            idx_name: name of index, which needs to be unique for the table; if not provided, a name will be generated
+            idx_type: type of index (one of 'embedding')
+
+        Raises:
+            Error: If an index with that name already exists for the table or if the column does not exist.
+
+        Examples:
+            Add an index to the ``img`` column:
+
+            >>> tbl.add_embedding_index('img', text_embed=...)
+
+            Add another index to the ``img`` column, with a specific name:
+
+            >>> tbl.add_embedding_index('img', idx_name='clip_idx', text_embed=...)
+        """
+        if self.tbl_version_path.is_snapshot():
+            raise excs.Error('Cannot add an index to a snapshot')
+        self._check_is_dropped()
+        col = self.tbl_version_path.get_column(col_name, include_bases=True)
+        if col is None:
+            raise excs.Error(f'Column {col_name} unknown')
+        if idx_name is not None and idx_name in self.tbl_version_path.tbl_version.idxs_by_name:
+            raise excs.Error(f'Duplicate index name: {idx_name}')
+        from pixeltable.index import EmbeddingIndex
+        # create the EmbeddingIndex instance to verify args
+        idx = EmbeddingIndex(col, text_embed=text_embed, img_embed=img_embed)
+        status = self.tbl_version_path.tbl_version.add_index(col, idx_name=idx_name, idx=idx)
+        # TODO: how to deal with exceptions here? drop the index and raise?
+
+    def drop_index(self, *, column_name: Optional[str] = None, idx_name: Optional[str] = None) -> None:
+        """Drop an index from the table.
+
+        Args:
+            column_name: The name of the column whose index to drop. Invalid if the column has multiple indices.
+            idx_name: The name of the index to drop.
+
+        Raises:
+            Error: If the index does not exist.
+
+        Examples:
+            Drop index on the ``img`` column:
+
+            >>> tbl.drop_index(column_name='img')
+        """
+        if self.tbl_version_path.is_snapshot():
+            raise excs.Error('Cannot drop an index from a snapshot')
+        self._check_is_dropped()
+        if (column_name is None) == (idx_name is None):
+            raise excs.Error('Exactly one of column_name or idx_name must be provided')
+        tbl_version = self.tbl_version_path.tbl_version
+
+        if idx_name is not None:
+            if idx_name not in tbl_version.idxs_by_name:
+                raise excs.Error(f'Index {idx_name} does not exist')
+            idx_id = tbl_version.idxs_by_name[idx_name].id
+        else:
+            col = self.tbl_version_path.get_column(column_name, include_bases=True)
+            if col is None:
+                raise excs.Error(f'Column {column_name} unknown')
+            if col.tbl.id != tbl_version.id:
+                raise excs.Error(
+                    f'Column {column_name}: cannot drop index from column that belongs to base ({col.tbl.name})')
+            idx_ids = [info.id for info in tbl_version.idxs_by_name.values() if info.col.id == col.id]
+            if len(idx_ids) == 0:
+                raise excs.Error(f'Column {column_name} does not have an index')
+            if len(idx_ids) > 1:
+                raise excs.Error(f'Column {column_name} has multiple indices; specify idx_name instead')
+            idx_id = idx_ids[0]
+        self.tbl_version_path.tbl_version.drop_index(idx_id)
+
     def update(
-            self, value_spec: Dict[str, Union['pixeltable.exprs.Expr', Any]],
-            where: Optional['pixeltable.exprs.Predicate'] = None, cascade: bool = True
+            self, value_spec: dict[str, Any], where: Optional['pixeltable.exprs.Predicate'] = None, cascade: bool = True
     ) -> UpdateStatus:
         """Update rows in this table.
 
@@ -510,11 +556,11 @@ class Table(SchemaObject):
             cascade: if True, also update all computed columns that transitively depend on the updated columns.
 
         Examples:
-            Set newly-added column `int_col` to 1 for all rows:
+            Set column `int_col` to 1 for all rows:
 
             >>> tbl.update({'int_col': 1})
 
-            Set newly-added column `int_col` to 1 for all rows where `int_col` is 0:
+            Set column `int_col` to 1 for all rows where `int_col` is 0:
 
             >>> tbl.update({'int_col': 1}, where=tbl.int_col == 0)
 
@@ -526,27 +572,95 @@ class Table(SchemaObject):
 
             >>> tbl.update({'int_col': tbl.int_col + 1}, where=tbl.int_col == 0)
         """
+        if self.tbl_version_path.is_snapshot():
+            raise excs.Error('Cannot update a snapshot')
+        self._check_is_dropped()
+
+        update_spec = self._validate_update_spec(value_spec, allow_pk=False, allow_exprs=True)
+        from pixeltable.plan import Planner
+        if where is not None:
+            if not isinstance(where, exprs.Predicate):
+                raise excs.Error(f"'where' argument must be a Predicate, got {type(where)}")
+            analysis_info = Planner.analyze(self.tbl_version_path, where)
+            if analysis_info.similarity_clause is not None:
+                raise excs.Error('nearest() cannot be used with update()')
+            # for now we require that the updated rows can be identified via SQL, rather than via a Python filter
+            if analysis_info.filter is not None:
+                raise excs.Error(f'Filter {analysis_info.filter} not expressible in SQL')
+
+        return self.tbl_version_path.tbl_version.update(update_spec, where, cascade)
+
+    def batch_update(self, rows: Iterable[dict[str, Any]], cascade: bool = True) -> UpdateStatus:
+        """Update rows in this table.
+
+        Args:
+            rows: an Iterable of dictionaries containing values for the updated columns plus values for the primary key
+                  columns.
+            cascade: if True, also update all computed columns that transitively depend on the updated columns.
+
+        Examples:
+            Update the 'name' and 'age' columns for the rows with ids 1 and 2 (assuming 'id' is the primary key):
+
+            >>> tbl.update([{'id': 1, 'name': 'Alice', 'age': 30}, {'id': 2, 'name': 'Bob', 'age': 40}])
+        """
+        if self.tbl_version_path.is_snapshot():
+            raise excs.Error('Cannot update a snapshot')
+        self._check_is_dropped()
+
+        row_updates: List[Dict[Column, exprs.Expr]] = []
+        pk_col_names = set(c.name for c in self.tbl_version_path.tbl_version.primary_key_columns())
+
+        # pseudo-column _rowid: contains the rowid of the row to update and can be used instead of the primary key
+        has_rowid = self.ROWID_COLUMN_NAME in rows[0]
+        rowids: list[Tuple[int, ...]] = []
+        if len(pk_col_names) == 0 and not has_rowid:
+            raise excs.Error('Table must have primary key for batch update')
+
+        for row_spec in rows:
+            col_vals = self._validate_update_spec(row_spec, allow_pk=not has_rowid, allow_exprs=False)
+            if has_rowid:
+                # we expect the _rowid column to be present for each row
+                assert self.ROWID_COLUMN_NAME in row_spec
+                rowids.append(row_spec[self.ROWID_COLUMN_NAME])
+            else:
+                col_names = set(col.name for col in col_vals.keys())
+                if any(pk_col_name not in col_names for pk_col_name in pk_col_names):
+                    missing_cols = pk_col_names - set(col.name for col in col_vals.keys())
+                    raise excs.Error(f'Primary key columns ({", ".join(missing_cols)}) missing in {row_spec}')
+            row_updates.append(col_vals)
+        return self.tbl_version_path.tbl_version.batch_update(row_updates, rowids, cascade)
+
+    def _validate_update_spec(
+            self, value_spec: dict[str, Any], allow_pk: bool, allow_exprs: bool
+    ) -> dict[Column, 'pixeltable.exprs.Expr']:
         from pixeltable import exprs
-        update_targets: List[Tuple[Column, exprs.Expr]] = []
+        update_targets: dict[Column, exprs.Expr] = {}
         for col_name, val in value_spec.items():
             if not isinstance(col_name, str):
                 raise excs.Error(f'Update specification: dict key must be column name, got {col_name!r}')
+            if col_name == self.ROWID_COLUMN_NAME:
+                # ignore pseudo-column _rowid
+                continue
             col = self.tbl_version_path.get_column(col_name, include_bases=False)
             if col is None:
                 # TODO: return more informative error if this is trying to update a base column
                 raise excs.Error(f'Column {col_name} unknown')
             if col.is_computed:
                 raise excs.Error(f'Column {col_name} is computed and cannot be updated')
-            if col.primary_key:
+            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():
                 raise excs.Error(f'Column {col_name} has type image/video/audio/document and cannot be updated')
 
             # make sure that the value is compatible with the column type
-            # check if this is a literal
             try:
+                # check if this is a literal
                 value_expr = exprs.Literal(val, col_type=col.col_type)
             except TypeError:
+                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})')
                 # 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:
@@ -556,20 +670,10 @@ class Table(SchemaObject):
                         f'Type of value {val!r} ({value_expr.col_type}) is not compatible with the type of column '
                         f'{col_name} ({col.col_type})'
                     ))
-            update_targets.append((col, value_expr))
+            update_targets[col] = value_expr
 
-        from pixeltable.plan import Planner
-        if where is not None:
-            if not isinstance(where, exprs.Predicate):
-                raise excs.Error(f"'where' argument must be a Predicate, got {type(where)}")
-            analysis_info = Planner.analyze(self.tbl_version_path, where)
-            if analysis_info.similarity_clause is not None:
-                raise excs.Error('nearest() cannot be used with update()')
-            # for now we require that the updated rows can be identified via SQL, rather than via a Python filter
-            if analysis_info.filter is not None:
-                raise excs.Error(f'Filter {analysis_info.filter} not expressible in SQL')
+        return update_targets
 
-        return self.tbl_version_path.tbl_version.update(update_targets, where, cascade)
 
     def revert(self) -> None:
         """Reverts the table to the previous version.
@@ -577,5 +681,7 @@ class Table(SchemaObject):
         .. warning::
             This operation is irreversible.
         """
+        if self.tbl_version_path.is_snapshot():
+            raise excs.Error('Cannot revert a snapshot')
         self._check_is_dropped()
         self.tbl_version_path.tbl_version.revert()