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

pixeltable/catalog/table_version.py

@@ -177,10 +177,6 @@ class TableVersion:
         # Init external stores (this needs to happen after the schema is created)
         self._init_external_stores(tbl_md)
 
-        # Force column metadata to load, in order to surface any invalid metadata now (as warnings)
-        for col in self.cols_by_id.values():
-            _ = col.value_expr
-
     def __hash__(self) -> int:
         return hash(self.id)
 
@@ -229,7 +225,9 @@ class TableVersion:
         # create schema.Table
         # 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()
         table_md = schema.TableMd(
+            tbl_id=str(tbl_id),
             name=name,
             user=None,
             current_version=0,
@@ -245,11 +243,12 @@ class TableVersion:
         )
         # 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()
         tbl_record = schema.Table(id=tbl_id, dir_id=dir_id, md=dataclasses.asdict(table_md))
 
         # create schema.TableVersion
-        table_version_md = schema.TableVersionMd(created_at=timestamp, version=0, schema_version=0, additional_md={})
+        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)
         )
@@ -265,6 +264,7 @@ class TableVersion:
             schema_col_md[col.id] = md
 
         schema_version_md = schema.TableSchemaVersionMd(
+            tbl_id=str(tbl_record.id),
             schema_version=0,
             preceding_schema_version=None,
             columns=schema_col_md,
@@ -458,6 +458,11 @@ class TableVersion:
                 )
             )
 
+    def ensure_md_loaded(self) -> None:
+        """Ensure that table metadata is loaded."""
+        for col in self.cols_by_id.values():
+            _ = col.value_expr
+
     def _store_idx_name(self, idx_id: int) -> str:
         """Return name of index in the store, which needs to be globally unique"""
         return f'idx_{self.id.hex}_{idx_id}'
@@ -1239,6 +1244,11 @@ class TableVersion:
         """Return all non-system columns"""
         return [c for c in self.cols if c.is_pk]
 
+    @property
+    def primary_key(self) -> list[str]:
+        """Return the names of the primary key columns"""
+        return [c.name for c in self.cols if c.is_pk]
+
     def get_required_col_names(self) -> list[str]:
         """Return the names of all columns for which values must be specified in insert()"""
         assert not self.is_view
@@ -1305,6 +1315,7 @@ class TableVersion:
 
     def _create_tbl_md(self) -> schema.TableMd:
         return schema.TableMd(
+            tbl_id=str(self.id),
             name=self.name,
             user=None,
             current_version=self.version,
@@ -1321,7 +1332,11 @@ class TableVersion:
 
     def _create_version_md(self, timestamp: float) -> schema.TableVersionMd:
         return schema.TableVersionMd(
-            created_at=timestamp, version=self.version, schema_version=self.schema_version, additional_md={}
+            tbl_id=str(self.id),
+            created_at=timestamp,
+            version=self.version,
+            schema_version=self.schema_version,
+            additional_md={},
         )
 
     def _create_schema_version_md(self, preceding_schema_version: int) -> schema.TableSchemaVersionMd:
@@ -1334,6 +1349,7 @@ class TableVersion:
             )
         # preceding_schema_version to be set by the caller
         return schema.TableSchemaVersionMd(
+            tbl_id=str(self.id),
             schema_version=self.schema_version,
             preceding_schema_version=preceding_schema_version,
             columns=column_md,

pixeltable/catalog/view.py

@@ -237,15 +237,11 @@ class View(Table):
         )
 
     def _drop(self) -> None:
-        cat = catalog.Catalog.get()
         if self._snapshot_only:
             # there is not TableVersion to drop
             self._check_is_dropped()
             self.is_dropped = True
             TableVersion.delete_md(self._id)
-            # update catalog
-            cat = catalog.Catalog.get()
-            cat.remove_tbl(self._id)
         else:
             super()._drop()
 
@@ -255,13 +251,20 @@ class View(Table):
         md['is_snapshot'] = self._tbl_version_path.is_snapshot()
         return md
 
