pixeltable 0.4.1__py3-none-any.whl → 0.4.2__py3-none-any.whl

pixeltable/catalog/table_version.py

@@ -29,7 +29,14 @@ if TYPE_CHECKING:
 
 from ..func.globals import resolve_symbol
 from .column import Column
-from .globals import _POS_COLUMN_NAME, _ROWID_COLUMN_NAME, MediaValidation, UpdateStatus, is_valid_identifier
+from .globals import (
+    _POS_COLUMN_NAME,
+    _ROWID_COLUMN_NAME,
+    MediaValidation,
+    RowCountStats,
+    UpdateStatus,
+    is_valid_identifier,
+)
 
 if TYPE_CHECKING:
     from pixeltable import exec, store
@@ -183,6 +190,12 @@ class TableVersion:
         else:
             return f'{self.name}:{self.effective_version}'
 
+    @property
+    def handle(self) -> 'TableVersionHandle':
+        from .table_version_handle import TableVersionHandle
+
+        return TableVersionHandle(self.id, self.effective_version, self)
+
     @classmethod
     def create(
         cls,
@@ -195,7 +208,6 @@ class TableVersion:
         # base_path: Optional[pxt.catalog.TableVersionPath] = None,
         view_md: Optional[schema.ViewMd] = None,
     ) -> tuple[UUID, Optional[TableVersion]]:
-        session = Env.get().session
         user = Env.get().user
 
         # assign ids
@@ -212,8 +224,9 @@ class TableVersion:
         # Column.dependent_cols for existing cols is wrong at this point, but init() will set it correctly
         column_md = cls._create_column_md(cols)
         tbl_id = uuid.uuid4()
+        tbl_id_str = str(tbl_id)
         table_md = schema.TableMd(
-            tbl_id=str(tbl_id),
+            tbl_id=tbl_id_str,
             name=name,
             user=user,
             is_replica=False,
@@ -229,16 +242,10 @@ class TableVersion:
             view_md=view_md,
             additional_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_record = schema.Table(id=tbl_id, dir_id=dir_id, md=dataclasses.asdict(table_md))
 
         # create schema.TableVersion
         table_version_md = schema.TableVersionMd(
-            tbl_id=str(tbl_record.id), created_at=timestamp, version=0, schema_version=0, additional_md={}
-        )
-        tbl_version_record = schema.TableVersion(
-            tbl_id=tbl_record.id, version=0, md=dataclasses.asdict(table_version_md)
+            tbl_id=tbl_id_str, created_at=timestamp, version=0, schema_version=0, additional_md={}
         )
 
         # create schema.TableSchemaVersion
@@ -252,7 +259,7 @@ class TableVersion:
             schema_col_md[col.id] = md
 
         schema_version_md = schema.TableSchemaVersionMd(
-            tbl_id=str(tbl_record.id),
+            tbl_id=tbl_id_str,
             schema_version=0,
             preceding_schema_version=None,
             columns=schema_col_md,
@@ -261,9 +268,8 @@ class TableVersion:
             media_validation=media_validation.name.lower(),
             additional_md={},
         )
-        schema_version_record = schema.TableSchemaVersion(
-            tbl_id=tbl_record.id, schema_version=0, md=dataclasses.asdict(schema_version_md)
-        )
+
+        cat = pxt.catalog.Catalog.get()
 
         # if this is purely a snapshot (it doesn't require any additional storage for columns and it doesn't have a
         # predicate to apply at runtime), we don't create a physical table and simply use the base's table version path
@@ -274,22 +280,23 @@ class TableVersion:
             and view_md.sample_clause is None
             and len(cols) == 0
         ):
-            session.add(tbl_record)
-            session.add(tbl_version_record)
-            session.add(schema_version_record)
-            return tbl_record.id, None
+            cat.store_tbl_md(
+                tbl_id=tbl_id,
+                dir_id=dir_id,
+                tbl_md=table_md,
+                version_md=table_version_md,
+                schema_version_md=schema_version_md,
+            )
+            return tbl_id, None
 
         # assert (base_path is not None) == (view_md is not None)
         is_snapshot = view_md is not None and view_md.is_snapshot
         effective_version = 0 if is_snapshot else None
         base_path = pxt.catalog.TableVersionPath.from_md(view_md.base_versions) if view_md is not None else None
         base = base_path.tbl_version if base_path is not None else None
