pixeltable 0.2.12__py3-none-any.whl → 0.2.14__py3-none-any.whl

pixeltable/exec/{sql_scan_node.py → sql_node.py}

@@ -13,30 +13,23 @@ import pixeltable.catalog as catalog
 
 _logger = logging.getLogger('pixeltable')
 
-class SqlScanNode(ExecNode):
-    """Materializes data from the store via SQL
-    """
+class SqlNode(ExecNode):
+    """Materializes data from the store via a Select stmt."""
+
     def __init__(
             self, tbl: catalog.TableVersionPath, row_builder: exprs.RowBuilder,
-            select_list: Iterable[exprs.Expr],
-            where_clause: Optional[exprs.Expr] = None, filter: Optional[exprs.Predicate] = None,
-            order_by_items: Optional[List[Tuple[exprs.Expr, bool]]] = None,
-            limit: int = 0, set_pk: bool = False, exact_version_only: Optional[List[catalog.TableVersion]] = None
+            select_list: Iterable[exprs.Expr], set_pk: bool = False
     ):
         """
+        Initialize self.stmt with expressions derived from select_list.
+
+        This only provides the select list. The subclass is responsible for the From clause and any additional clauses.
+
         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
         """
         # create Select stmt
-        if order_by_items is None:
-            order_by_items = []
-        if exact_version_only is None:
-            exact_version_only = []
         self.tbl = tbl
         target = tbl.tbl_version  # the stored table we're scanning
         self.sql_exprs = exprs.ExprSet(select_list)
@@ -45,21 +38,15 @@ class SqlScanNode(ExecNode):
             sql_subexprs = iter_arg.subexprs(filter=lambda e: e.sql_expr() is not None, traverse_matches=False)
             [self.sql_exprs.append(e) for e in sql_subexprs]
         super().__init__(row_builder, self.sql_exprs, [], None)  # we materialize self.sql_exprs
-        self.filter = filter
-        self.filter_eval_ctx = \
-            row_builder.create_eval_ctx([filter], exclude=select_list) if filter is not None else None
-        self.limit = limit
 
         # 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
         for rowid_ref in [e for e in self.sql_exprs if isinstance(e, exprs.RowidRef)]:
             rowid_ref.set_tbl(tbl)
 
-        where_clause_tbl_ids = where_clause.tbl_ids() if where_clause is not None else set()
-        refd_tbl_ids = exprs.Expr.list_tbl_ids(self.sql_exprs) | where_clause_tbl_ids
         sql_select_list = [e.sql_expr() for e in self.sql_exprs]
         assert len(sql_select_list) == len(self.sql_exprs)
-        assert all([e is not None for e in sql_select_list])
+        assert all(e is not None for e in sql_select_list)
         self.set_pk = set_pk
         self.num_pk_cols = 0
         if set_pk:
@@ -69,42 +56,12 @@ class SqlScanNode(ExecNode):
             sql_select_list += pk_columns
 
         self.stmt = sql.select(*sql_select_list)
-        self.stmt = self.create_from_clause(
-            tbl, self.stmt, refd_tbl_ids, exact_version_only={t.id for t in exact_version_only})
-
-        # 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
-        for rowid_ref in [e for e, _ in order_by_items if isinstance(e, exprs.RowidRef)]:
-            rowid_ref.set_tbl(tbl)
-        order_by_clause: List[sql.ClauseElement] = []
-        for e, asc in order_by_items:
-            if isinstance(e, exprs.SimilarityExpr):
-                order_by_clause.append(e.as_order_by_clause(asc))
-            else:
-                order_by_clause.append(e.sql_expr().desc() if not asc else e.sql_expr())
-
-        if where_clause is not None:
-            sql_where_clause = where_clause.sql_expr()
-            assert sql_where_clause is not None
-            self.stmt = self.stmt.where(sql_where_clause)
-        if len(order_by_clause) > 0:
-            self.stmt = self.stmt.order_by(*order_by_clause)
-        elif target.id in row_builder.unstored_iter_args:
-            # we are referencing unstored iter columns from this view and try to order by our primary key,
-            # which ensures that iterators will see monotonically increasing pos values
-            self.stmt = self.stmt.order_by(*self.tbl.store_tbl.rowid_columns())
-        if limit != 0 and self.filter is None:
-            # if we need to do post-SQL filtering, we can't use LIMIT
-            self.stmt = self.stmt.limit(limit)
 
