pixeltable 0.2.24__py3-none-any.whl → 0.2.26__py3-none-any.whl

pixeltable/exec/sql_node.py

@@ -1,17 +1,19 @@
 import logging
 import warnings
 from decimal import Decimal
-from typing import Iterable, Iterator, NamedTuple, Optional
+from typing import Iterable, Iterator, NamedTuple, Optional, TYPE_CHECKING, Sequence
 from uuid import UUID
 
 import sqlalchemy as sql
 
 import pixeltable.catalog as catalog
 import pixeltable.exprs as exprs
-
 from .data_row_batch import DataRowBatch
 from .exec_node import ExecNode
 
+if TYPE_CHECKING:
+    import pixeltable.plan
+
 _logger = logging.getLogger('pixeltable')
 
 
@@ -67,12 +69,17 @@ class SqlNode(ExecNode):
     select_list: exprs.ExprSet
     set_pk: bool
     num_pk_cols: int
-    filter: Optional[exprs.Expr]
-    filter_eval_ctx: Optional[exprs.RowBuilder.EvalCtx]
+    py_filter: Optional[exprs.Expr]  # a predicate that can only be run in Python
+    py_filter_eval_ctx: Optional[exprs.RowBuilder.EvalCtx]
     cte: Optional[sql.CTE]
     sql_elements: exprs.SqlElementCache
-    limit: Optional[int]
+
+    # where_clause/-_element: allow subclass to set one or the other (but not both)
+    where_clause: Optional[exprs.Expr]
+    where_clause_element: Optional[sql.ColumnElement]
+
     order_by_clause: OrderByClause
+    limit: Optional[int]
 
     def __init__(
             self, tbl: Optional[catalog.TableVersionPath], row_builder: exprs.RowBuilder,
@@ -89,6 +96,7 @@ class SqlNode(ExecNode):
         # create Select stmt
         self.sql_elements = sql_elements
         self.tbl = tbl
+        assert all(not isinstance(e, exprs.Literal) for e in select_list)  # we're never asked to materialize literals
         self.select_list = exprs.ExprSet(select_list)
         # unstored iter columns: we also need to retrieve whatever is needed to materialize the iter args
         for iter_arg in row_builder.unstored_iter_args.values():
@@ -112,10 +120,12 @@ class SqlNode(ExecNode):
         # additional state
         self.result_cursor = None
         # the filter is provided by the subclass
-        self.filter = None
-        self.filter_eval_ctx = None
+        self.py_filter = None
+        self.py_filter_eval_ctx = None
         self.cte = None
         self.limit = None
+        self.where_clause = None
+        self.where_clause_element = None
         self.order_by_clause = []
 
     def _create_stmt(self) -> sql.Select:
@@ -124,9 +134,16 @@ class SqlNode(ExecNode):
         assert self.sql_elements.contains_all(self.select_list)
         sql_select_list = [self.sql_elements.get(e) for e in self.select_list]
         if self.set_pk:
+            assert self.tbl is not None
             sql_select_list += self.tbl.tbl_version.store_tbl.pk_columns()
         stmt = sql.select(*sql_select_list)
 
+        where_clause_element = (
+            self.sql_elements.get(self.where_clause) if self.where_clause is not None else self.where_clause_element
+        )
+        if where_clause_element is not None:
+            stmt = stmt.where(where_clause_element)
+
         order_by_clause: list[sql.ColumnElement] = []
         for e, asc in self.order_by_clause:
             if isinstance(e, exprs.SimilarityExpr):
@@ -135,7 +152,7 @@ class SqlNode(ExecNode):
                 order_by_clause.append(self.sql_elements.get(e).desc() if asc is False else self.sql_elements.get(e))
         stmt = stmt.order_by(*order_by_clause)
 
-        if self.filter is None and self.limit is not None:
+        if self.py_filter is None and self.limit is not None:
             # if we don't have a Python filter, we can apply the limit to stmt
             stmt = stmt.limit(self.limit)
 
@@ -151,7 +168,7 @@ class SqlNode(ExecNode):
         Returns:
             (CTE, dict from Expr to output column)
         """
-        if self.filter is not None:
+        if self.py_filter is not None:
             # the filter needs to run in Python
             return None
         self.set_pk = False  # we don't need the PK if we use this SqlNode as a CTE
@@ -215,8 +232,17 @@ class SqlNode(ExecNode):
             prev_tbl = tbl
         return stmt
 
-    def add_order_by(self, ordering: OrderByClause) -> None:
-        """Add Order By clause to stmt"""
+    def set_where(self, where_clause: exprs.Expr) -> None:
+        assert self.where_clause_element is None
+        self.where_clause = where_clause
+
+    def set_py_filter(self, py_filter: exprs.Expr) -> None:
+        assert self.py_filter is None
+        self.py_filter = py_filter
+        self.py_filter_eval_ctx = self.row_builder.create_eval_ctx([py_filter], exclude=self.select_list)
+
+    def set_order_by(self, ordering: OrderByClause) -> None:
+        """Add Order By clause"""
         if self.tbl is not None:
             # change rowid refs against a base table to rowid refs against the target table, so that we minimize
             # the number of tables that need to be joined to the target table
@@ -280,10 +306,10 @@ class SqlNode(ExecNode):
                 else:
                     output_row[slot_idx] = sql_row[i]
 
-            if self.filter is not None:
+            if self.py_filter is not None:
                 # evaluate filter
-                self.row_builder.eval(output_row, self.filter_eval_ctx, profile=self.ctx.profile)
-            if self.filter is not None and not output_row[self.filter.slot_idx]:
+                self.row_builder.eval(output_row, self.py_filter_eval_ctx, profile=self.ctx.profile)
+            if self.py_filter is not None and not output_row[self.py_filter.slot_idx]:
                 # we re-use this row for the next sql row since it didn't pass the filter
                 output_row = output_batch.pop_row()
                 output_row.clear()
@@ -315,21 +341,16 @@ class SqlScanNode(SqlNode):
 
     Supports filtering and ordering.
     """
-    where_clause: Optional[exprs.Expr]
     exact_version_only: list[catalog.TableVersion]
 
     def __init__(
-            self, tbl: catalog.TableVersionPath, row_builder: exprs.RowBuilder,
-            select_list: Iterable[exprs.Expr],
-            where_clause: Optional[exprs.Expr] = None, filter: Optional[exprs.Expr] = None,
-            set_pk: bool = False, exact_version_only: Optional[list[catalog.TableVersion]] = None
+        self, tbl: catalog.TableVersionPath, row_builder: exprs.RowBuilder,
+        select_list: Iterable[exprs.Expr],
+        set_pk: bool = False, exact_version_only: Optional[list[catalog.TableVersion]] = None
     ):
         """
         Args:
             select_list: output of the query
-            sql_where_clause: SQL Where clause
-            filter: additional Where-clause predicate that can't be evaluated via SQL
-            limit: max number of rows to return: 0 = no limit
             set_pk: if True, sets the primary for each DataRow
             exact_version_only: tables for which we only want to see rows created at the current version
         """
@@ -338,12 +359,7 @@ class SqlScanNode(SqlNode):
         # create Select stmt
         if exact_version_only is None:
             exact_version_only = []
-        target = tbl.tbl_version  # the stored table we're scanning
-        self.filter = filter
-        self.filter_eval_ctx = \
-            row_builder.create_eval_ctx([filter], exclude=select_list) if filter is not None else None
 
-        self.where_clause = where_clause
         self.exact_version_only = exact_version_only
 
     def _create_stmt(self) -> sql.Select:
@@ -352,12 +368,6 @@ class SqlScanNode(SqlNode):
         refd_tbl_ids = exprs.Expr.all_tbl_ids(self.select_list) | where_clause_tbl_ids | self._ordering_tbl_ids()
         stmt = self.create_from_clause(
             self.tbl, stmt, refd_tbl_ids, exact_version_only={t.id for t in self.exact_version_only})
-
-        if self.where_clause is not None:
-            sql_where_clause = self.sql_elements.get(self.where_clause)
-            assert sql_where_clause is not None
-            stmt = stmt.where(sql_where_clause)
-
         return stmt
 
 
@@ -366,11 +376,9 @@ class SqlLookupNode(SqlNode):
     Materializes data from the store via a Select stmt with a WHERE clause that matches a list of key values
     """
 
-    where_clause: sql.ColumnElement
-
     def __init__(
-            self, tbl: catalog.TableVersionPath, row_builder: exprs.RowBuilder,
-            select_list: Iterable[exprs.Expr], sa_key_cols: list[sql.Column], key_vals: list[tuple],
+        self, tbl: catalog.TableVersionPath, row_builder: exprs.RowBuilder,
+        select_list: Iterable[exprs.Expr], sa_key_cols: list[sql.Column], key_vals: list[tuple],
     ):
         """
         Args:
@@ -381,15 +389,15 @@ class SqlLookupNode(SqlNode):
         sql_elements = exprs.SqlElementCache()
         super().__init__(tbl, row_builder, select_list, sql_elements, set_pk=True)
         # Where clause: (key-col-1, key-col-2, ...) IN ((val-1, val-2, ...), ...)
-        self.where_clause = sql.tuple_(*sa_key_cols).in_(key_vals)
+        self.where_clause_element = sql.tuple_(*sa_key_cols).in_(key_vals)
 
     def _create_stmt(self) -> sql.Select:
         stmt = super()._create_stmt()
         refd_tbl_ids = exprs.Expr.all_tbl_ids(self.select_list) | self._ordering_tbl_ids()
         stmt = self.create_from_clause(self.tbl, stmt, refd_tbl_ids)
-        stmt = stmt.where(self.where_clause)
         return stmt
 
+
 class SqlAggregationNode(SqlNode):
     """
     Materializes data from the store via a Select stmt with a WHERE clause that matches a list of key values
@@ -398,11 +406,11 @@ class SqlAggregationNode(SqlNode):
     group_by_items: Optional[list[exprs.Expr]]
 
     def __init__(
-            self, row_builder: exprs.RowBuilder,
-            input: SqlNode,
-            select_list: Iterable[exprs.Expr],
-            group_by_items: Optional[list[exprs.Expr]] = None,
-            limit: Optional[int] = None, exact_version_only: Optional[list[catalog.TableVersion]] = None
+        self, row_builder: exprs.RowBuilder,
+        input: SqlNode,
+        select_list: Iterable[exprs.Expr],
+        group_by_items: Optional[list[exprs.Expr]] = None,
+        limit: Optional[int] = None, exact_version_only: Optional[list[catalog.TableVersion]] = None
     ):
         """
         Args:
@@ -422,3 +430,42 @@ class SqlAggregationNode(SqlNode):
             assert all(e is not None for e in sql_group_by_items)
             stmt = stmt.group_by(*sql_group_by_items)
         return stmt
+
+
+class SqlJoinNode(SqlNode):
+    """
+    Materializes data from the store via a Select ... From ... that contains joins
+    """
+    input_ctes: list[sql.CTE]
+    join_clauses: list['pixeltable.plan.JoinClause']
+
+    def __init__(
+        self, row_builder: exprs.RowBuilder,
+        inputs: Sequence[SqlNode], join_clauses: list['pixeltable.plan.JoinClause'], select_list: Iterable[exprs.Expr]
+    ):
+        assert len(inputs) > 1
+        assert len(inputs) == len(join_clauses) + 1
+        self.input_ctes = []
+        self.join_clauses = join_clauses
+        sql_elements = exprs.SqlElementCache()
+        for input_node in inputs:
+            input_cte, input_col_map = input_node.to_cte()
+            self.input_ctes.append(input_cte)
+            sql_elements.extend(input_col_map)
+        super().__init__(None, row_builder, select_list, sql_elements)
+
+    def _create_stmt(self) -> sql.Select:
+        from pixeltable import plan
+        stmt = super()._create_stmt()
+        stmt = stmt.select_from(self.input_ctes[0])
+        for i in range(len(self.join_clauses)):
+            join_clause = self.join_clauses[i]
+            on_clause = (
+                self.sql_elements.get(join_clause.join_predicate) if join_clause.join_type != plan.JoinType.CROSS
+                else sql.sql.expression.literal(True)
+            )
+            is_outer = join_clause.join_type == plan.JoinType.LEFT or join_clause.join_type == plan.JoinType.FULL_OUTER
+            stmt = stmt.join(
+                self.input_ctes[i + 1], onclause=on_clause, isouter=is_outer,
+                full=join_clause == plan.JoinType.FULL_OUTER)
+        return stmt

pixeltable/exprs/__init__.py

@@ -23,3 +23,4 @@ from .similarity_expr import SimilarityExpr
 from .sql_element_cache import SqlElementCache
 from .type_cast import TypeCast
 from .variable import Variable
+from .globals import ComparisonOperator, LogicalOperator, ArithmeticOperator

pixeltable/exprs/arithmetic_expr.py

@@ -35,7 +35,7 @@ class ArithmeticExpr(Expr):
 
         self.id = self._create_id()
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         # add parentheses around operands that are ArithmeticExprs to express precedence
         op1_str = f'({self._op1})' if isinstance(self._op1, ArithmeticExpr) else str(self._op1)
         op2_str = f'({self._op2})' if isinstance(self._op2, ArithmeticExpr) else str(self._op2)

pixeltable/exprs/array_slice.py

@@ -23,7 +23,7 @@ class ArraySlice(Expr):
         self.index = index
         self.id = self._create_id()
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         index_strs: list[str] = []
         for el in self.index:
             if isinstance(el, int):

pixeltable/exprs/column_property_ref.py

@@ -46,7 +46,7 @@ class ColumnPropertyRef(Expr):
         assert isinstance(col_ref, ColumnRef)
         return col_ref
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         return f'{self._col_ref}.{self.prop.name.lower()}'
 
     def is_error_prop(self) -> bool:

pixeltable/exprs/column_ref.py

@@ -5,10 +5,12 @@ from uuid import UUID
 
 import sqlalchemy as sql
 
+import pixeltable as pxt
 import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
 import pixeltable.iterators as iters
 
+from ..utils.description_helper import DescriptionHelper
 from .data_row import DataRow
 from .expr import Expr
 from .row_builder import RowBuilder
@@ -126,6 +128,22 @@ class ColumnRef(Expr):
     def _equals(self, other: ColumnRef) -> bool:
         return self.col == other.col and self.perform_validation == other.perform_validation
 
+    def _df(self) -> 'pxt.dataframe.DataFrame':
+        tbl = catalog.Catalog.get().tbls[self.col.tbl.id]
+        return tbl.select(self)
+
+    def show(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
+        return self._df().show(*args, **kwargs)
+
+    def head(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
+        return self._df().head(*args, **kwargs)
+
+    def tail(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
+        return self._df().tail(*args, **kwargs)
+
+    def count(self) -> int:
+        return self._df().count()
+
     def __str__(self) -> str:
         if self.col.name is None:
             return f'<unnamed column {self.col.id}>'
@@ -133,11 +151,20 @@ class ColumnRef(Expr):
             return self.col.name
 
     def __repr__(self) -> str:
-        return f'ColumnRef({self.col!r})'
+        return self._descriptors().to_string()
 
     def _repr_html_(self) -> str:
+        return self._descriptors().to_html()
+
+    def _descriptors(self) -> DescriptionHelper:
         tbl = catalog.Catalog.get().tbls[self.col.tbl.id]
-        return tbl._description_html(cols=[self.col])._repr_html_()  # type: ignore[attr-defined]
+        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]))
+        idxs = tbl._index_descriptor([self.col.name])
+        if len(idxs) > 0:
+            helper.append(idxs)
+        return helper
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         return None if self.perform_validation else self.col.sa_col

pixeltable/exprs/comparison.py

@@ -49,7 +49,7 @@ class Comparison(Expr):
 
         self.id = self._create_id()
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         return f'{self._op1} {self.operator} {self._op2}'
 
     def _equals(self, other: Comparison) -> bool:

pixeltable/exprs/compound_predicate.py

@@ -30,7 +30,7 @@ class CompoundPredicate(Expr):
 
         self.id = self._create_id()
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         if self.operator == LogicalOperator.NOT:
             return f'~({self.components[0]})'
         return f' {self.operator} '.join([f'({e})' for e in self.components])

pixeltable/exprs/expr.py

@@ -216,12 +216,12 @@ class Expr(abc.ABC):
                 return result
             result = result.substitute({ref: ref.col.value_expr for ref in target_col_refs})
 
-    def is_bound_by(self, tbl: catalog.TableVersionPath) -> bool:
-        """Returns True if this expr can be evaluated in the context of tbl."""
+    def is_bound_by(self, tbls: list[catalog.TableVersionPath]) -> bool:
+        """Returns True if this expr can be evaluated in the context of tbls."""
         from .column_ref import ColumnRef
         col_refs = self.subexprs(ColumnRef)
         for col_ref in col_refs:
-            if not tbl.has_column(col_ref.col):
+            if not any(tbl.has_column(col_ref.col) for tbl in tbls):
                 return False
         return True
 
@@ -235,7 +235,7 @@ class Expr(abc.ABC):
             self.components[i] = self.components[i]._retarget(tbl_versions)
         return self
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         return f'<Expression of type {type(self)}>'
 
     def display_str(self, inline: bool = True) -> str:
@@ -450,7 +450,13 @@ class Expr(abc.ABC):
 
     def astype(self, new_type: Union[ts.ColumnType, type, _AnnotatedAlias]) -> 'exprs.TypeCast':
         from pixeltable.exprs import TypeCast
-        return TypeCast(self, ts.ColumnType.normalize_type(new_type))
+        # Interpret the type argument the same way we would if given in a schema
+        col_type = ts.ColumnType.normalize_type(new_type, nullable_default=True, allow_builtin_types=False)
+        if not self.col_type.nullable:
+            # This expression is non-nullable; we can prove that the output is non-nullable, regardless of
+            # whether new_type is given as nullable.
+            col_type = col_type.copy(nullable=False)
+        return TypeCast(self, col_type)
 
     def apply(self, fn: Callable, *, col_type: Union[ts.ColumnType, type, _AnnotatedAlias, None] = None) -> 'exprs.FunctionCall':
         if col_type is not None:

pixeltable/exprs/expr_set.py

@@ -60,6 +60,14 @@ class ExprSet(Generic[T]):
     def __le__(self, other: ExprSet[T]) -> bool:
         return other.issuperset(self)
 
+    def union(self, *others: Iterable[T]) -> ExprSet[T]:
+        result = ExprSet(self.exprs.values())
+        result.update(*others)
+        return result
+
+    def __or__(self, other: ExprSet[T]) -> ExprSet[T]:
+        return self.union(other)
+
     def difference(self, *others: Iterable[T]) -> ExprSet[T]:
         id_diff = set(self.exprs.keys()).difference(e.id for other_set in others for e in other_set)
         return ExprSet(self.exprs[id] for id in id_diff)

pixeltable/exprs/function_call.py

@@ -85,7 +85,9 @@ class FunctionCall(Expr):
         # we record the types of non-variable parameters for runtime type checks
         self.arg_types = []
         self.kwarg_types = {}
+
         # the prefix of parameters that are bound can be passed by position
+        processed_args: set[str] = set()
         for py_param in fn.signature.py_signature.parameters.values():
             if py_param.name not in bound_args or py_param.kind == inspect.Parameter.KEYWORD_ONLY:
                 break
@@ -97,18 +99,19 @@ class FunctionCall(Expr):
                 self.args.append((None, arg))
             if py_param.kind != inspect.Parameter.VAR_POSITIONAL and py_param.kind != inspect.Parameter.VAR_KEYWORD:
                 self.arg_types.append(signature.parameters[py_param.name].col_type)
+            processed_args.add(py_param.name)
 
         # the remaining args are passed as keywords
-        kw_param_names = set(bound_args.keys()) - set(list(fn.signature.py_signature.parameters.keys())[:len(self.args)])
-        for param_name in kw_param_names:
-            arg = bound_args[param_name]
-            if isinstance(arg, Expr):
-                self.kwargs[param_name] = (len(self.components), None)
-                self.components.append(arg.copy())
-            else:
-                self.kwargs[param_name] = (None, arg)
-            if fn.signature.py_signature.parameters[param_name].kind != inspect.Parameter.VAR_KEYWORD:
-                self.kwarg_types[param_name] = signature.parameters[param_name].col_type
+        for param_name in bound_args.keys():
+            if param_name not in processed_args:
+                arg = bound_args[param_name]
+                if isinstance(arg, Expr):
+                    self.kwargs[param_name] = (len(self.components), None)
+                    self.components.append(arg.copy())
+                else:
+                    self.kwargs[param_name] = (None, arg)
+                if fn.signature.py_signature.parameters[param_name].kind != inspect.Parameter.VAR_KEYWORD:
+                    self.kwarg_types[param_name] = signature.parameters[param_name].col_type
 
         # window function state:
         # self.components[self.group_by_start_idx:self.group_by_stop_idx] contains group_by exprs
@@ -255,7 +258,7 @@ class FunctionCall(Expr):
             ('order_by_start_idx', self.order_by_start_idx)
         ]
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         return self.display_str()
 
     def display_str(self, inline: bool = True) -> str:

pixeltable/exprs/in_predicate.py

@@ -61,7 +61,7 @@ class InPredicate(Expr):
                 pass
         return result
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         if self.value_list is not None:
             return f'{self.components[0]}.isin({self.value_list})'
         return f'{self.components[0]}.isin({self.components[1]})'

pixeltable/exprs/inline_expr.py

@@ -56,7 +56,7 @@ class InlineArray(Expr):
         self.components.extend(exprs)
         self.id = self._create_id()
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         elem_strs = [str(expr) for expr in self.components]
         return f'[{", ".join(elem_strs)}]'
 
@@ -105,7 +105,7 @@ class InlineList(Expr):
         self.components.extend(exprs)
         self.id = self._create_id()
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         elem_strs = [str(expr) for expr in self.components]
         return f'[{", ".join(elem_strs)}]'
 
@@ -153,7 +153,7 @@ class InlineDict(Expr):
         self.components.extend(exprs)
         self.id = self._create_id()
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         item_strs = list(f"'{key}': {str(expr)}" for key, expr in zip(self.keys, self.components))
         return '{' + ', '.join(item_strs) + '}'
 

pixeltable/exprs/is_null.py

@@ -18,7 +18,7 @@ class IsNull(Expr):
         self.components = [e]
         self.id = self._create_id()
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         return f'{str(self.components[0])} == None'
 
     def _equals(self, other: IsNull) -> bool:

pixeltable/exprs/json_mapper.py

@@ -69,7 +69,7 @@ class JsonMapper(Expr):
             return False
         return self._src_expr.equals(other._src_expr) and self._target_expr.equals(other._target_expr)
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         return f'{str(self._src_expr)} >> {str(self._target_expr)}'
 
     @property

pixeltable/exprs/json_path.py

@@ -42,7 +42,7 @@ class JsonPath(Expr):
         # this is not a problem, because _create_id() shouldn't be called after init()
         self.id = self._create_id()
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         # else "R": the anchor is RELATIVE_PATH_ROOT
         return (f'{str(self._anchor) if self._anchor is not None else "R"}'
             f'{"." if isinstance(self.path_elements[0], str) else ""}{self._json_path()}')

pixeltable/exprs/method_ref.py

@@ -60,5 +60,5 @@ class MethodRef(Expr):
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         assert False, 'MethodRef cannot be evaluated directly'
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         return f'{self.base_expr}.{self.method_name}'

pixeltable/exprs/rowid_ref.py

@@ -55,7 +55,7 @@ class RowidRef(Expr):
         return super()._id_attrs() +\
             [('normalized_base_id', self.normalized_base_id), ('idx', self.rowid_component_idx)]
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         # check if this is the pos column of a component view
         tbl = self.tbl if self.tbl is not None else catalog.Catalog.get().tbl_versions[(self.tbl_id, None)]
         if tbl.is_component_view() and self.rowid_component_idx == tbl.store_tbl.pos_col_idx:  # type: ignore[attr-defined]

