pixeltable 0.2.17__py3-none-any.whl → 0.2.19__py3-none-any.whl

pixeltable/exprs/compound_predicate.py

@@ -9,6 +9,7 @@ from .data_row import DataRow
 from .expr import Expr
 from .globals import LogicalOperator
 from .row_builder import RowBuilder
+from .sql_element_cache import SqlElementCache
 import pixeltable.type_system as ts
 
 
@@ -66,8 +67,8 @@ class CompoundPredicate(Expr):
         non_matches = [op for op in self.components if not condition(op)]
         return (matches, self.make_conjunction(non_matches))
 
-    def sql_expr(self) -> Optional[sql.ClauseElement]:
-        sql_exprs = [op.sql_expr() for op in self.components]
+    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
+        sql_exprs = [sql_elements.get(op) for op in self.components]
         if any(e is None for e in sql_exprs):
             return None
         if self.operator == LogicalOperator.NOT:

pixeltable/exprs/data_row.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import datetime
 import io
 import urllib.parse
 import urllib.request
@@ -8,8 +9,11 @@ from typing import Optional, List, Any, Tuple
 import sqlalchemy as sql
 import pgvector.sqlalchemy
 import PIL
+import PIL.Image
 import numpy as np
 
+from pixeltable import env
+
 
 class DataRow:
     """
@@ -101,6 +105,7 @@ class DataRow:
 
     def __getitem__(self, index: object) -> Any:
         """Returns in-memory value, ie, what is needed for expr evaluation"""
+        assert isinstance(index, int)
         if not self.has_val[index]:
             # for debugging purposes
             pass
@@ -115,7 +120,7 @@ class DataRow:
 
         return self.vals[index]
 
-    def get_stored_val(self, index: object, sa_col_type: Optional[sql.types.TypeEngine] = None) -> Any:
+    def get_stored_val(self, index: int, sa_col_type: Optional[sql.types.TypeEngine] = None) -> Any:
         """Return the value that gets stored in the db"""
         assert self.excs[index] is None
         if not self.has_val[index]:
@@ -140,12 +145,17 @@ class DataRow:
         if self.vals[index] is None and sa_col_type is not None and isinstance(sa_col_type, sql.JSON):
             return sql.sql.null()
 
+        if isinstance(self.vals[index], datetime.datetime) and self.vals[index].tzinfo is None:
+            # if the datetime is naive, cast it to the default time zone
+            return self.vals[index].replace(tzinfo=env.Env.get().default_time_zone)
+
         return self.vals[index]
 
     def __setitem__(self, idx: object, val: Any) -> None:
         """Assign in-memory cell value
         This allows overwriting
         """
+        assert isinstance(idx, int)
         assert self.excs[idx] is None
 
         if (idx in self.img_slot_idxs or idx in self.media_slot_idxs) and isinstance(val, str):
@@ -177,7 +187,7 @@ class DataRow:
             self.vals[idx] = val
         self.has_val[idx] = True
 
-    def set_file_path(self, idx: object, path: str) -> None:
+    def set_file_path(self, idx: int, path: str) -> None:
         """Augment an existing url with a local file path"""
         assert self.has_val[idx]
         assert idx in self.img_slot_idxs or idx in self.media_slot_idxs
@@ -185,7 +195,7 @@ class DataRow:
         if idx in self.media_slot_idxs:
             self.vals[idx] = path
 
-    def flush_img(self, index: object, filepath: Optional[str] = None) -> None:
+    def flush_img(self, index: int, filepath: Optional[str] = None) -> None:
         """Discard the in-memory value and save it to a local file, if filepath is not None"""
         if self.vals[index] is None:
             return
@@ -195,7 +205,12 @@ class DataRow:
                 # we want to save this to a file
                 self.file_paths[index] = filepath
                 self.file_urls[index] = urllib.parse.urljoin('file:', urllib.request.pathname2url(filepath))
-                self.vals[index].save(filepath, format='JPEG')
+                image = self.vals[index]
+                assert isinstance(image, PIL.Image.Image)
+                # Default to JPEG unless the image has a transparency layer (which isn't supported by JPEG).
+                # In that case, use WebP instead.
+                format = 'webp' if image.has_transparency_data else 'jpeg'
+                image.save(filepath, format=format)
             else:
                 # we discard the content of this cell
                 self.has_val[index] = False

pixeltable/exprs/expr.py

@@ -7,10 +7,11 @@ import inspect
 import json
 import sys
 import typing
-from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Type, TypeVar, Union, overload
+from typing import TYPE_CHECKING, Any, Callable, Iterator, Optional, TypeVar, Union, overload
 from uuid import UUID
 
 import sqlalchemy as sql
+from typing_extensions import Self
 
 import pixeltable
 import pixeltable.catalog as catalog
@@ -21,6 +22,8 @@ import pixeltable.type_system as ts
 from .data_row import DataRow
 from .globals import ArithmeticOperator, ComparisonOperator, LiteralPythonTypes, LogicalOperator
 
+if TYPE_CHECKING:
+    from pixeltable import exprs
 
 class ExprScope:
     """
@@ -49,23 +52,31 @@ class Expr(abc.ABC):
     - during eval(), components can only be accessed via self.components; any Exprs outside of that won't
       have slot_idx set
     """
-    def __init__(self, col_type: ts.ColumnType):
-        self.col_type = col_type
 
-        # each instance has an id that is used for equality comparisons
-        # - set by the subclass's __init__()
-        # - produced by _create_id()
-        # - not expected to survive a serialize()/deserialize() roundtrip
-        self.id: Optional[int] = None
+    col_type: ts.ColumnType
+
+    # the subexprs are needed to construct this expr
+    components: list[Expr]
+
+    # each instance has an id that is used for equality comparisons
+    # - set by the subclass's __init__()
+    # - produced by _create_id()
+    # - not expected to survive a serialize()/deserialize() roundtrip
+    id: Optional[int]
 
-        # index of the expr's value in the data row:
-        # - set for all materialized exprs
-        # - None: not executable
-        # - not set for subexprs that don't need to be materialized because the parent can be materialized via SQL
-        self.slot_idx: Optional[int] = None
-        self.components: List[Expr] = []  # the subexprs that are needed to construct this expr
+    # index of the expr's value in the data row:
+    # - set for all materialized exprs
+    # - None: not executable
+    # - not set for subexprs that don't need to be materialized because the parent can be materialized via SQL
+    slot_idx: Optional[int]
+
+    def __init__(self, col_type: ts.ColumnType):
+        self.col_type = col_type
+        self.components = []
+        self.id = None
+        self.slot_idx = None
 
-    def dependencies(self) -> List[Expr]:
+    def dependencies(self) -> list[Expr]:
         """
         Returns all exprs that need to have been evaluated before eval() can be called on this one.
         """
@@ -115,7 +126,7 @@ class Expr(abc.ABC):
         # override this
         return True
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         """Returns attribute name/value pairs that are used to construct the instance id.
 
         Attribute values must be immutable and have str() defined.
@@ -137,7 +148,7 @@ class Expr(abc.ABC):
         return self.id
 
     @classmethod
-    def list_equals(cls, a: List[Expr], b: List[Expr]) -> bool:
+    def list_equals(cls, a: list[Expr], b: list[Expr]) -> bool:
         if len(a) != len(b):
             return False
         for i in range(len(a)):
@@ -158,7 +169,7 @@ class Expr(abc.ABC):
         return result
 
     @classmethod
-    def copy_list(cls, expr_list: Optional[List[Expr]]) -> Optional[List[Expr]]:
+    def copy_list(cls, expr_list: Optional[list[Expr]]) -> Optional[list[Expr]]:
         if expr_list is None:
             return None
         return [e.copy() for e in expr_list]
@@ -183,11 +194,11 @@ class Expr(abc.ABC):
         return self
 
     @classmethod
-    def list_substitute(cls, expr_list: List[Expr], spec: dict[Expr, Expr]) -> None:
+    def list_substitute(cls, expr_list: list[Expr], spec: dict[Expr, Expr]) -> None:
         for i in range(len(expr_list)):
             expr_list[i] = expr_list[i].substitute(spec)
 
-    def resolve_computed_cols(self, resolve_cols: Optional[Set[catalog.Column]] = None) -> Expr:
+    def resolve_computed_cols(self, resolve_cols: Optional[set[catalog.Column]] = None) -> Expr:
         """
         Recursively replace ColRefs to unstored computed columns with their value exprs.
         Also replaces references to stored computed columns in resolve_cols.
@@ -215,12 +226,12 @@ class Expr(abc.ABC):
                 return False
         return True
 
-    def retarget(self, tbl: catalog.TableVersionPath) -> Expr:
+    def retarget(self, tbl: catalog.TableVersionPath) -> Self:
         """Retarget ColumnRefs in this expr to the specific TableVersions in tbl."""
         tbl_versions = {tbl_version.id: tbl_version for tbl_version in tbl.get_tbl_versions()}
         return self._retarget(tbl_versions)
 
-    def _retarget(self, tbl_versions: Dict[UUID, catalog.TableVersion]) -> Expr:
+    def _retarget(self, tbl_versions: dict[UUID, catalog.TableVersion]) -> Self:
         from .column_ref import ColumnRef
         if isinstance(self, ColumnRef):
             target = tbl_versions[self.col.tbl.id]
@@ -299,7 +310,7 @@ class Expr(abc.ABC):
         for e in expr_list:
             yield from e.subexprs(expr_class=expr_class, filter=filter, traverse_matches=traverse_matches)
 
-    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.
         """
@@ -312,15 +323,15 @@ class Expr(abc.ABC):
         except StopIteration:
             return False
 
-    def tbl_ids(self) -> Set[UUID]:
+    def tbl_ids(self) -> set[UUID]:
         """Returns table ids referenced by this expr."""
         from .column_ref import ColumnRef
         from .rowid_ref import RowidRef
         return {ref.col.tbl.id for ref in self.subexprs(ColumnRef)} | {ref.tbl.id for ref in self.subexprs(RowidRef)}
 
     @classmethod
-    def list_tbl_ids(cls, expr_list: List[Expr]) -> Set[UUID]:
-        ids: Set[UUID] = set()
+    def list_tbl_ids(cls, expr_list: list[Expr]) -> set[UUID]:
+        ids: set[UUID] = set()
         for e in expr_list:
             ids.update(e.tbl_ids())
         return ids
@@ -345,15 +356,14 @@ class Expr(abc.ABC):
         """
         if isinstance(o, Expr):
             return o
-        # Try to create a literal. We need to check for InlineArray/InlineDict
-        # first, to prevent arrays from inappropriately being interpreted as JsonType
+        # Try to create a literal. We need to check for InlineList/InlineDict
+        # first, to prevent them 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))
+            from .inline_expr import InlineList
+            return InlineList(o)
         if isinstance(o, dict):
-            from .inline_dict import InlineDict
+            from .inline_expr import InlineDict
             return InlineDict(o)
         obj_type = ts.ColumnType.infer_literal_type(o)
         if obj_type is not None:
@@ -362,7 +372,7 @@ class Expr(abc.ABC):
         return None
 
     @abc.abstractmethod
-    def sql_expr(self) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, sql_elements: 'exprs.SqlElementCache') -> Optional[sql.ColumnElement]:
         """
         If this expr can be materialized directly in SQL:
         - returns a ColumnElement
@@ -389,14 +399,14 @@ class Expr(abc.ABC):
             c.release()
 
     @classmethod
-    def release_list(cls, expr_list: List[Expr]) -> None:
+    def release_list(cls, expr_list: list[Expr]) -> None:
         for e in expr_list:
             e.release()
 
     def serialize(self) -> str:
         return json.dumps(self.as_dict())
 