+    if TYPE_CHECKING:
+        import datasets  # type: ignore[import-untyped]
+
+        from pixeltable.globals import RowData, TableDataSource
+
     def insert(
         self,
-        rows: Optional[Iterable[dict[str, Any]]] = None,
+        source: Optional[TableDataSource] = None,
         /,
         *,
-        print_stats: bool = False,
+        source_format: Optional[Literal['csv', 'excel', 'parquet', 'json']] = None,
+        schema_overrides: Optional[dict[str, ts.ColumnType]] = None,
         on_error: Literal['abort', 'ignore'] = 'abort',
+        print_stats: bool = False,
         **kwargs: Any,
     ) -> UpdateStatus:
         raise excs.Error(f'{self._display_name()} {self._name!r}: cannot insert into view')

pixeltable/env.py

@@ -170,19 +170,25 @@ class Env:
         assert self._current_session is not None
         return self._current_session
 
+    def in_xact(self) -> bool:
+        return self._current_conn is not None
+
     @contextmanager
     def begin_xact(self) -> Iterator[sql.Connection]:
         """Return a context manager that yields a connection to the database. Idempotent."""
         if self._current_conn is None:
             assert self._current_session is None
-            with self.engine.begin() as conn, sql.orm.Session(conn) as session:
-                self._current_conn = conn
-                self._current_session = session
-                try:
+            try:
+                with self.engine.begin() as conn, sql.orm.Session(conn) as session:
+                    # TODO: remove print() once we're done with debugging the concurrent update behavior
+                    # print(f'{datetime.datetime.now()}: start xact')
+                    self._current_conn = conn
+                    self._current_session = session
                     yield conn
-                finally:
-                    self._current_session = None
-                    self._current_conn = None
+            finally:
+                self._current_session = None
+                self._current_conn = None
+                # print(f'{datetime.datetime.now()}: end xact')
         else:
             assert self._current_session is not None
             yield self._current_conn
@@ -391,7 +397,7 @@ class Env:
     def _create_engine(self, time_zone_name: Optional[str], echo: bool = False) -> None:
         connect_args = {} if time_zone_name is None else {'options': f'-c timezone={time_zone_name}'}
         self._sa_engine = sql.create_engine(
-            self.db_url, echo=echo, future=True, isolation_level='REPEATABLE READ', connect_args=connect_args
+            self.db_url, echo=echo, isolation_level='REPEATABLE READ', connect_args=connect_args
         )
         self._logger.info(f'Created SQLAlchemy engine at: {self.db_url}')
         with self.engine.begin() as conn:
@@ -561,7 +567,7 @@ class Env:
         self.__register_package('transformers')
         self.__register_package('whisper', library_name='openai-whisper')
         self.__register_package('whisperx')
-        self.__register_package('yolox', library_name='git+https://github.com/Megvii-BaseDetection/YOLOX@ac58e0a')
+        self.__register_package('yolox', library_name='pixeltable-yolox')
 
     def __register_package(self, package_name: str, library_name: Optional[str] = None) -> None:
         is_installed: bool

pixeltable/exec/exec_node.py

@@ -75,7 +75,7 @@ class ExecNode(abc.ABC):
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
 
-        if 'pytest' in sys.modules:
+        if _logger.isEnabledFor(logging.DEBUG):
             loop.set_debug(True)
 
         aiter = self.__aiter__()

pixeltable/exprs/__init__.py

@@ -16,7 +16,7 @@ from .in_predicate import InPredicate
 from .inline_expr import InlineArray, InlineDict, InlineList
 from .is_null import IsNull
 from .json_mapper import JsonMapper
-from .json_path import RELATIVE_PATH_ROOT, JsonPath
+from .json_path import JsonPath
 from .literal import Literal
 from .method_ref import MethodRef
 from .object_ref import ObjectRef
@@ -24,5 +24,6 @@ from .row_builder import ColumnSlotIdx, ExecProfile, RowBuilder
 from .rowid_ref import RowidRef
 from .similarity_expr import SimilarityExpr
 from .sql_element_cache import SqlElementCache
+from .string_op import StringOp
 from .type_cast import TypeCast
 from .variable import Variable

pixeltable/exprs/arithmetic_expr.py

@@ -19,6 +19,8 @@ class ArithmeticExpr(Expr):
     Allows arithmetic exprs on json paths
     """
 
+    operator: ArithmeticOperator
+
     def __init__(self, operator: ArithmeticOperator, op1: Expr, op2: Expr):
         if op1.col_type.is_json_type() or op2.col_type.is_json_type() or operator == ArithmeticOperator.DIV:
             # we assume it's a float

pixeltable/exprs/column_ref.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copy
 from typing import Any, Optional, Sequence
 from uuid import UUID
 
@@ -125,11 +126,46 @@ class ColumnRef(Expr):
 
         return super().__getattr__(name)
 
+    @classmethod
+    def find_embedding_index(
+        cls, col: catalog.Column, idx_name: Optional[str], method_name: str
+    ) -> dict[str, catalog.TableVersion.IndexInfo]:
+        """Return IndexInfo for a column, with an optional given name"""
+        # determine index to use
+        idx_info_dict = col.get_idx_info()
+        from pixeltable import index
+
+        embedding_idx_info = {
+            info: value for info, value in idx_info_dict.items() if isinstance(value.idx, index.EmbeddingIndex)
+        }
+        if len(embedding_idx_info) == 0:
+            raise excs.Error(f'No indices found for {method_name!r} on column {col.name!r}')
+        if idx_name is not None and idx_name not in embedding_idx_info:
+            raise excs.Error(f'Index {idx_name!r} not found for {method_name!r} on column {col.name!r}')
+        if len(embedding_idx_info) > 1:
+            if idx_name is None:
+                raise excs.Error(
+                    f'Column {col.name!r} has multiple indices; use the index name to disambiguate: '
+                    f'`{method_name}(..., idx=<index_name>)`'
+                )
+            idx_info = {idx_name: embedding_idx_info[idx_name]}
+        else:
+            idx_info = embedding_idx_info
+        return idx_info
+
     def similarity(self, item: Any, *, idx: Optional[str] = None) -> Expr:
         from .similarity_expr import SimilarityExpr
 
         return SimilarityExpr(self, item, idx_name=idx)
 
+    def embedding(self, *, idx: Optional[str] = None) -> ColumnRef:
+        idx_info = ColumnRef.find_embedding_index(self.col, idx, 'embedding')
+        assert len(idx_info) == 1
+        col = copy.copy(next(iter(idx_info.values())).val_col)
+        col.name = f'{self.col.name}_embedding_{idx if idx is not None else ""}'
+        col.create_sa_cols()
+        return ColumnRef(col)
+
     def default_column_name(self) -> Optional[str]:
         return str(self)
 
@@ -137,7 +173,7 @@ class ColumnRef(Expr):
         return self.col == other.col and self.perform_validation == other.perform_validation
 
     def _df(self) -> 'pxt.dataframe.DataFrame':
-        tbl = catalog.Catalog.get().get_tbl(self.col.tbl.id)
+        tbl = catalog.Catalog.get().get_table_by_id(self.col.tbl.id)
         return tbl.select(self)
 
     def show(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
@@ -165,7 +201,7 @@ class ColumnRef(Expr):
         return self._descriptors().to_html()
 
     def _descriptors(self) -> DescriptionHelper:
-        tbl = catalog.Catalog.get().get_tbl(self.col.tbl.id)
+        tbl = catalog.Catalog.get().get_table_by_id(self.col.tbl.id)
         helper = DescriptionHelper()
         helper.append(f'Column\n{self.col.name!r}\n(of table {tbl._path()!r})')
         helper.append(tbl._col_descriptor([self.col.name]))

pixeltable/exprs/expr.py

@@ -17,7 +17,7 @@ from typing_extensions import Self, _AnnotatedAlias
 from pixeltable import catalog, exceptions as excs, func, type_system as ts
 
 from .data_row import DataRow
-from .globals import ArithmeticOperator, ComparisonOperator, LiteralPythonTypes, LogicalOperator
+from .globals import ArithmeticOperator, ComparisonOperator, LiteralPythonTypes, LogicalOperator, StringOperator
 
 if TYPE_CHECKING:
     from pixeltable import exprs
@@ -90,14 +90,29 @@ class Expr(abc.ABC):
                 result = c_scope
         return result
 
-    def bind_rel_paths(self, mapper: Optional['exprs.JsonMapper'] = None) -> None:
+    def bind_rel_paths(self) -> None:
         """
         Binds relative JsonPaths to mapper.
         This needs to be done in a separate phase after __init__(), because RelativeJsonPath()(-1) cannot be resolved
         by the immediately containing JsonMapper during initialization.
         """
+        self._bind_rel_paths()
+        assert not self._has_relative_path, self._expr_tree()
+
+    def _bind_rel_paths(self, mapper: Optional['exprs.JsonMapper'] = None) -> None:
+        for c in self.components:
+            c._bind_rel_paths(mapper)
+
+    def _expr_tree(self) -> str:
+        """Returns a string representation of this expression as a multi-line tree. Useful for debugging."""
+        buf: list[str] = []
+        self._expr_tree_r(0, buf)
+        return '\n'.join(buf)
+
+    def _expr_tree_r(self, indent: int, buf: list[str]) -> None:
+        buf.append(f'{" " * indent}{type(self).__name__}: {self}'.replace('\n', '\\n'))
         for c in self.components:
-            c.bind_rel_paths(mapper)
+            c._expr_tree_r(indent + 2, buf)
 
     def default_column_name(self) -> Optional[str]:
         """
@@ -355,6 +370,10 @@ class Expr(abc.ABC):
         except StopIteration:
             return False
 
+    @property
+    def _has_relative_path(self) -> bool:
+        return any(c._has_relative_path for c in self.components)
+
     def tbl_ids(self) -> set[UUID]:
         """Returns table ids referenced by this expr."""
         from .column_ref import ColumnRef
@@ -514,7 +533,7 @@ class Expr(abc.ABC):
 
     @classmethod
     def _from_dict(cls, d: dict, components: list[Expr]) -> Self:
-        raise AssertionError('not implemented')
+        raise AssertionError(f'not implemented: {cls.__name__}')
 
     def isin(self, value_set: Any) -> 'exprs.InPredicate':
         from .in_predicate import InPredicate
@@ -586,10 +605,6 @@ class Expr(abc.ABC):
                 # Return the `MethodRef` object itself; it requires arguments to become a `FunctionCall`
                 return method_ref
 
-    def __rshift__(self, other: object) -> 'exprs.Expr':
-        # Implemented here for type-checking purposes
-        raise excs.Error('The `>>` operator can only be applied to Json expressions')
-
     def __bool__(self) -> bool:
         raise TypeError(
             f'Pixeltable expressions cannot be used in conjunction with Python boolean operators (and/or/not)\n{self!r}'
@@ -639,13 +654,17 @@ class Expr(abc.ABC):
     def __neg__(self) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.MUL, -1)
 
-    def __add__(self, other: object) -> 'exprs.ArithmeticExpr':
+    def __add__(self, other: object) -> Union[exprs.ArithmeticExpr, exprs.StringOp]:
+        if isinstance(self, str) or (isinstance(self, Expr) and self.col_type.is_string_type()):
+            return self._make_string_expr(StringOperator.CONCAT, other)
         return self._make_arithmetic_expr(ArithmeticOperator.ADD, other)
 
     def __sub__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.SUB, other)
 
-    def __mul__(self, other: object) -> 'exprs.ArithmeticExpr':
+    def __mul__(self, other: object) -> Union['exprs.ArithmeticExpr', 'exprs.StringOp']:
+        if isinstance(self, str) or (isinstance(self, Expr) and self.col_type.is_string_type()):
+            return self._make_string_expr(StringOperator.REPEAT, other)
         return self._make_arithmetic_expr(ArithmeticOperator.MUL, other)
 
     def __truediv__(self, other: object) -> 'exprs.ArithmeticExpr':
@@ -657,13 +676,17 @@ class Expr(abc.ABC):
     def __floordiv__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._make_arithmetic_expr(ArithmeticOperator.FLOORDIV, other)
 
-    def __radd__(self, other: object) -> 'exprs.ArithmeticExpr':
+    def __radd__(self, other: object) -> Union['exprs.ArithmeticExpr', 'exprs.StringOp']:
+        if isinstance(other, str) or (isinstance(other, Expr) and other.col_type.is_string_type()):
+            return self._rmake_string_expr(StringOperator.CONCAT, other)
         return self._rmake_arithmetic_expr(ArithmeticOperator.ADD, other)
 
     def __rsub__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._rmake_arithmetic_expr(ArithmeticOperator.SUB, other)
 
-    def __rmul__(self, other: object) -> 'exprs.ArithmeticExpr':
+    def __rmul__(self, other: object) -> Union['exprs.ArithmeticExpr', 'exprs.StringOp']:
+        if isinstance(other, str) or (isinstance(other, Expr) and other.col_type.is_string_type()):
+            return self._rmake_string_expr(StringOperator.REPEAT, other)
         return self._rmake_arithmetic_expr(ArithmeticOperator.MUL, other)
 
     def __rtruediv__(self, other: object) -> 'exprs.ArithmeticExpr':
@@ -675,6 +698,32 @@ class Expr(abc.ABC):
     def __rfloordiv__(self, other: object) -> 'exprs.ArithmeticExpr':
         return self._rmake_arithmetic_expr(ArithmeticOperator.FLOORDIV, other)
 
+    def _make_string_expr(self, op: StringOperator, other: object) -> 'exprs.StringOp':
+        """
+        Make left-handed version of string expression.
+        """
+        from .literal import Literal
+        from .string_op import StringOp
+
+        if isinstance(other, Expr):
+            return StringOp(op, self, other)
+        if isinstance(other, typing.get_args(LiteralPythonTypes)):
+            return StringOp(op, self, Literal(other))
+        raise TypeError(f'Other must be Expr or literal: {type(other)}')
+
+    def _rmake_string_expr(self, op: StringOperator, other: object) -> 'exprs.StringOp':
+        """
+        Right-handed version of _make_string_expr. other must be a literal; if it were an Expr,
+        the operation would have already been evaluated in its left-handed form.
+        """
+        from .literal import Literal
+        from .string_op import StringOp
+
+        assert not isinstance(other, Expr)  # Else the left-handed form would have evaluated first
+        if isinstance(other, typing.get_args(LiteralPythonTypes)):
+            return StringOp(op, Literal(other), self)
+        raise TypeError(f'Other must be Expr or literal: {type(other)}')
+
     def _make_arithmetic_expr(self, op: ArithmeticOperator, other: object) -> 'exprs.ArithmeticExpr':
         """
         other: Union[Expr, LiteralPythonTypes]

pixeltable/exprs/function_call.py

@@ -360,10 +360,7 @@ class FunctionCall(Expr):
             return
         args, kwargs = args_kwargs
 
-        if isinstance(self.fn, func.CallableFunction) and not self.fn.is_batched:
-            # optimization: avoid additional level of indirection we'd get from calling Function.exec()
-            data_row[self.slot_idx] = self.fn.py_fn(*args, **kwargs)
-        elif self.is_window_fn_call:
+        if self.is_window_fn_call:
             assert isinstance(self.fn, func.AggregateFunction)
             agg_cls = self.fn.agg_class
             if self.has_group_by():

pixeltable/exprs/globals.py

@@ -87,3 +87,15 @@ class ArithmeticOperator(enum.Enum):
         if self == self.FLOORDIV:
             return '//'
         raise AssertionError()
+
+
+class StringOperator(enum.Enum):
+    CONCAT = 0
+    REPEAT = 1
+
+    def __str__(self) -> str:
+        if self == self.CONCAT:
+            return '+'
+        if self == self.REPEAT:
+            return '*'
+        raise AssertionError()

pixeltable/exprs/json_mapper.py

@@ -48,9 +48,9 @@ class JsonMapper(Expr):
         scope_anchor = ObjectRef(self.target_expr_scope, self)
         self.components.append(scope_anchor)
 
-    def bind_rel_paths(self, mapper: Optional[JsonMapper] = None) -> None:
-        self._src_expr.bind_rel_paths(mapper)
-        self._target_expr.bind_rel_paths(self)
+    def _bind_rel_paths(self, mapper: Optional[JsonMapper] = None) -> None:
+        self._src_expr._bind_rel_paths(mapper)
+        self._target_expr._bind_rel_paths(self)
         self.parent_mapper = mapper
         parent_scope = _GLOBAL_SCOPE if mapper is None else mapper.target_expr_scope
         self.target_expr_scope.parent = parent_scope
@@ -86,7 +86,7 @@ class JsonMapper(Expr):
         return self._src_expr.equals(other._src_expr) and self._target_expr.equals(other._target_expr)
 
     def __repr__(self) -> str:
-        return f'{self._src_expr} >> {self._target_expr}'
+        return f'map({self._src_expr}, lambda R: {self._target_expr})'
 
     @property
     def _src_expr(self) -> Expr:

pixeltable/exprs/json_path.py

@@ -80,11 +80,16 @@ class JsonPath(Expr):
     def is_relative_path(self) -> bool:
         return self._anchor is None
 
-    def bind_rel_paths(self, mapper: Optional['JsonMapper'] = None) -> None:
-        if not self.is_relative_path():
-            return
-        # TODO: take scope_idx into account
-        self.set_anchor(mapper.scope_anchor)
+    @property
+    def _has_relative_path(self) -> bool:
+        return self.is_relative_path() or super()._has_relative_path
+
+    def _bind_rel_paths(self, mapper: Optional['JsonMapper'] = None) -> None:
+        if self.is_relative_path():
+            # TODO: take scope_idx into account
+            self.set_anchor(mapper.scope_anchor)
+        else:
+            self._anchor._bind_rel_paths(mapper)
 
     def __call__(self, *args: object, **kwargs: object) -> 'JsonPath':
         """
@@ -105,12 +110,6 @@ class JsonPath(Expr):
             return JsonPath(self._anchor, [*self.path_elements, index])
         raise excs.Error(f'Invalid json list index: {index}')
 
-    def __rshift__(self, other: object) -> 'JsonMapper':
-        rhs_expr = Expr.from_object(other)
-        if rhs_expr is None:
-            raise excs.Error(f'>> requires an expression on the right-hand side, found {type(other)}')
-        return JsonMapper(self, rhs_expr)
-
     def default_column_name(self) -> Optional[str]:
         anchor_name = self._anchor.default_column_name() if self._anchor is not None else ''
         ret_name = f'{anchor_name}.{self._json_path()}'

pixeltable/exprs/similarity_expr.py

@@ -23,26 +23,12 @@ class SimilarityExpr(Expr):
 
         self.components = [col_ref, item_expr]
 
-        # determine index to use
-        idx_info = col_ref.col.get_idx_info()
         from pixeltable import index
 
-        embedding_idx_info = {
-            info.name: info for info in idx_info.values() if isinstance(info.idx, index.EmbeddingIndex)
-        }
-        if len(embedding_idx_info) == 0:
-            raise excs.Error(f'No index found for column {col_ref.col!r}')
-        if idx_name is not None and idx_name not in embedding_idx_info:
-            raise excs.Error(f'Index {idx_name!r} not found for column {col_ref.col.name!r}')
-        if len(embedding_idx_info) > 1:
-            if idx_name is None:
-                raise excs.Error(
-                    f'Column {col_ref.col.name!r} has multiple indices; use the index name to disambiguate: '
-                    f'`{col_ref.col.name}.similarity(..., idx=<name>)`'
-                )
-            self.idx_info = embedding_idx_info[idx_name]
-        else:
-            self.idx_info = next(iter(embedding_idx_info.values()))
+        # determine index to use
+        idx_dict = ColumnRef.find_embedding_index(col_ref.col, idx_name, 'similarity')
+        assert len(idx_dict) == 1
+        self.idx_info = next(iter(idx_dict.values()))
         idx = self.idx_info.idx
         assert isinstance(idx, index.EmbeddingIndex)
 
@@ -86,8 +72,7 @@ class SimilarityExpr(Expr):
         return self.idx_info.idx.order_by_clause(self.idx_info.val_col, item, is_asc)
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
-        # this should never get called
-        raise AssertionError()
+        raise excs.Error('similarity(): cannot be used in a computed column')
 
     def _as_dict(self) -> dict:
         return {'idx_name': self.idx_info.name, **super()._as_dict()}