pixeltable/exprs/similarity_expr.py

@@ -55,9 +55,12 @@ class SimilarityExpr(Expr):
                 f'Embedding index {self.idx_info.name!r} on column {self.idx_info.col.name!r} was created without the '
                 f"'image_embed' parameter and does not support image queries")
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         return f'{self.components[0]}.similarity({self.components[1]})'
 
+    def default_column_name(self) -> str:
+        return 'similarity'
+
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         if not isinstance(self.components[1], Literal):
              raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')

pixeltable/exprs/sql_element_cache.py

@@ -17,6 +17,10 @@ class SqlElementCache:
             for e, el in elements.items():
                 self.cache[e.id] = el
 
+    def extend(self, elements: ExprDict[sql.ColumnElement]):
+        for e, el in elements.items():
+            self.cache[e.id] = el
+
     def get(self, e: Expr) -> Optional[sql.ColumnElement]:
         """Returns the sql.ColumnElement for the given Expr, or None if Expr.to_sql() returns None."""
         try:

pixeltable/exprs/type_cast.py

@@ -51,5 +51,5 @@ class TypeCast(Expr):
         assert len(components) == 1
         return cls(components[0], ts.ColumnType.from_dict(d['new_type']))
 
-    def __str__(self) -> str:
-        return f'{self._underlying}.astype({self.col_type})'
+    def __repr__(self) -> str:
+        return f'{self._underlying}.astype({self.col_type._to_str(as_schema=True)})'

pixeltable/exprs/variable.py

@@ -33,6 +33,9 @@ class Variable(Expr):
     def __str__(self) -> str:
         return self.name
 
+    def __repr__(self) -> str:
+        return f"Variable('{self.name}')"
+
     def sql_expr(self, _: SqlElementCache) -> NoReturn:
         raise NotImplementedError()
 

pixeltable/func/expr_template_function.py

@@ -78,6 +78,9 @@ class ExprTemplateFunction(Function):
     def name(self) -> str:
         return self.self_name
 
+    def __str__(self) -> str:
+        return str(self.expr)
+
     def _as_dict(self) -> dict:
         if self.self_path is not None:
             return super()._as_dict()