-    def as_dict(self) -> Dict:
+    def as_dict(self) -> dict:
         """
         Turn Expr object into a dict that can be passed to json.dumps().
         Subclasses override _as_dict().
@@ -407,10 +417,10 @@ class Expr(abc.ABC):
         }
 
     @classmethod
-    def as_dict_list(self, expr_list: List[Expr]) -> List[Dict]:
+    def as_dict_list(self, expr_list: list[Expr]) -> list[dict]:
         return [e.as_dict() for e in expr_list]
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         if len(self.components) > 0:
             return {'components': [c.as_dict() for c in self.components]}
         return {}
@@ -420,24 +430,24 @@ class Expr(abc.ABC):
         return cls.from_dict(json.loads(dict_str))
 
     @classmethod
-    def from_dict(cls, d: Dict) -> Expr:
+    def from_dict(cls, d: dict) -> Self:
         """
         Turn dict that was produced by calling Expr.as_dict() into an instance of the correct Expr subclass.
         """
         assert '_classname' in d
         exprs_module = importlib.import_module(cls.__module__.rsplit('.', 1)[0])
         type_class = getattr(exprs_module, d['_classname'])
-        components: List[Expr] = []
+        components: list[Expr] = []
         if 'components' in d:
             components = [cls.from_dict(component_dict) for component_dict in d['components']]
         return type_class._from_dict(d, components)
 
     @classmethod
-    def from_dict_list(cls, dict_list: List[Dict]) -> List[Expr]:
+    def from_dict_list(cls, dict_list: list[dict]) -> list[Expr]:
         return [cls.from_dict(d) for d in dict_list]
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> Self:
         assert False, 'not implemented'
 
     def isin(self, value_set: Any) -> 'pixeltable.exprs.InPredicate':

pixeltable/exprs/expr_set.py

@@ -1,25 +1,36 @@
 from __future__ import annotations
-from typing import Optional, Dict, Iterable, Iterator
+
+from typing import Optional, Iterable, Iterator
 
 from .expr import Expr
 
 
 class ExprSet:
-    """A set that also supports indexed lookup (by slot_idx and Expr.id)"""
+    """
+    A set that also supports indexed lookup (by slot_idx and Expr.id). Exprs are uniquely identified by Expr.id.
+    """
+    exprs: dict[int, Expr]  # key: Expr.id
+    exprs_by_idx: dict[int, Expr]  # key: slot_idx
+
     def __init__(self, elements: Optional[Iterable[Expr]] = None):
-        self.exprs: Dict[int, Expr] = {}  # Expr.id -> Expr
+        self.exprs = {}
+        self.exprs_by_idx = {}
         if elements is not None:
             for e in elements:
-                self.append(e)
+                self.add(e)
 
-    def append(self, expr: Expr) -> None:
+    def add(self, expr: Expr) -> None:
         if expr.id in self.exprs:
             return
         self.exprs[expr.id] = expr
+        if expr.slot_idx is None:
+            return
+        self.exprs_by_idx[expr.slot_idx] = expr
 
-    def extend(self, elements: Iterable[Expr]) -> None:
-        for e in elements:
-            self.append(e)
+    def update(self, *others: Iterable[Expr]) -> None:
+        for other in others:
+            for e in other:
+                self.add(e)
 
     def __contains__(self, item: Expr) -> bool:
         return item.id in self.exprs
@@ -31,9 +42,21 @@ class ExprSet:
         return iter(self.exprs.values())
 
     def __getitem__(self, index: object) -> Optional[Expr]:
+        """Indexed lookup by slot_idx or Expr.id."""
+        if not isinstance(index, int) and not isinstance(index, Expr):
+            pass
         assert isinstance(index, int) or isinstance(index, Expr)
         if isinstance(index, int):
             # return expr with matching slot_idx
-            return list(self.exprs.values())[index]
+            return self.exprs_by_idx.get(index)
         else:
             return self.exprs.get(index.id)
+
+    def issuperset(self, other: ExprSet) -> bool:
+        return self.exprs.keys() >= other.exprs.keys()
+
+    def __ge__(self, other: ExprSet) -> bool:
+        return self.issuperset(other)
+
+    def __le__(self, other: ExprSet) -> bool:
+        return other.issuperset(self)

pixeltable/exprs/function_call.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import inspect
 import json
 import sys
-from typing import Optional, List, Any, Dict, Tuple
+from typing import Any, Optional
 
 import sqlalchemy as sql
 
@@ -11,34 +11,40 @@ import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
 import pixeltable.func as func
 import pixeltable.type_system as ts
+
 from .data_row import DataRow
 from .expr import Expr
-from .inline_array import InlineArray
-from .inline_dict import InlineDict
+from .inline_expr import InlineDict, InlineList
 from .row_builder import RowBuilder
 from .rowid_ref import RowidRef
+from .sql_element_cache import SqlElementCache
 
 
 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]
+    agg_init_args: dict[str, Any]
+
+    # tuple[Optional[int], Optional[Any]]:
+    # - for Exprs: (index into components, None)
+    # - otherwise: (None, val)
+    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]]
+    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):
+            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):
         if order_by_clause is None:
             order_by_clause = []
         if group_by_clause is None:
@@ -47,7 +53,7 @@ class FunctionCall(Expr):
         super().__init__(fn.call_return_type(bound_args))
         self.fn = fn
         self.is_method_call = is_method_call
-        self.normalize_args(signature, bound_args)
+        self.normalize_args(fn.name, signature, bound_args)
 
         self.agg_init_args = {}
         if self.is_agg_fn_call:
@@ -58,10 +64,6 @@ 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
-
-        # Tuple[int, Any]:
-        # - for Exprs: (index into components, None)
-        # - otherwise: (None, val)
         self.args = []
         self.kwargs = {}
 
@@ -131,7 +133,7 @@ class FunctionCall(Expr):
 
         self.id = self._create_id()
 
-    def _create_rowid_refs(self, tbl: catalog.Table) -> List[Expr]:
+    def _create_rowid_refs(self, tbl: catalog.Table) -> list[Expr]:
         target = tbl._tbl_version_path.tbl_version
         return [RowidRef(target, i) for i in range(target.num_rowid_columns())]
 
@@ -141,7 +143,7 @@ class FunctionCall(Expr):
         return super().default_column_name()
 
     @classmethod
-    def normalize_args(cls, signature: func.Signature, bound_args: Dict[str, Any]) -> None:
+    def normalize_args(cls, fn_name: str, signature: func.Signature, bound_args: dict[str, Any]) -> None:
         """Converts all args to Exprs and checks that they are compatible with signature.
 
         Updates bound_args in place, where necessary.
@@ -161,9 +163,7 @@ class FunctionCall(Expr):
 
             if isinstance(arg, list) or isinstance(arg, tuple):
                 try:
-                    # If the column type is JsonType, force the literal to be JSON
-                    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)
+                    arg = InlineList(arg)
                     bound_args[param_name] = arg
                     continue
                 except excs.Error:
@@ -175,7 +175,7 @@ class FunctionCall(Expr):
                 try:
                     _ = json.dumps(arg)
                 except TypeError:
-                    raise excs.Error(f'Argument for parameter {param_name!r} is not json-serializable: {arg}')
+                    raise excs.Error(f'Argument for parameter {param_name!r} is not json-serializable: {arg} (of type {type(arg)})')
                 if arg is not None:
                     try:
                         param_type = param.col_type
@@ -213,7 +213,7 @@ class FunctionCall(Expr):
                     or (arg.col_type.is_json_type() and param.col_type.is_scalar_type())
                 ):
                     raise excs.Error(
-                        f'Parameter {param_name}: argument type {arg.col_type} does not match parameter type '
+                        f'Parameter {param_name} (in function {fn_name}): argument type {arg.col_type} does not match parameter type '
                         f'{param.col_type}')
 
     def _equals(self, other: FunctionCall) -> bool:
@@ -232,7 +232,7 @@ class FunctionCall(Expr):
             return False
         return True
 
-    def _id_attrs(self) -> List[Tuple[str, Any]]:
+    def _id_attrs(self) -> list[tuple[str, Any]]:
         return super()._id_attrs() + [
             ('fn', id(self.fn)),  # use the function pointer, not the fqn, which isn't set for lambdas
             ('args', self.args),
@@ -253,11 +253,11 @@ class FunctionCall(Expr):
             return f'{fn_name}({self._print_args()})'
 
     def _print_args(self, start_idx: int = 0, inline: bool = True) -> str:
+        def print_arg(arg: Any) -> str:
+            return repr(arg) if isinstance(arg, str) else str(arg)
         arg_strs = [
-            str(arg) if idx is None else str(self.components[idx]) for idx, arg in self.args[start_idx:]
+            print_arg(arg) if idx is None else str(self.components[idx]) for idx, arg in self.args[start_idx:]
         ]
-        def print_arg(arg: Any) -> str:
-            return f"'{arg}'" if isinstance(arg, str) else str(arg)
         arg_strs.extend([
             f'{param_name}={print_arg(arg) if idx is None else str(self.components[idx])}'
             for param_name, (idx, arg) in self.kwargs.items()
@@ -273,15 +273,15 @@ class FunctionCall(Expr):
         separator = ', ' if inline else ',\n    '
         return separator.join(arg_strs)
 
-    def has_group_by(self) -> List[Expr]:
+    def has_group_by(self) -> list[Expr]:
         return self.group_by_stop_idx != 0
 
     @property
-    def group_by(self) -> List[Expr]:
+    def group_by(self) -> list[Expr]:
         return self.components[self.group_by_start_idx:self.group_by_stop_idx]
 
     @property
-    def order_by(self) -> List[Expr]:
+    def order_by(self) -> list[Expr]:
         return self.components[self.order_by_start_idx:]
 
     @property
@@ -291,20 +291,42 @@ class FunctionCall(Expr):
              or self.has_group_by() \
              or (len(self.order_by) > 0 and not self.fn.requires_order_by))
 
-    def get_window_sort_exprs(self) -> Tuple[List[Expr], List[Expr]]:
+    def get_window_sort_exprs(self) -> tuple[list[Expr], list[Expr]]:
         return self.group_by, self.order_by
 
     @property
     def is_agg_fn_call(self) -> bool:
         return isinstance(self.fn, func.AggregateFunction)
 
-    def get_agg_order_by(self) -> List[Expr]:
+    def get_agg_order_by(self) -> list[Expr]:
         assert self.is_agg_fn_call
         return self.order_by
 
-    def sql_expr(self) -> Optional[sql.ClauseElement]:
-        # TODO: implement for standard aggregate functions
-        return None
+    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
+        # try to construct args and kwargs to call self.fn._to_sql()
+        kwargs: dict[str, sql.ColumnElement] = {}
+        for param_name, (component_idx, arg) in self.kwargs.items():
+            param = self.fn.signature.parameters[param_name]
+            assert param.kind != inspect.Parameter.VAR_POSITIONAL and param.kind != inspect.Parameter.VAR_KEYWORD
+            if component_idx is None:
+                kwargs[param_name] = sql.literal(arg)
+            else:
+                arg_element = sql_elements.get(self.components[component_idx])
+                if arg_element is None:
+                    return None
+                kwargs[param_name] = arg_element
+
+        args: list[sql.ColumnElement] = []
+        for _, (component_idx, arg) in enumerate(self.args):
+            if component_idx is None:
+                args.append(sql.literal(arg))
+            else:
+                arg_element = sql_elements.get(self.components[component_idx])
+                if arg_element is None:
+                    return None
+                args.append(arg_element)
+        result = self.fn._to_sql(*args, **kwargs)
+        return result
 
     def reset_agg(self) -> None:
         """
@@ -322,9 +344,9 @@ class FunctionCall(Expr):
         args, kwargs = self._make_args(data_row)
         self.aggregator.update(*args, **kwargs)
 
-    def _make_args(self, data_row: DataRow) -> Tuple[List[Any], Dict[str, Any]]:
+    def _make_args(self, data_row: DataRow) -> tuple[list[Any], dict[str, Any]]:
         """Return args and kwargs, constructed for data_row"""
-        kwargs: Dict[str, Any] = {}
+        kwargs: dict[str, Any] = {}
         for param_name, (component_idx, arg) in self.kwargs.items():
             val = arg if component_idx is None else data_row[self.components[component_idx].slot_idx]
             param = self.fn.signature.parameters[param_name]
@@ -335,7 +357,7 @@ class FunctionCall(Expr):
                 assert param.kind != inspect.Parameter.VAR_POSITIONAL
                 kwargs[param_name] = val
 
-        args: List[Any] = []
+        args: list[Any] = []
         for param_idx, (component_idx, arg) in enumerate(self.args):
             val = arg if component_idx is None else data_row[self.components[component_idx].slot_idx]
             param = self.fn.signature.parameters_by_pos[param_idx]
@@ -393,7 +415,7 @@ class FunctionCall(Expr):
         else:
             data_row[self.slot_idx] = self.fn.exec(*args, **kwargs)
 
-    def _as_dict(self) -> Dict:
+    def _as_dict(self) -> dict:
         result = {
             'fn': self.fn.as_dict(), 'args': self.args, 'kwargs': self.kwargs,
             'group_by_start_idx': self.group_by_start_idx, 'group_by_stop_idx': self.group_by_stop_idx,
@@ -403,7 +425,7 @@ class FunctionCall(Expr):
         return result
 
     @classmethod
-    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+    def _from_dict(cls, d: dict, components: list[Expr]) -> Expr:
         assert 'fn' in d
         assert 'args' in d
         assert 'kwargs' in d