-        tbl_version = cls(
-            tbl_record.id, table_md, effective_version, schema_version_md, [], base_path=base_path, base=base
-        )
+        tbl_version = cls(tbl_id, table_md, effective_version, schema_version_md, [], base_path=base_path, base=base)
         # TODO: break this up, so that Catalog.create_table() registers tbl_version
-        cat = pxt.catalog.Catalog.get()
-        cat._tbl_versions[tbl_record.id, effective_version] = tbl_version
+        cat._tbl_versions[tbl_id, effective_version] = tbl_version
         tbl_version.init()
         tbl_version.store_tbl.create()
         is_mutable = not is_snapshot and not table_md.is_replica
@@ -306,12 +313,14 @@ class TableVersion:
                 status = tbl_version._add_default_index(col)
                 assert status is None or status.num_excs == 0
 
-        # we re-create the tbl_record here, now that we have new index metadata
-        tbl_record = schema.Table(id=tbl_id, dir_id=dir_id, md=dataclasses.asdict(tbl_version.tbl_md))
-        session.add(tbl_record)
-        session.add(tbl_version_record)
-        session.add(schema_version_record)
-        return tbl_record.id, tbl_version
+        cat.store_tbl_md(
+            tbl_id=tbl_id,
+            dir_id=dir_id,
+            tbl_md=tbl_version.tbl_md,
+            version_md=table_version_md,
+            schema_version_md=schema_version_md,
+        )
+        return tbl_id, tbl_version
 
     @classmethod
     def create_replica(cls, md: schema.FullTableMd) -> TableVersion:
@@ -488,7 +497,7 @@ class TableVersion:
         )
 
         Catalog.get().store_tbl_md(
-            self.id, self._tbl_md, version_md, self._schema_version_md if new_schema_version else None
+            self.id, None, self._tbl_md, version_md, self._schema_version_md if new_schema_version else None
         )
 
     def _store_idx_name(self, idx_id: int) -> str:
@@ -693,6 +702,7 @@ class TableVersion:
                     f'Cannot add non-nullable column {col.name!r} to table {self.name!r} with existing rows'
                 )
 
+        computed_values = 0
         num_excs = 0
         cols_with_excs: list[Column] = []
         for col in cols_to_add:
@@ -731,18 +741,19 @@ class TableVersion:
             # populate the column
             from pixeltable.plan import Planner
 
-            plan, value_expr_slot_idx = Planner.create_add_column_plan(self.path, col)
+            plan = Planner.create_add_column_plan(self.path, col)
             plan.ctx.num_rows = row_count
             try:
                 plan.open()
                 try:
-                    excs_per_col = self.store_tbl.load_column(col, plan, value_expr_slot_idx, on_error)
+                    excs_per_col = self.store_tbl.load_column(col, plan, on_error == 'abort')
                 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 excs_per_col > 0:
                     cols_with_excs.append(col)
                     num_excs += excs_per_col
+                computed_values += plan.ctx.num_computed_exprs * row_count
             finally:
                 # Ensure cleanup occurs if an exception or keyboard interruption happens during `load_column()`.
                 def cleanup_on_error() -> None:
@@ -765,12 +776,14 @@ class TableVersion:
 
         if print_stats:
             plan.ctx.profile.print(num_rows=row_count)
+
         # TODO: what to do about system columns with exceptions?
+        row_counts = RowCountStats(
+            upd_rows=row_count, num_excs=num_excs, computed_values=computed_values
+        )  # add_columns
         return UpdateStatus(
-            num_rows=row_count,
-            num_computed_values=row_count,
-            num_excs=num_excs,
             cols_with_excs=[f'{col.tbl.name}.{col.name}' for col in cols_with_excs if col.name is not None],
+            row_count_stats=row_counts,
         )
 
     def drop_column(self, col: Column) -> None:
@@ -910,14 +923,10 @@ class TableVersion:
         """Insert rows produced by exec_plan and propagate to views"""
         # we're creating a new version
         self.version += 1
-        result = UpdateStatus()
-        num_rows, num_excs, cols_with_excs = self.store_tbl.insert_rows(
+        cols_with_excs, result = self.store_tbl.insert_rows(
             exec_plan, v_min=self.version, rowids=rowids, abort_on_exc=abort_on_exc
         )
-        result.num_rows = num_rows
-        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]
+        result += UpdateStatus(cols_with_excs=[f'{self.name}.{self.cols_by_id[cid].name}' for cid in cols_with_excs])
         self._write_md(new_version=True, new_version_ts=timestamp, new_schema_version=False)
 
         # update views
@@ -926,14 +935,10 @@ class TableVersion:
 
             plan, _ = Planner.create_view_load_plan(view.get().path, propagates_insert=True)
             status = view.get()._insert(plan, timestamp, print_stats=print_stats)
-            result.num_rows += status.num_rows
-            result.num_excs += status.num_excs
-            result.num_computed_values += status.num_computed_values
-            result.cols_with_excs += status.cols_with_excs
+            result += status.to_cascade()
 
-        result.cols_with_excs = list(dict.fromkeys(result.cols_with_excs).keys())  # remove duplicates
         if print_stats:
-            plan.ctx.profile.print(num_rows=num_rows)
+            plan.ctx.profile.print(num_rows=result.num_rows)  # This is the net rows after all propagations
         _logger.info(f'TableVersion {self.name}: new version {self.version}')
         return result
 
@@ -973,7 +978,7 @@ class TableVersion:
             cascade=cascade,
             show_progress=True,
         )