+        # additional state
         self.result_cursor: Optional[sql.engine.CursorResult] = None
-
-        try:
-            # log stmt, if possible
-            stmt_str = str(self.stmt.compile(compile_kwargs={'literal_binds': True}))
-            _logger.debug(f'SqlScanNode stmt:\n{stmt_str}')
-        except Exception as e:
-            pass
+        # the filter is provided by the subclass
+        self.filter: Optional[exprs.Expr] = None
+        self.filter_eval_ctx: Optional[exprs.EvalContext] = None
 
     @classmethod
     def create_from_clause(
@@ -224,3 +181,110 @@ class SqlScanNode(ExecNode):
         if self.result_cursor is not None:
             self.result_cursor.close()
 
+
+class SqlScanNode(SqlNode):
+    """
+    Materializes data from the store via a Select stmt.
+
+    Supports filtering and ordering.
+    """
+    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,
+            order_by_items: Optional[List[Tuple[exprs.Expr, bool]]] = None,
+            limit: int = 0, 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
+        """
+        super().__init__(tbl, row_builder, select_list, set_pk=set_pk)
+        # create Select stmt
+        if order_by_items is None:
+            order_by_items = []
+        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.limit = limit
+
+        where_clause_tbl_ids = where_clause.tbl_ids() if where_clause is not None else set()
+        refd_tbl_ids = exprs.Expr.list_tbl_ids(self.sql_exprs) | where_clause_tbl_ids
+        self.stmt = self.create_from_clause(
+            tbl, self.stmt, refd_tbl_ids, exact_version_only={t.id for t in exact_version_only})
+
+        # 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
+        for rowid_ref in [e for e, _ in order_by_items if isinstance(e, exprs.RowidRef)]:
+            rowid_ref.set_tbl(tbl)
+        order_by_clause: List[sql.ClauseElement] = []
+        for e, asc in order_by_items:
+            if isinstance(e, exprs.SimilarityExpr):
+                order_by_clause.append(e.as_order_by_clause(asc))
+            else:
+                order_by_clause.append(e.sql_expr().desc() if not asc else e.sql_expr())
+
+        if where_clause is not None:
+            sql_where_clause = where_clause.sql_expr()
+            assert sql_where_clause is not None
+            self.stmt = self.stmt.where(sql_where_clause)
+        if len(order_by_clause) > 0:
+            self.stmt = self.stmt.order_by(*order_by_clause)
+        elif target.id in row_builder.unstored_iter_args:
+            # we are referencing unstored iter columns from this view and try to order by our primary key,
+            # which ensures that iterators will see monotonically increasing pos values
+            self.stmt = self.stmt.order_by(*self.tbl.store_tbl.rowid_columns())
+        if limit != 0 and self.filter is None:
+            # if we need to do post-SQL filtering, we can't use LIMIT
+            self.stmt = self.stmt.limit(limit)
+
+        try:
+            # log stmt, if possible
+            stmt_str = str(self.stmt.compile(compile_kwargs={'literal_binds': True}))
+            _logger.debug(f'SqlScanNode stmt:\n{stmt_str}')
+        except Exception as e:
+            pass
+
+
+class SqlLookupNode(SqlNode):
+    """
+    Materializes data from the store via a Select stmt with a WHERE clause that matches a list of key values
+    """
+    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],
+    ):
+        """
+        Args:
+            select_list: output of the query
+            sa_key_cols: list of key columns in the store table
+            key_vals: list of key values to look up
+        """
+        super().__init__(tbl, row_builder, select_list, set_pk=True)
+        target = tbl.tbl_version  # the stored table we're scanning
+        refd_tbl_ids = exprs.Expr.list_tbl_ids(self.sql_exprs)
+        self.stmt = self.create_from_clause(tbl, self.stmt, refd_tbl_ids)
+        # 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.stmt = self.stmt.where(self.where_clause)
+
+        if target.id in row_builder.unstored_iter_args:
+            # we are referencing unstored iter columns from this view and try to order by our primary key,
+            # which ensures that iterators will see monotonically increasing pos values
+            self.stmt = self.stmt.order_by(*self.tbl.store_tbl.rowid_columns())
+
+        try:
+            # log stmt, if possible
+            stmt_str = str(self.stmt.compile(compile_kwargs={'literal_binds': True}))
+            _logger.debug(f'SqlLookupNode stmt:\n{stmt_str}')
+        except Exception as e:
+            pass
+

pixeltable/exprs/__init__.py

@@ -8,7 +8,6 @@ from .data_row import DataRow
 from .expr import Expr
 from .expr_set import ExprSet
 from .function_call import FunctionCall
-from .image_member_access import ImageMemberAccess
 from .in_predicate import InPredicate
 from .inline_array import InlineArray
 from .inline_dict import InlineDict
@@ -16,8 +15,8 @@ from .is_null import IsNull
 from .json_mapper import JsonMapper
 from .json_path import RELATIVE_PATH_ROOT, JsonPath
 from .literal import Literal
+from .method_ref import MethodRef
 from .object_ref import ObjectRef
-from .predicate import Predicate
 from .row_builder import RowBuilder, ColumnSlotIdx, ExecProfile
 from .rowid_ref import RowidRef
 from .similarity_expr import SimilarityExpr

pixeltable/exprs/comparison.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional, List, Any, Dict, Tuple
+from typing import Optional, List, Any, Dict
 
 import sqlalchemy as sql
 
@@ -9,15 +9,15 @@ from .data_row import DataRow
 from .expr import Expr
 from .globals import ComparisonOperator
 from .literal import Literal
-from .predicate import Predicate
 from .row_builder import RowBuilder
 import pixeltable.exceptions as excs
 import pixeltable.index as index
+import pixeltable.type_system as ts
 
 
-class Comparison(Predicate):
+class Comparison(Expr):
     def __init__(self, operator: ComparisonOperator, op1: Expr, op2: Expr):
-        super().__init__()
+        super().__init__(ts.BoolType())
         self.operator = operator
 
         # if this is a comparison of a column to a literal (ie, could be used as a search argument in an index lookup),
@@ -50,7 +50,7 @@ class Comparison(Predicate):
     def _equals(self, other: Comparison) -> bool:
         return self.operator == other.operator
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('operator', self.operator.value)]
 
     @property

pixeltable/exprs/compound_predicate.py

@@ -1,20 +1,20 @@
 from __future__ import annotations
-from typing import Optional, List, Any, Dict, Tuple, Callable
+
 import operator
+from typing import Optional, List, Any, Dict, Callable
 
 import sqlalchemy as sql
 
+from .data_row import DataRow
 from .expr import Expr
 from .globals import LogicalOperator
-from .predicate import Predicate
-from .data_row import DataRow
 from .row_builder import RowBuilder
-import pixeltable.catalog as catalog
+import pixeltable.type_system as ts
 
 
-class CompoundPredicate(Predicate):
-    def __init__(self, operator: LogicalOperator, operands: List[Predicate]):
-        super().__init__()
+class CompoundPredicate(Expr):
+    def __init__(self, operator: LogicalOperator, operands: List[Expr]):
+        super().__init__(ts.BoolType())
         self.operator = operator
         # operands are stored in self.components
         if self.operator == LogicalOperator.NOT:
@@ -22,7 +22,7 @@ class CompoundPredicate(Predicate):
             self.components = operands
         else:
             assert len(operands) > 1
-            self.operands: List[Predicate] = []
+            self.operands: List[Expr] = []
             for operand in operands:
                 self._merge_operand(operand)
 
@@ -34,14 +34,14 @@ class CompoundPredicate(Predicate):
         return f' {self.operator} '.join([f'({e})' for e in self.components])
 
     @classmethod
-    def make_conjunction(cls, operands: List[Predicate]) -> Optional[Predicate]:
+    def make_conjunction(cls, operands: List[Expr]) -> Optional[Expr]:
         if len(operands) == 0:
             return None
         if len(operands) == 1:
             return operands[0]
         return CompoundPredicate(LogicalOperator.AND, operands)
 
-    def _merge_operand(self, operand: Predicate) -> None:
+    def _merge_operand(self, operand: Expr) -> None:
         """
         Merge this operand, if possible, otherwise simply record it.
         """
@@ -55,11 +55,11 @@ class CompoundPredicate(Predicate):
     def _equals(self, other: CompoundPredicate) -> bool:
         return self.operator == other.operator
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [('operator', self.operator.value)]
 
     def split_conjuncts(
-            self, condition: Callable[[Predicate], bool]) -> Tuple[List[Predicate], Optional[Predicate]]:
+            self, condition: Callable[[Expr], bool]) -> tuple[list[Expr], Optional[Expr]]:
         if self.operator == LogicalOperator.OR or self.operator == LogicalOperator.NOT:
             return super().split_conjuncts(condition)
         matches = [op for op in self.components if condition(op)]

pixeltable/exprs/expr.py

@@ -7,7 +7,6 @@ import inspect
 import json
 import sys
 import typing
-from itertools import islice
 from typing import Union, Optional, List, Callable, Any, Dict, Tuple, Set, Generator, Type
 from uuid import UUID
 
@@ -16,8 +15,8 @@ import sqlalchemy as sql
 import pixeltable
 import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
 import pixeltable.func as func
+import pixeltable.type_system as ts
 from .data_row import DataRow
 from .globals import ComparisonOperator, LogicalOperator, LiteralPythonTypes, ArithmeticOperator
 
@@ -91,8 +90,8 @@ class Expr(abc.ABC):
 
     def default_column_name(self) -> Optional[str]:
         """
-        Returns: 
-            None if this expression lacks a default name, 
+        Returns:
+            None if this expression lacks a default name,
             or a valid identifier (according to catalog.is_valid_identifer) otherwise.
         """
         return None
@@ -231,9 +230,8 @@ class Expr(abc.ABC):
             self.components[i] = self.components[i]._retarget(tbl_versions)
         return self
 
-    @abc.abstractmethod
     def __str__(self) -> str:
-        pass
+        return f'<Expression of type {type(self)}>'
 
     def display_str(self, inline: bool = True) -> str:
         """
@@ -264,7 +262,7 @@ class Expr(abc.ABC):
         if is_match:
             yield self
 
-    def contains(self, cls: Optional[Type[Expr]] = None, filter: Optional[Callable[[Expr], bool]] = None) -> bool:
+    def _contains(self, cls: Optional[Type[Expr]] = None, filter: Optional[Callable[[Expr], bool]] = None) -> bool:
         """
         Returns True if any subexpr is an instance of cls.
         """
@@ -319,17 +317,20 @@ class Expr(abc.ABC):
         """
         if isinstance(o, Expr):
             return o
-        # try to create a literal
+        # Try to create a literal. We need to check for InlineArray/InlineDict
+        # first, to prevent arrays from inappropriately being interpreted as JsonType
+        # literals.
+        # TODO: general cleanup of InlineArray/InlineDict
+        if isinstance(o, list):
+            from .inline_array import InlineArray
+            return InlineArray(tuple(o))
+        if isinstance(o, dict):
+            from .inline_dict import InlineDict
+            return InlineDict(o)
         obj_type = ts.ColumnType.infer_literal_type(o)
         if obj_type is not None:
             from .literal import Literal
             return Literal(o, col_type=obj_type)
-        if isinstance(o, dict):
-            from .inline_dict import InlineDict
-            return InlineDict(o)
-        elif isinstance(o, list):
-            from .inline_array import InlineArray
-            return InlineArray(tuple(o))
         return None
 
     @abc.abstractmethod
@@ -427,6 +428,14 @@ class Expr(abc.ABC):
         # Return a `FunctionCall` obtained by passing this `Expr` to the new `function`.
         return function(self)
 
+    def __dir__(self) -> list[str]:
+        attrs = ['isin', 'astype', 'apply']
+        attrs += [
+            f.name
+            for f in func.FunctionRegistry.get().get_type_methods(self.col_type.type_enum)
+        ]
+        return attrs
+
     def __getitem__(self, index: object) -> Expr:
         if self.col_type.is_json_type():
             from .json_path import JsonPath
@@ -434,19 +443,23 @@ class Expr(abc.ABC):
         if self.col_type.is_array_type():
             from .array_slice import ArraySlice
             return ArraySlice(self, index)
-        raise excs.Error(f'Type {self.col_type} is not subscriptable')
+        raise AttributeError(f'Type {self.col_type} is not subscriptable')
 
-    def __getattr__(self, name: str) -> Union['pixeltable.exprs.ImageMemberAccess', 'pixeltable.exprs.JsonPath']:
+    def __getattr__(self, name: str) -> Union['pixeltable.exprs.MethodRef', 'pixeltable.exprs.FunctionCall', 'pixeltable.exprs.JsonPath']:
         """
         ex.: <img col>.rotate(60)
         """
-        if self.col_type.is_image_type():
-            from .image_member_access import ImageMemberAccess
-            return ImageMemberAccess(name, self)
         if self.col_type.is_json_type():
-            from .json_path import JsonPath
-            return JsonPath(self).__getattr__(name)
-        raise excs.Error(f'Member access not supported on type {self.col_type}: {name}')
+            return pixeltable.exprs.JsonPath(self).__getattr__(name)
+        else:
+            method_ref = pixeltable.exprs.MethodRef(self, name)
+            if method_ref.fn.is_property:
+                # Marked as a property, so autoinvoke the method to obtain a `FunctionCall`
+                assert method_ref.fn.arity == 1
+                return method_ref.fn(method_ref.base_expr)
+            else:
+                # Return the `MethodRef` object itself; it requires arguments to become a `FunctionCall`
+                return method_ref
 
     def __bool__(self) -> bool:
         raise TypeError(
@@ -518,6 +531,38 @@ class Expr(abc.ABC):
             return ArithmeticExpr(op, self, Literal(other))  # type: ignore[arg-type]
         raise TypeError(f'Other must be Expr or literal: {type(other)}')
 
+    def __and__(self, other: object) -> Expr:
+        if not isinstance(other, Expr):
+            raise TypeError(f'Other needs to be an expression: {type(other)}')
+        if not other.col_type.is_bool_type():
+            raise TypeError(f'Other needs to be an expression that returns a boolean: {other.col_type}')
+        from .compound_predicate import CompoundPredicate
+        return CompoundPredicate(LogicalOperator.AND, [self, other])
+
+    def __or__(self, other: object) -> Expr:
+        if not isinstance(other, Expr):
+            raise TypeError(f'Other needs to be an expression: {type(other)}')
+        if not other.col_type.is_bool_type():
+            raise TypeError(f'Other needs to be an expression that returns a boolean: {other.col_type}')
+        from .compound_predicate import CompoundPredicate
+        return CompoundPredicate(LogicalOperator.OR, [self, other])
+
+    def __invert__(self) -> Expr:
+        from .compound_predicate import CompoundPredicate
+        return CompoundPredicate(LogicalOperator.NOT, [self])
+
+    def split_conjuncts(
+            self, condition: Callable[[Expr], bool]) -> tuple[list[Expr], Optional[Expr]]:
+        """
+        Returns clauses of a conjunction that meet condition in the first element.
+        The second element contains remaining clauses, rolled into a conjunction.
+        """
+        assert self.col_type.is_bool_type()  # only valid for predicates
+        if condition(self):
+            return [self], None
+        else:
+            return [], self
+
     def _make_applicator_function(self, fn: Callable, col_type: Optional[ts.ColumnType]) -> 'pixeltable.func.Function':
         """
         Creates a unary pixeltable `Function` that encapsulates a python `Callable`. The result type of

pixeltable/exprs/function_call.py

@@ -20,6 +20,22 @@ from .rowid_ref import RowidRef
 
 
 class FunctionCall(Expr):
+
+    fn: func.Function
+    is_method_call: bool
+    agg_init_args: Dict[str, Any]
+    args: List[Tuple[Optional[int], Optional[Any]]]
+    kwargs: Dict[str, Tuple[Optional[int], Optional[Any]]]
+    arg_types: List[ts.ColumnType]
+    kwarg_types: Dict[str, ts.ColumnType]
+    group_by_start_idx: int
+    group_by_stop_idx: int
+    fn_expr_idx: int
+    order_by_start_idx: int
+    constant_args: set[str]
+    aggregator: Optional[Any]
+    current_partition_vals: Optional[List[Any]]
+
     def __init__(
             self, fn: func.Function, bound_args: Dict[str, Any], order_by_clause: Optional[List[Any]] = None,
             group_by_clause: Optional[List[Any]] = None, is_method_call: bool = False):
@@ -31,9 +47,9 @@ class FunctionCall(Expr):
         super().__init__(fn.call_return_type(bound_args))
         self.fn = fn
         self.is_method_call = is_method_call
-        self.check_args(signature, bound_args)
+        self.normalize_args(signature, bound_args)
 
-        self.agg_init_args: Dict[str, Any] = {}
+        self.agg_init_args = {}
         if self.is_agg_fn_call:
             # we separate out the init args for the aggregator
             self.agg_init_args = {
@@ -42,17 +58,16 @@ class FunctionCall(Expr):
             bound_args = {arg_name: arg for arg_name, arg in bound_args.items() if arg_name not in fn.init_param_names}
 
         # construct components, args, kwargs
-        self.components: List[Expr] = []
 
         # Tuple[int, Any]:
         # - for Exprs: (index into components, None)
         # - otherwise: (None, val)
-        self.args: List[Tuple[Optional[int], Optional[Any]]] = []
-        self.kwargs: Dict[str, Tuple[Optional[int], Optional[Any]]] = {}
+        self.args = []
+        self.kwargs = {}
 
         # we record the types of non-variable parameters for runtime type checks
-        self.arg_types: List[ts.ColumnType] = []
-        self.kwarg_types: Dict[str, ts.ColumnType] = {}
+        self.arg_types = []
+        self.kwarg_types = {}
         # the prefix of parameters that are bound can be passed by position
         for param in fn.signature.py_signature.parameters.values():
             if param.name not in bound_args or param.kind == inspect.Parameter.KEYWORD_ONLY:
@@ -111,8 +126,8 @@ class FunctionCall(Expr):
 
         self.constant_args = {param_name for param_name, arg in bound_args.items() if not isinstance(arg, Expr)}
         # execution state for aggregate functions
-        self.aggregator: Optional[Any] = None
-        self.current_partition_vals: Optional[List[Any]] = None
+        self.aggregator = None
+        self.current_partition_vals = None
 
         self.id = self._create_id()
 
@@ -120,26 +135,37 @@ class FunctionCall(Expr):
         target = tbl._tbl_version_path.tbl_version
         return [RowidRef(target, i) for i in range(target.num_rowid_columns())]
 
+    def default_column_name(self) -> Optional[str]:
+        if self.fn.is_property:
+            return self.fn.name
+        return super().default_column_name()
+
     @classmethod
-    def check_args(cls, signature: func.Signature, bound_args: Dict[str, Any]) -> None:
-        """Checks that bound_args are compatible with signature.
+    def normalize_args(cls, signature: func.Signature, bound_args: Dict[str, Any]) -> None:
+        """Converts all args to Exprs and checks that they are compatible with signature.
 
-        Convert literals to the correct type and update bound_args in place, if necessary.
+        Updates bound_args in place, where necessary.
         """
         for param_name, arg in bound_args.items():
             param = signature.parameters[param_name]
+            is_var_param = param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+
             if isinstance(arg, dict):
                 try:
                     arg = InlineDict(arg)
                     bound_args[param_name] = arg
+                    continue
                 except excs.Error:
                     # this didn't work, but it might be a literal
                     pass
+
             if isinstance(arg, list) or isinstance(arg, tuple):
                 try:
                     # If the column type is JsonType, force the literal to be JSON
-                    arg = InlineArray(arg, force_json=param.col_type is not None and param.col_type.is_json_type())
+                    is_json = is_var_param or (param.col_type is not None and param.col_type.is_json_type())
+                    arg = InlineArray(arg, force_json=is_json)
                     bound_args[param_name] = arg
+                    continue
                 except excs.Error:
                     # this didn't work, but it might be a literal
                     pass
@@ -149,30 +175,35 @@ class FunctionCall(Expr):
                 try:
                     _ = json.dumps(arg)
                 except TypeError:
-                    raise excs.Error(f"Argument for parameter '{param_name}' is not json-serializable: {arg}")
+                    raise excs.Error(f'Argument for parameter {param_name!r} is not json-serializable: {arg}')
                 if arg is not None:
                     try:
                         param_type = param.col_type
                         bound_args[param_name] = param_type.create_literal(arg)
                     except TypeError as e:
                         msg = str(e)
-                        raise excs.Error(f"Argument for parameter '{param_name}': {msg[0].lower() + msg[1:]}")
+                        raise excs.Error(f'Argument for parameter {param_name!r}: {msg[0].lower() + msg[1:]}')
                 continue
 
-            # variable parameters don't get type-checked, but they both need to be json-typed
-            if param.kind == inspect.Parameter.VAR_POSITIONAL:
-                assert isinstance(arg, InlineArray)
-                arg.col_type = ts.JsonType()
-                continue
-            if param.kind == inspect.Parameter.VAR_KEYWORD:
-                assert isinstance(arg, InlineDict)
-                arg.col_type = ts.JsonType()
-            continue
-
-            if not param_type.is_supertype_of(arg.col_type):
-                raise excs.Error(
-                    f'Parameter {param_name}: argument type {arg.col_type} does not match parameter type '
-                    f'{param_type}')
+            # these checks break the db migration test, because InlineArray isn't serialized correctly (it looses
+            # the type information)
+            # if is_var_param:
+            #     if param.kind == inspect.Parameter.VAR_POSITIONAL:
+            #         if not isinstance(arg, InlineArray) or not arg.col_type.is_json_type():
+            #             pass
+            #         assert isinstance(arg, InlineArray), type(arg)
+            #         assert arg.col_type.is_json_type()
+            #     if param.kind == inspect.Parameter.VAR_KEYWORD:
+            #         if not isinstance(arg, InlineDict):
+            #             pass
+            #         assert isinstance(arg, InlineDict), type(arg)
+            if is_var_param:
+                pass
+            else:
+                if not param.col_type.is_supertype_of(arg.col_type):
+                    raise excs.Error(
+                        f'Parameter {param_name}: argument type {arg.col_type} does not match parameter type '
+                        f'{param.col_type}')
 
     def _equals(self, other: FunctionCall) -> bool:
         if self.fn != other.fn:

pixeltable/exprs/globals.py

@@ -29,6 +29,8 @@ class ComparisonOperator(enum.Enum):
             return '<='
         if self == self.EQ:
             return '=='
+        if self == self.NE:
+            return '!='
         if self == self.GT:
             return '>'
         if self == self.GE: