pixeltable 0.0.0__py3-none-any.whl

pixeltable/__init__.py

@@ -0,0 +1,53 @@
+from .catalog import Column, Table, InsertableTable, View
+from .dataframe import DataFrame
+from .exceptions import Error, Error
+from .exprs import RELATIVE_PATH_ROOT
+from .func import Function, udf, uda, Aggregator, expr_udf
+from .globals import *
+from .type_system import (
+    ColumnType,
+    StringType,
+    IntType,
+    FloatType,
+    BoolType,
+    TimestampType,
+    JsonType,
+    ArrayType,
+    ImageType,
+    VideoType,
+    AudioType,
+    DocumentType,
+)
+from .utils.help import help
+
+# noinspection PyUnresolvedReferences
+from . import functions, io
+from .__version__ import __version__, __version_tuple__
+
+__all__ = [
+    'DataFrame',
+    'Column',
+    'Table',
+    'InsertableTable',
+    'View',
+    'Error',
+    'ColumnType',
+    'StringType',
+    'IntType',
+    'FloatType',
+    'BoolType',
+    'TimestampType',
+    'JsonType',
+    'RELATIVE_PATH_ROOT',
+    'ArrayType',
+    'ImageType',
+    'VideoType',
+    'AudioType',
+    'DocumentType',
+    'Function',
+    'help',
+    'udf',
+    'Aggregator',
+    'uda',
+    'expr_udf',
+]

pixeltable/__version__.py

@@ -0,0 +1,3 @@
+# These version placeholders will be replaced during build.
+__version__ = "0.0.0"
+__version_tuple__ = (0, 0, 0)

pixeltable/catalog/__init__.py

@@ -0,0 +1,13 @@
+from .catalog import Catalog
+from .column import Column
+from .table_version_path import TableVersionPath
+from .table_version import TableVersion
+from .schema_object import SchemaObject
+from .named_function import NamedFunction
+from .dir import Dir
+from .table import Table
+from .insertable_table import InsertableTable
+from .view import View
+from .path import Path
+from .path_dict import PathDict
+from .globals import is_valid_identifier, is_valid_path

pixeltable/catalog/catalog.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+from typing import Optional, List, Any, Dict, Tuple
+from uuid import UUID
+import dataclasses
+import logging
+
+import sqlalchemy as sql
+import sqlalchemy.orm as orm
+
+from .table_version import TableVersion
+from .table_version_path import TableVersionPath
+from .table import Table
+from .named_function import NamedFunction
+from .path_dict import PathDict
+import pixeltable.env as env
+import pixeltable.metadata.schema as schema
+
+_logger = logging.getLogger('pixeltable')
+
+class Catalog:
+    """A repository of catalog objects"""
+    _instance: Optional[Catalog] = None
+
+    @classmethod
+    def get(cls) -> Catalog:
+        if cls._instance is None:
+            cls._instance = cls()
+            with orm.Session(env.Env.get().engine, future=True) as session:
+                cls._instance._load_table_versions(session)
+                #cls._instance._load_functions(session)
+        return cls._instance
+
+    @classmethod
+    def clear(cls) -> None:
+        """Remove the instance. Used for testing."""
+        cls._instance = None
+
+    def __init__(self) -> None:
+        # key: [id, version]
+        # - mutable version of a table: version == None (even though TableVersion.version is set correctly)
+        # - snapshot versions: records the version of the snapshot
+        self.tbl_versions: Dict[Tuple[UUID, int], TableVersion] = {}
+
+        self.tbls: Dict[UUID, Table] = {}  # don't use a defaultdict here, it doesn't cooperate with the debugger
+        self.tbl_dependents: Dict[UUID, List[Table]] = {}
+
+        self._init_store()
+        self.paths = PathDict()  # do this after _init_catalog()
+
+    def _init_store(self) -> None:
+        """One-time initialization of the stored catalog. Idempotent."""
+        with orm.Session(env.Env.get().engine, future=True) as session:
+            if session.query(sql.func.count(schema.Dir.id)).scalar() > 0:
+                return
+            # create a top-level directory, so that every schema object has a directory
+            dir_md = schema.DirMd(name='')
+            dir_record = schema.Dir(parent_id=None, md=dataclasses.asdict(dir_md))
+            session.add(dir_record)
+            session.flush()
+            session.commit()
+            _logger.info(f'Initialized catalog')
+
+    def _load_snapshot_version(
+            self, tbl_id: UUID, version: int, base: Optional[TableVersion], session: orm.Session
+    ) -> TableVersion:
+        q = session.query(schema.Table, schema.TableSchemaVersion) \
+            .select_from(schema.Table) \
+            .join(schema.TableVersion) \
+            .join(schema.TableSchemaVersion) \
+            .where(schema.Table.id == tbl_id) \
+            .where(sql.text(f"({schema.TableVersion.__table__}.md->>'version')::int = {version}")) \
+            .where(sql.text((
+                f"({schema.TableVersion.__table__}.md->>'schema_version')::int = "
+                f"{schema.TableSchemaVersion.__table__}.{schema.TableSchemaVersion.schema_version.name}")))
+        tbl_record, schema_version_record = q.one()
+        tbl_md = schema.md_from_dict(schema.TableMd, tbl_record.md)
+        schema_version_md = schema.md_from_dict(schema.TableSchemaVersionMd, schema_version_record.md)
+        # we ignore tbl_record.base_tbl_id/base_snapshot_id and use 'base' instead: if the base is a snapshot
+        # we'd have to look that up first
+        return TableVersion(tbl_record.id, tbl_md, version, schema_version_md, is_snapshot=True, base=base)
+
+    def _load_table_versions(self, session: orm.Session) -> None:
+        from .insertable_table import InsertableTable
+        from .view import View
+
+        # load tables/views;
+        # do this in ascending order of creation ts so that we can resolve base references in one pass
+        q = session.query(schema.Table, schema.TableSchemaVersion) \
+            .select_from(schema.Table) \
+            .join(schema.TableVersion) \
+            .join(schema.TableSchemaVersion) \
+            .where(sql.text(f"({schema.TableVersion.__table__}.md->>'version')::int = 0")) \
+            .where(sql.text((
+                f"({schema.Table.__table__}.md->>'current_schema_version')::int = "
+                f"{schema.TableSchemaVersion.__table__}.{schema.TableSchemaVersion.schema_version.name}"))) \
+            .order_by(sql.text(f"({schema.TableVersion.__table__}.md->>'created_at')::float"))
+
+        for tbl_record, schema_version_record in q.all():
+            tbl_md = schema.md_from_dict(schema.TableMd, tbl_record.md)
+            schema_version_md = schema.md_from_dict(schema.TableSchemaVersionMd, schema_version_record.md)
+            view_md = tbl_md.view_md
+
+            if view_md is not None:
+                assert len(view_md.base_versions) > 0
+                # construct a TableVersionPath for the view
+                refd_versions = [(UUID(tbl_id), version) for tbl_id, version in view_md.base_versions]
+                base_path: Optional[TableVersionPath] = None
+                base: Optional[TableVersion] = None
+                # go through the versions in reverse order, so we can construct TableVersionPaths
+                for base_id, version in refd_versions[::-1]:
+                    base_version = self.tbl_versions.get((base_id, version), None)
+                    if base_version is None:
+                        if version is None:
+                            # debugging
+                            pass
+                        # if this is a reference to a mutable table, we should have loaded it already
+                        assert version is not None
+                        base_version = self._load_snapshot_version(base_id, version, base, session)
+                    base_path = TableVersionPath(base_version, base=base_path)
+                    base = base_version
+                assert base_path is not None
+
+                base_tbl = self.tbls[base_path.tbl_version.id]
+                is_snapshot = view_md is not None and view_md.is_snapshot
+                snapshot_only = is_snapshot and view_md.predicate is None and len(schema_version_md.columns) == 0
+                if snapshot_only:
+                    # this is a pure snapshot, without a physical table backing it
+                    view_path = base_path
+                else:
+                    tbl_version = TableVersion(
+                        tbl_record.id, tbl_md, tbl_md.current_version, schema_version_md, is_snapshot=is_snapshot,
+                        base=base_path.tbl_version if is_snapshot else None,
+                        base_path=base_path if not is_snapshot else None)
+                    view_path = TableVersionPath(tbl_version, base=base_path)
+
+                tbl = View(
+                    tbl_record.id, tbl_record.dir_id, tbl_md.name, view_path, base_tbl,
+                    snapshot_only=snapshot_only)
+                self.tbl_dependents[base_tbl._id].append(tbl)
+
+            else:
+                tbl_version = TableVersion(tbl_record.id, tbl_md, tbl_md.current_version, schema_version_md)
+                tbl = InsertableTable(tbl_record.dir_id, tbl_version)
+
+            self.tbls[tbl._id] = tbl
+            self.tbl_dependents[tbl._id] = []
+            self.paths.add_schema_obj(tbl._dir_id, tbl_md.name, tbl)
+
+    # def _load_functions(self, session: orm.Session) -> None:
+    #     # load Function metadata; doesn't load the actual callable, which can be large and is only done on-demand by the
+    #     # FunctionRegistry
+    #     q = session.query(schema.Function.id, schema.Function.dir_id, schema.Function.md) \
+    #         .where(sql.text(f"({schema.Function.__table__}.md->>'name')::text IS NOT NULL"))
+    #     for id, dir_id, md in q.all():
+    #         assert 'name' in md
+    #         name = md['name']
+    #         assert name is not None
+    #         named_fn = NamedFunction(id, dir_id, name)
+    #         self.paths.add_schema_obj(dir_id, name, named_fn)

pixeltable/catalog/column.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import logging
+from typing import Optional, Union, Callable, Set
+
+import sqlalchemy as sql
+
+import pixeltable.exceptions as excs
+import pixeltable.type_system as ts
+from .globals import is_valid_identifier
+
+_logger = logging.getLogger('pixeltable')
+
+class Column:
+    """Representation of a column in the schema of a Table/DataFrame.
+
+    A Column contains all the metadata necessary for executing queries and updates against a particular version of a
+    table/view.
+    """
+    def __init__(
+            self, name: Optional[str], col_type: Optional[ts.ColumnType] = None,
+            computed_with: Optional[Union['Expr', Callable]] = 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; 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
+            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
+            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)
+        """
+        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:
+            raise excs.Error(f'Column `{name}`: col_type is required if computed_with is not specified')
+
+        self.value_expr: Optional['Expr'] = None
+        self.compute_func: Optional[Callable] = None
+        from pixeltable import exprs
+        if computed_with is not None:
+            value_expr = exprs.Expr.from_object(computed_with)
+            if value_expr is None:
+                # computed_with needs to be a Callable
+                if not isinstance(computed_with, Callable):
+                    raise excs.Error(
+                        f'Column {name}: computed_with needs to be either a Pixeltable expression or a Callable, '
+                        f'but it is a {type(computed_with)}')
+                if col_type is None:
+                    raise excs.Error(f'Column {name}: col_type is required if computed_with is a Callable')
+                # we need to turn the computed_with function into an Expr, but this requires resolving
+                # column name references and for that we need to wait until we're assigned to a Table
+                self.compute_func = computed_with
+            else:
+                self.value_expr = value_expr.copy()
+                self.col_type = self.value_expr.col_type
+
+        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[Column] = set()  # cols with value_exprs that reference us; set by TableVersion
+        self.id = col_id
+        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
+        from .table_version import TableVersion
+        self.tbl: Optional[TableVersion] = None  # set by owning TableVersion
+
+    def __hash__(self) -> int:
+        assert self.tbl is not None
+        return hash((self.tbl.id, self.id))
+
+    def check_value_expr(self) -> None:
+        assert self.value_expr is not None
+        if self.stored == False and self.is_computed and self.has_window_fn_call():
+            raise excs.Error(
+                f'Column {self.name}: stored={self.stored} not supported for columns computed with window functions:'
+                f'\n{self.value_expr}')
+
+    def has_window_fn_call(self) -> bool:
+        if self.value_expr is None:
+            return False
+        from pixeltable import exprs
+        l = list(self.value_expr.subexprs(filter=lambda e: isinstance(e, exprs.FunctionCall) and e.is_window_fn_call))
+        return len(l) > 0
+
+    def get_idx_info(self) -> dict[str, 'pixeltable.catalog.TableVersion.IndexInfo']:
+        assert self.tbl is not None
+        return {name: info for name, info in self.tbl.idxs_by_name.items() if info.col == self}
+
+    @property
+    def is_computed(self) -> bool:
+        return self.compute_func is not None or self.value_expr is not None
+
+    @property
+    def is_stored(self) -> bool:
+        """Returns True if column is materialized in the stored table."""
+        assert self.stored is not None
+        return self.stored
+
+    @property
+    def records_errors(self) -> bool:
+        """True if this column also stores error information."""
+        return self.is_stored and (self.is_computed or self.col_type.is_media_type())
+
+    def source(self) -> None:
+        """
+        If this is a computed col and the top-level expr is a function call, print the source, if possible.
+        """
+        from pixeltable import exprs
+        if self.value_expr is None or not isinstance(self.value_expr, exprs.FunctionCall):
+            return
+        self.value_expr.fn.source()
+
+    def create_sa_cols(self) -> None:
+        """
+        These need to be recreated for every new table schema version.
+        """
+        assert self.is_stored
+        # all storage columns are nullable (we deal with null errors in Pixeltable directly)
+        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_store_name(), ts.StringType().to_sa_type(), nullable=True)
+            self.sa_errortype_col = sql.Column(self.errortype_store_name(), ts.StringType().to_sa_type(), nullable=True)
+
+    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_store_name(self) -> str:
+        return f'{self.store_name()}_errormsg'
+
+    def errortype_store_name(self) -> str:
+        return f'{self.store_name()}_errortype'
+
+    def __str__(self) -> str:
+        return f'{self.name}: {self.col_type}'
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Column):
+            return False
+        assert self.tbl is not None
+        assert other.tbl is not None
+        return self.tbl.id == other.tbl.id and self.id == other.id
+

pixeltable/catalog/dir.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import dataclasses
+import logging
+from uuid import UUID
+
+import sqlalchemy as sql
+
+from .schema_object import SchemaObject
+from pixeltable.env import Env
+from pixeltable.metadata import schema
+
+
+_logger = logging.getLogger('pixeltable')
+
+class Dir(SchemaObject):
+    def __init__(self, id: UUID, parent_id: UUID, name: str):
+        super().__init__(id, name, parent_id)
+
+    @classmethod
+    def display_name(cls) -> str:
+        return 'directory'
+
+    def move(self, new_name: str, new_dir_id: UUID) -> None:
+        super().move(new_name, new_dir_id)
+        with Env.get().engine.begin() as conn:
+            dir_md = schema.DirMd(name=new_name)
+            conn.execute(
+                sql.update(schema.Dir.__table__)
+                .values({schema.Dir.parent_id: self._dir_id, schema.Dir.md: dataclasses.asdict(dir_md)})
+                .where(schema.Dir.id == self._id))
+

pixeltable/catalog/globals.py

@@ -0,0 +1,33 @@
+from typing import List
+import dataclasses
+import logging
+
+
+_logger = logging.getLogger('pixeltable')
+
+# name of the position column in a component view
+POS_COLUMN_NAME = 'pos'
+
+@dataclasses.dataclass
+class UpdateStatus:
+    num_rows: int = 0
+    # TODO: disambiguate what this means: # of slots computed or # of columns computed?
+    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)
+
+def is_valid_identifier(name: str) -> bool:
+    return name.isidentifier() and not name.startswith('_')
+
+def is_valid_path(path: str, empty_is_valid : bool) -> bool:
+    if path == '':
+        return empty_is_valid
+
+    for part in path.split('.'):
+        if not is_valid_identifier(part):
+            return False
+    return True
+
+def is_system_column_name(name: str) -> bool:
+    return name == POS_COLUMN_NAME

pixeltable/catalog/insertable_table.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import logging
+from typing import Optional, List, Any, Dict, overload, Iterable
+from uuid import UUID
+
+import sqlalchemy.orm as orm
+
+import pixeltable
+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)
+
+    @classmethod
+    def display_name(cls) -> str:
+        return 'table'
+
+    # MODULE-LOCAL, NOT PUBLIC
+    @classmethod
+    def create(
+            cls, dir_id: UUID, name: str, schema: Dict[str, ts.ColumnType], primary_key: List[str],
+            num_retained_versions: int, comment: str
+    ) -> InsertableTable:
+        columns = cls._create_columns(schema)
+        cls._verify_schema(columns)
+        column_names = [col.name for col in columns]
+        for pk_col in primary_key:
+            if pk_col not in column_names:
+                raise excs.Error(f'Primary key column {pk_col} not found in table schema')
+            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.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)
+            tbl = cls(dir_id, tbl_version)
+            session.commit()
+            cat = Catalog.get()
+            cat.tbl_dependents[tbl._id] = []
+            cat.tbls[tbl._id] = tbl
+
+            _logger.info(f'Created table `{name}`, id={tbl_version.id}')
+            print(f'Created table `{name}`.')
+            return tbl
+
+    @overload
+    def insert(self, rows: Iterable[Dict[str, Any]], /, print_stats: bool = False, fail_on_exception: bool = True): ...
+
+    @overload
+    def insert(self, print_stats: bool = False, fail_on_exception: bool = True, **kwargs: Any): ...
+
+    def insert(self, *args, **kwargs) -> UpdateStatus:
+        """Insert rows into table.
+
+        To insert multiple rows at a time:
+
+        ``insert(rows: List[Dict[str, Any]], print_stats: bool = False, fail_on_exception: bool = True)``
+
+        To insert just a single row, you can use the more convenient syntax:
+        ``insert(print_stats: bool = False, fail_on_exception: bool = True, **kwargs: Any)``
+
+        Args:
+            rows: (if inserting multiple rows) A list of rows to insert, each of which is a dictionary mapping column
+                names to values.
+            kwargs: (if inserting a single row) keyword-argument pairs representing column names and values.
+            print_stats: If ``True``, print statistics about the cost of computed columns.
+            fail_on_exception:
+                Determines how exceptions in computed columns and invalid media files (e.g., corrupt images)
+                are handled.
+                If ``False``, store error information (accessible as column properties 'errortype' and 'errormsg')
+                for those cases, but continue inserting rows.
+                If ``True``, raise an exception that aborts the insert.
+
+        Returns:
+            execution status
+
+        Raises:
+            Error: if a row does not match the table schema or contains values for computed columns
+
+        Examples:
+            Insert two rows into a table with three int columns ``a``, ``b``, and ``c``. Column ``c`` is nullable.
+
+            >>> tbl.insert([{'a': 1, 'b': 1, 'c': 1}, {'a': 2, 'b': 2}])
+
+            Insert a single row into a table with three int columns ``a``, ``b``, and ``c``.
+
+            >>> tbl.insert(a=1, b=1, c=1)
+        """
+        print_stats = kwargs.pop('print_stats', False)
+        fail_on_exception = kwargs.pop('fail_on_exception', True)
+        if len(args) > 0:
+            # There's a positional argument; this means `rows` is expressed as a
+            # list of dicts (multi-insert)
+            rows = list(args[0])
+        else:
+            # No positional argument; this means we're inserting a single row
+            # using kwargs syntax
+            rows = [kwargs]
+
+        if not isinstance(rows, list):
+            raise excs.Error('rows must be a list of dictionaries')
+        if len(rows) == 0:
+            raise excs.Error('rows must not be empty')
+        for row in rows:
+            if not isinstance(row, dict):
+                raise excs.Error('rows must be a list of dictionaries')
+        self._validate_input_rows(rows)
+        result = self.tbl_version.insert(rows, print_stats=print_stats, fail_on_exception=fail_on_exception)
+
+        if result.num_excs == 0:
+            cols_with_excs_str = ''
+        else:
+            cols_with_excs_str = \
+                f' across {len(result.cols_with_excs)} column{"" if len(result.cols_with_excs) == 1 else "s"}'
+            cols_with_excs_str += f' ({", ".join(result.cols_with_excs)})'
+        msg = (
+            f'Inserted {result.num_rows} row{"" if result.num_rows == 1 else "s"} '
+            f'with {result.num_excs} error{"" if result.num_excs == 1 else "s"}{cols_with_excs_str}.'
+        )
+        print(msg)
+        _logger.info(f'InsertableTable {self._name}: {msg}')
+        return result
+
+    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.column_names())
+        reqd_col_names = set(self.tbl_version_path.tbl_version.get_required_col_names())
+        computed_col_names = set(self.tbl_version_path.tbl_version.get_computed_col_names())
+        for row in rows:
+            assert isinstance(row, dict)
+            col_names = set(row.keys())
+            if len(reqd_col_names - col_names) > 0:
+                raise excs.Error(f'Missing required column(s) ({", ".join(reqd_col_names - col_names)}) in row {row}')
+
+            for col_name, val in row.items():
+                if col_name not in valid_col_names:
+                    raise excs.Error(f'Unknown column name {col_name} in row {row}')
+                if col_name in computed_col_names:
+                    raise excs.Error(f'Value for computed column {col_name} in row {row}')
+
+                # validate data
+                col = self.tbl_version_path.get_column(col_name)
+                try:
+                    # basic sanity checks here
+                    checked_val = col.col_type.create_literal(val)
+                    row[col_name] = checked_val
+                except TypeError as e:
+                    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) -> UpdateStatus:
+        """Delete rows in this table.
+
+        Args:
+            where: a Predicate to filter rows to delete.
+
+        Examples:
+            Delete all rows in a table:
+
+            >>> tbl.delete()
+
+            Delete all rows in a table where column `a` is greater than 5:
+
+            >>> tbl.delete(tbl.a > 5)
+        """
+        from pixeltable.exprs import Predicate
+        from pixeltable.plan import Planner
+        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_path, where)
+            # 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.delete(where)