-        result.updated_cols = updated_cols
+        result += UpdateStatus(updated_cols=updated_cols)
         return result
 
     def batch_update(
@@ -1000,7 +1005,7 @@ class TableVersion:
         result = self.propagate_update(
             plan, delete_where_clause, recomputed_cols, base_versions=[], timestamp=time.time(), cascade=cascade
         )
-        result.updated_cols = [c.qualified_name for c in updated_cols]
+        result += UpdateStatus(updated_cols=[c.qualified_name for c in updated_cols])
 
         unmatched_rows = row_update_node.unmatched_rows()
         if len(unmatched_rows) > 0:
@@ -1008,7 +1013,7 @@ class TableVersion:
                 raise excs.Error(f'batch_update(): {len(unmatched_rows)} row(s) not found')
             if insert_if_not_exists:
                 insert_status = self.insert(unmatched_rows, None, print_stats=False, fail_on_exception=False)
-                result += insert_status
+                result += insert_status.to_cascade()
         return result
 
     def _validate_update_spec(
@@ -1061,6 +1066,38 @@ class TableVersion:
 
         return update_targets
 
+    def recompute_columns(self, col_names: list[str], errors_only: bool = False, cascade: bool = True) -> UpdateStatus:
+        assert not self.is_snapshot
+        assert all(name in self.cols_by_name for name in col_names)
+        assert len(col_names) > 0
+        assert len(col_names) == 1 or not errors_only
+
+        from pixeltable.plan import Planner
+
+        target_columns = [self.cols_by_name[name] for name in col_names]
+        where_clause: Optional[exprs.Expr] = None
+        if errors_only:
+            where_clause = (
+                exprs.ColumnPropertyRef(exprs.ColumnRef(target_columns[0]), exprs.ColumnPropertyRef.Property.ERRORTYPE)
+                != None
+            )
+        plan, updated_cols, recomputed_cols = Planner.create_update_plan(
+            self.path, update_targets={}, recompute_targets=target_columns, where_clause=where_clause, cascade=cascade
+        )
+        from pixeltable.exprs import SqlElementCache
+
+        result = self.propagate_update(
+            plan,
+            where_clause.sql_expr(SqlElementCache()) if where_clause is not None else None,
+            recomputed_cols,
+            base_versions=[],
+            timestamp=time.time(),
+            cascade=cascade,
+            show_progress=True,
+        )
+        result += UpdateStatus(updated_cols=updated_cols)
+        return result
+
     def propagate_update(
         self,
         plan: Optional[exec.ExecNode],
@@ -1071,18 +1108,20 @@ class TableVersion:
         cascade: bool,
         show_progress: bool = True,
     ) -> UpdateStatus:
-        result = UpdateStatus()
         if plan is not None:
             # we're creating a new version
             self.version += 1
-            result.num_rows, result.num_excs, cols_with_excs = self.store_tbl.insert_rows(
-                plan, v_min=self.version, show_progress=show_progress
+            cols_with_excs, status = self.store_tbl.insert_rows(plan, v_min=self.version, show_progress=show_progress)
+            result = status.insert_to_update()
+            result += UpdateStatus(
+                cols_with_excs=[f'{self.name}.{self.cols_by_id[cid].name}' for cid in cols_with_excs]
             )
-            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
             )
             self._write_md(new_version=True, new_version_ts=timestamp, new_schema_version=False)
+        else:
+            result = UpdateStatus()
 
         if cascade:
             base_versions = [None if plan is None else self.version, *base_versions]  # don't update in place
@@ -1097,17 +1136,17 @@ class TableVersion:
                 status = view.get().propagate_update(
                     plan, None, recomputed_view_cols, base_versions=base_versions, timestamp=timestamp, cascade=True
                 )
-                result.num_rows += status.num_rows
-                result.num_excs += status.num_excs
-                result.cols_with_excs += status.cols_with_excs
+                result += status.to_cascade()
 
-        result.cols_with_excs = list(dict.fromkeys(result.cols_with_excs).keys())  # remove duplicates
         return result
 
     def delete(self, where: Optional[exprs.Expr] = None) -> UpdateStatus:
         """Delete rows in this table.
         Args:
             where: a predicate to filter rows to delete.
+
+        Returns:
+            UpdateStatus: an object containing the number of deleted rows and other statistics.
         """
         assert self.is_insertable
         from pixeltable.exprs import Expr
@@ -1123,14 +1162,12 @@ class TableVersion:
                 raise excs.Error(f'Filter {analysis_info.filter} not expressible in SQL')
             sql_where_clause = analysis_info.sql_where_clause
 
-        num_rows = self.propagate_delete(sql_where_clause, base_versions=[], timestamp=time.time())
-
-        status = UpdateStatus(num_rows=num_rows)
+        status = self.propagate_delete(sql_where_clause, base_versions=[], timestamp=time.time())
         return status
 
     def propagate_delete(
         self, where: Optional[exprs.Expr], base_versions: list[Optional[int]], timestamp: float
-    ) -> int:
+    ) -> UpdateStatus:
         """Delete rows in this table and propagate to views.
         Args:
             where: a predicate to filter rows to delete.
@@ -1146,18 +1183,21 @@ class TableVersion:
         # sql.sql.visitors.traverse(sql_where_clause, {}, {'column': collect_cols})
         # x = [f'{str(c)}:{hash(c)}:{id(c.table)}' for c in sql_cols]
         # print(f'where_clause cols: {x}')
-        num_rows = self.store_tbl.delete_rows(
+        del_rows = self.store_tbl.delete_rows(
             self.version + 1, base_versions=base_versions, match_on_vmin=False, where_clause=sql_where_clause
         )
-        if num_rows > 0:
+        row_counts = RowCountStats(del_rows=del_rows)  # delete
+        result = UpdateStatus(row_count_stats=row_counts)
+        if del_rows > 0:
             # we're creating a new version
             self.version += 1
             self._write_md(new_version=True, new_version_ts=timestamp, new_schema_version=False)
         for view in self.mutable_views:
-            num_rows += view.get().propagate_delete(
+            status = view.get().propagate_delete(
                 where=None, base_versions=[self.version, *base_versions], timestamp=timestamp
             )
-        return num_rows
+            result += status.to_cascade()
+        return result
 
     def revert(self) -> None:
         """Reverts the table to the previous version."""

pixeltable/catalog/table_version_handle.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
 import logging
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Optional
 from uuid import UUID
 
+from pixeltable import exceptions as excs
+
 from .table_version import TableVersion
 
 if TYPE_CHECKING:
-    pass
+    from pixeltable.catalog import Column
 
 _logger = logging.getLogger('pixeltable')
 
@@ -67,3 +70,25 @@ class TableVersionHandle:
     @classmethod
     def from_dict(cls, d: dict) -> TableVersionHandle:
         return cls(UUID(d['id']), d['effective_version'])
+
+
+@dataclass(frozen=True)
+class ColumnHandle:
+    tbl_version: TableVersionHandle
+    col_id: int
+
+    def get(self) -> 'Column':
+        if self.col_id not in self.tbl_version.get().cols_by_id:
+            schema_version_drop = self.tbl_version.get()._tbl_md.column_md[self.col_id].schema_version_drop
+            raise excs.Error(
+                f'Column has been dropped (no record for column ID {self.col_id} in table '
+                f'{self.tbl_version.get().versioned_name!r}; it was dropped in table version {schema_version_drop})'
+            )
+        return self.tbl_version.get().cols_by_id[self.col_id]
+
+    def as_dict(self) -> dict:
+        return {'tbl_version': self.tbl_version.as_dict(), 'col_id': self.col_id}
+
+    @classmethod
+    def from_dict(cls, d: dict) -> ColumnHandle:
+        return cls(tbl_version=TableVersionHandle.from_dict(d['tbl_version']), col_id=d['col_id'])

pixeltable/catalog/view.py

@@ -229,7 +229,7 @@ class View(Table):
 
             try:
                 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)
+                _, status = tbl_version.store_tbl.insert_rows(plan, v_min=tbl_version.version)
             except:
                 # we need to remove the orphaned TableVersion instance
                 del catalog.Catalog.get()._tbl_versions[tbl_version.id, tbl_version.effective_version]
@@ -238,7 +238,9 @@ class View(Table):
                     # also remove tbl_version from the base
                     base_tbl_version.mutable_views.remove(TableVersionHandle.create(tbl_version))
                 raise
-            Env.get().console_logger.info(f'Created view `{name}` with {num_rows} rows, {num_excs} exceptions.')
+            Env.get().console_logger.info(
+                f'Created view `{name}` with {status.num_rows} rows, {status.num_excs} exceptions.'
+            )
 
         session.commit()
         return view

pixeltable/exprs/column_property_ref.py

@@ -55,18 +55,9 @@ class ColumnPropertyRef(Expr):
         return self.prop in (self.Property.ERRORTYPE, self.Property.ERRORMSG)
 
     def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
-        if not self._col_ref.col.is_stored:
+        if not self._col_ref.col_handle.get().is_stored:
             return None
-
-        # we need to reestablish that we have the correct Column instance, there could have been a metadata
-        # reload since init()
-        # TODO: add an explicit prepare phase (ie, Expr.prepare()) that gives every subclass instance a chance to
-        # perform runtime checks and update state
-        tv = self._col_ref.tbl_version.get()
-        assert tv.is_validated
-        # we can assume at this point during query execution that the column exists
-        assert self._col_ref.col_id in tv.cols_by_id
-        col = tv.cols_by_id[self._col_ref.col_id]
+        col = self._col_ref.col_handle.get()
 
         # the errortype/-msg properties of a read-validated media column need to be extracted from the DataRow
         if (

pixeltable/exprs/column_ref.py

@@ -10,6 +10,7 @@ import pixeltable as pxt
 from pixeltable import catalog, exceptions as excs, iterators as iters
 
 from ..utils.description_helper import DescriptionHelper
+from ..utils.filecache import FileCache
 from .data_row import DataRow
 from .expr import Expr
 from .row_builder import RowBuilder
@@ -41,7 +42,8 @@ class ColumnRef(Expr):
     insert them into the EvalCtxs as needed
     """
 
-    col: catalog.Column
+    col: catalog.Column  # TODO: merge with col_handle
+    col_handle: catalog.ColumnHandle
     reference_tbl: Optional[catalog.TableVersionPath]
     is_unstored_iter_col: bool
     iter_arg_ctx: Optional[RowBuilder.EvalCtx]
@@ -52,10 +54,6 @@ class ColumnRef(Expr):
     id: int
     perform_validation: bool  # if True, performs media validation
 
-    # needed by sql_expr() to re-resolve Column instance after a metadata reload
-    tbl_version: catalog.TableVersionHandle
-    col_id: int
-
     def __init__(
         self,
         col: catalog.Column,
@@ -66,8 +64,7 @@ class ColumnRef(Expr):
         assert col.tbl is not None
         self.col = col
         self.reference_tbl = reference_tbl
-        self.tbl_version = catalog.TableVersionHandle(col.tbl.id, col.tbl.effective_version)
-        self.col_id = col.id
+        self.col_handle = catalog.ColumnHandle(col.tbl.handle, col.id)
 
         self.is_unstored_iter_col = col.tbl.is_component_view and col.tbl.is_iterator_column(col) and not col.is_stored
         self.iter_arg_ctx = None
@@ -170,6 +167,20 @@ class ColumnRef(Expr):
             idx_info = embedding_idx_info
         return idx_info
 
+    def recompute(self, *, cascade: bool = True, errors_only: bool = False) -> catalog.UpdateStatus:
+        cat = catalog.Catalog.get()
+        # lock_mutable_tree=True: we need to be able to see whether any transitive view has column dependents
+        with cat.begin_xact(tbl=self.reference_tbl, for_write=True, lock_mutable_tree=True):
+            tbl_version = self.col_handle.tbl_version.get()
+            if tbl_version.id != self.reference_tbl.tbl_id:
+                raise excs.Error('Cannot recompute column of a base.')
+            if tbl_version.is_snapshot:
+                raise excs.Error('Cannot recompute column of a snapshot.')
+            col_name = self.col_handle.get().name
+            status = tbl_version.recompute_columns([col_name], errors_only=errors_only, cascade=cascade)
+            FileCache.get().emit_eviction_warnings()
+            return status
+
     def similarity(self, item: Any, *, idx: Optional[str] = None) -> Expr:
         from .similarity_expr import SimilarityExpr
 
@@ -241,16 +252,7 @@ class ColumnRef(Expr):
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         if self.perform_validation:
             return None
-        # we need to reestablish that we have the correct Column instance, there could have been a metadata
-        # reload since init()
-        # TODO: add an explicit prepare phase (ie, Expr.prepare()) that gives every subclass instance a chance to
-        # perform runtime checks and update state
-        tv = self.tbl_version.get()
-        assert tv.is_validated
-        # we can assume at this point during query execution that the column exists
-        assert self.col_id in tv.cols_by_id
-        self.col = tv.cols_by_id[self.col_id]
-        assert self.col.tbl is tv
+        self.col = self.col_handle.get()
         return self.col.sa_col
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:

pixeltable/exprs/data_row.py

@@ -42,6 +42,10 @@ class DataRow:
     has_val: np.ndarray  # of bool
     excs: np.ndarray  # of object
 
+    # If `may_have_exc` is False, then we guarantee that no slot has an exception set. This is used to optimize
+    # exception handling under normal operation.
+    _may_have_exc: bool
+
     # expr evaluation state; indexed by slot idx
     missing_slots: np.ndarray  # of bool; number of missing dependencies
     missing_dependents: np.ndarray  # of int16; number of missing dependents
@@ -90,6 +94,7 @@ class DataRow:
         self.vals = np.full(num_slots, None, dtype=object)
         self.has_val = np.zeros(num_slots, dtype=bool)
         self.excs = np.full(num_slots, None, dtype=object)
+        self._may_have_exc = False
         self.missing_slots = np.zeros(num_slots, dtype=bool)
         self.missing_dependents = np.zeros(num_slots, dtype=np.int16)
         self.is_scheduled = np.zeros(num_slots, dtype=bool)
@@ -136,6 +141,9 @@ class DataRow:
         """
         Returns True if an exception has been set for the given slot index, or for any slot index if slot_idx is None
         """
+        if not self._may_have_exc:
+            return False
+
         if slot_idx is not None:
             return self.excs[slot_idx] is not None
         return (self.excs != None).any()
@@ -154,6 +162,7 @@ class DataRow:
     def set_exc(self, slot_idx: int, exc: Exception) -> None:
         assert self.excs[slot_idx] is None
         self.excs[slot_idx] = exc
+        self._may_have_exc = True
 
         # an exception means the value is None
         self.has_val[slot_idx] = True