pixeltable 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

pixeltable/exprs/json_mapper.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 import sqlalchemy as sql
 
@@ -11,6 +11,9 @@ from .expr import _GLOBAL_SCOPE, Expr, ExprScope
 from .row_builder import RowBuilder
 from .sql_element_cache import SqlElementCache
 
+if TYPE_CHECKING:
+    from .object_ref import ObjectRef
+
 
 class JsonMapper(Expr):
     """
@@ -19,6 +22,10 @@ class JsonMapper(Expr):
     is populated by JsonMapper.eval(). The JsonMapper effectively creates a new scope for its target expr.
     """
 
+    target_expr_scope: ExprScope
+    parent_mapper: Optional[JsonMapper]
+    target_expr_eval_ctx: Optional[RowBuilder.EvalCtx]
+
     def __init__(self, src_expr: Expr, target_expr: Expr):
         # TODO: type spec should be list[target_expr.col_type]
         super().__init__(ts.JsonType())
@@ -29,12 +36,18 @@ class JsonMapper(Expr):
 
         from .object_ref import ObjectRef
 
-        scope_anchor = ObjectRef(self.target_expr_scope, self)
-        self.components = [src_expr, target_expr, scope_anchor]
-        self.parent_mapper: Optional[JsonMapper] = None
-        self.target_expr_eval_ctx: Optional[RowBuilder.EvalCtx] = None
+        self.components = [src_expr, target_expr]
+        self.parent_mapper = None
+        self.target_expr_eval_ctx = None
+
+        # Intentionally create the id now, before adding the scope anchor; this ensures that JsonMappers will
+        # be recognized as equal so long as they have the same src_expr and target_expr.
+        # TODO: Might this cause problems after certain substitutions?
         self.id = self._create_id()
 
+        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)
@@ -84,8 +97,12 @@ class JsonMapper(Expr):
         return self.components[1]
 
     @property
-    def scope_anchor(self) -> Expr:
-        return self.components[2]
+    def scope_anchor(self) -> 'ObjectRef':
+        from .object_ref import ObjectRef
+
+        result = self.components[2]
+        assert isinstance(result, ObjectRef)
+        return result
 
     def _equals(self, _: JsonMapper) -> bool:
         return True
@@ -107,7 +124,7 @@ class JsonMapper(Expr):
         for i, val in enumerate(src):
             data_row[self.scope_anchor.slot_idx] = val
             # stored target_expr
-            row_builder.eval(data_row, self.target_expr_eval_ctx)
+            row_builder.eval(data_row, self.target_expr_eval_ctx, force_eval=self._target_expr.scope())
             result[i] = data_row[self._target_expr.slot_idx]
         data_row[self.slot_idx] = result
 

pixeltable/exprs/json_path.py

@@ -43,11 +43,11 @@ class JsonPath(Expr):
         self.id = self._create_id()
 
     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()}'
-        )
+        # else 'R': the anchor is RELATIVE_PATH_ROOT
+        anchor_str = str(self._anchor) if self._anchor is not None else 'R'
+        if len(self.path_elements) == 0:
+            return anchor_str
+        return f'{anchor_str}{"." if isinstance(self.path_elements[0], str) else ""}{self._json_path()}'
 
     def _as_dict(self) -> dict:
         path_elements = [[el.start, el.stop, el.step] if isinstance(el, slice) else el for el in self.path_elements]
@@ -158,6 +158,7 @@ class JsonPath(Expr):
         return ''.join(result)
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        assert self._anchor is not None, self
         val = data_row[self._anchor.slot_idx]
         if self.compiled_path is not None:
             val = self.compiled_path.search(val)

pixeltable/exprs/object_ref.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional
+from typing import Any, Optional
 
 import sqlalchemy as sql
 
@@ -26,14 +26,22 @@ class ObjectRef(Expr):
         self.owner = owner
         self.id = self._create_id()
 
+    def _id_attrs(self) -> list[tuple[str, Any]]:
+        # We have no components, so we can't rely on the default behavior here (otherwise, all ObjectRef
+        # instances will be conflated into a single slot).
+        return [('addr', id(self))]
+
+    def substitute(self, subs: dict[Expr, Expr]) -> Expr:
+        # Just return self; we need to avoid creating a new id after doing the substitution, because otherwise
+        # we'll wind up in a situation where the scope_anchor of the enclosing JsonMapper is different from the
+        # nested ObjectRefs inside its target_expr (and therefore occupies a different slot_idx).
+        return self
+
     def scope(self) -> ExprScope:
         return self._scope
 
-    def __str__(self) -> str:
-        assert False
-
     def _equals(self, other: ObjectRef) -> bool:
-        return self.owner is other.owner
+        return self.id == other.id
 
     def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
         return None
@@ -41,3 +49,6 @@ class ObjectRef(Expr):
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         # this will be called, but the value has already been materialized elsewhere
         pass
+
+    def __repr__(self) -> str:
+        return f'ObjectRef({self.owner}, {self.id}, {self.owner.id})'

pixeltable/exprs/row_builder.py

@@ -17,7 +17,7 @@ from pixeltable.env import Env
 from pixeltable.utils.media_store import MediaStore
 
 from .data_row import DataRow
-from .expr import Expr
+from .expr import Expr, ExprScope
 from .expr_set import ExprSet
 
 
@@ -299,6 +299,7 @@ class RowBuilder:
                 # this is input and therefore doesn't depend on other exprs
                 continue
             for d in expr.dependencies():
+                assert d.slot_idx is not None, f'{expr}, {d}'
                 if d.slot_idx in excluded_slot_idxs:
                     continue
                 dependencies[expr.slot_idx].add(d.slot_idx)
@@ -376,7 +377,12 @@ class RowBuilder:
             data_row.set_exc(slot_idx, exc)
 
     def eval(
-        self, data_row: DataRow, ctx: EvalCtx, profile: Optional[ExecProfile] = None, ignore_errors: bool = False
+        self,
+        data_row: DataRow,
+        ctx: EvalCtx,
+        profile: Optional[ExecProfile] = None,
+        ignore_errors: bool = False,
+        force_eval: Optional[ExprScope] = None,
     ) -> None:
         """
         Populates the slots in data_row given in ctx.
@@ -384,10 +390,11 @@ class RowBuilder:
         and omits any of that expr's dependents's eval().
         profile: if present, populated with execution time of each expr.eval() call; indexed by expr.slot_idx
         ignore_errors: if False, raises ExprEvalError if any expr.eval() raises an exception
+        force_eval: forces exprs in the specified scope to be reevaluated, even if they already have a value
         """
         for expr in ctx.exprs:
             assert expr.slot_idx >= 0
-            if data_row.has_val[expr.slot_idx] or data_row.has_exc(expr.slot_idx):
+            if expr.scope() != force_eval and (data_row.has_val[expr.slot_idx] or data_row.has_exc(expr.slot_idx)):
                 continue
             try:
                 start_time = time.perf_counter()

pixeltable/func/aggregate_function.py

@@ -12,7 +12,7 @@ from .globals import validate_symbol_path
 from .signature import Parameter, Signature
 
 if TYPE_CHECKING:
-    import pixeltable
+    from pixeltable import exprs
 
 
 class Aggregator(abc.ABC):
@@ -80,6 +80,8 @@ class AggregateFunction(Function):
         """Inspects the Aggregator class to infer the corresponding function signature. Returns the
         inferred signature along with the list of init_param_names (for downstream error handling).
         """
+        from pixeltable import exprs
+
         # infer type parameters; set return_type=InvalidType() because it has no meaning here
         init_sig = Signature.create(
             py_fn=cls.__init__, return_type=ts.InvalidType(), is_cls_method=True, type_substitutions=type_substitutions
@@ -102,14 +104,24 @@ class AggregateFunction(Function):
         py_update_params = list(inspect.signature(cls.update).parameters.values())[1:]  # leave out self
         assert len(py_update_params) == len(update_types)
         update_params = [
-            Parameter(p.name, col_type=update_types[i], kind=p.kind, default=p.default)
+            Parameter(
+                p.name,
+                col_type=update_types[i],
+                kind=p.kind,
+                default=exprs.Expr.from_object(p.default),  # type: ignore[arg-type]
+            )
             for i, p in enumerate(py_update_params)
         ]
         # starting at 1: leave out self
         py_init_params = list(inspect.signature(cls.__init__).parameters.values())[1:]
         assert len(py_init_params) == len(init_types)
         init_params = [
-            Parameter(p.name, col_type=init_types[i], kind=inspect.Parameter.KEYWORD_ONLY, default=p.default)
+            Parameter(
+                p.name,
+                col_type=init_types[i],
+                kind=inspect.Parameter.KEYWORD_ONLY,
+                default=exprs.Expr.from_object(p.default),  # type: ignore[arg-type]
+            )
             for i, p in enumerate(py_init_params)
         ]
         duplicate_params = set(p.name for p in init_params) & set(p.name for p in update_params)
@@ -157,7 +169,7 @@ class AggregateFunction(Function):
         res += '\n\n' + inspect.getdoc(self.agg_classes[0].update)
         return res
 
-    def __call__(self, *args: object, **kwargs: object) -> 'pixeltable.exprs.FunctionCall':
+    def __call__(self, *args: Any, **kwargs: Any) -> 'exprs.FunctionCall':
         from pixeltable import exprs
 
         # perform semantic analysis of special parameters 'order_by' and 'group_by'
@@ -194,29 +206,31 @@ class AggregateFunction(Function):
                 )
             group_by_clause = kwargs.pop(self.GROUP_BY_PARAM)
 
+        args = [exprs.Expr.from_object(arg) for arg in args]
+        kwargs = {k: exprs.Expr.from_object(v) for k, v in kwargs.items()}
+
         resolved_fn, bound_args = self._bind_to_matching_signature(args, kwargs)
-        return_type = resolved_fn.call_return_type(args, kwargs)
+        return_type = resolved_fn.call_return_type(bound_args)
+
         return exprs.FunctionCall(
             resolved_fn,
-            bound_args,
+            args,
+            kwargs,
             return_type,
             order_by_clause=[order_by_clause] if order_by_clause is not None else [],
             group_by_clause=[group_by_clause] if group_by_clause is not None else [],
         )
 
-    def validate_call(self, bound_args: dict[str, Any]) -> None:
-        # check that init parameters are not Exprs
-        # TODO: do this in the planner (check that init parameters are either constants or only refer to grouping exprs)
+    def validate_call(self, bound_args: dict[str, 'exprs.Expr']) -> None:
         from pixeltable import exprs
 
-        assert not self.is_polymorphic
+        super().validate_call(bound_args)
 
+        # check that init parameters are not Exprs
+        # TODO: do this in the planner (check that init parameters are either constants or only refer to grouping exprs)
         for param_name in self.init_param_names[0]:
-            if param_name in bound_args and isinstance(bound_args[param_name], exprs.Expr):
-                raise excs.Error(
-                    f'{self.display_name}(): init() parameter {param_name} needs to be a constant, not a Pixeltable '
-                    f'expression'
-                )
+            if param_name in bound_args and not isinstance(bound_args[param_name], exprs.Literal):
+                raise excs.Error(f'{self.display_name}(): init() parameter {param_name!r} must be a constant value')
 
     def __repr__(self) -> str:
         return f'<Pixeltable Aggregator {self.name}>'

pixeltable/func/callable_function.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import inspect
-from typing import Any, Callable, Optional, Sequence
+from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence
 from uuid import UUID
 
 import cloudpickle  # type: ignore[import-untyped]
@@ -12,6 +12,9 @@ import pixeltable.exceptions as excs
 from .function import Function
 from .signature import Signature
 
+if TYPE_CHECKING:
+    from pixeltable import exprs
+
 
 class CallableFunction(Function):
     """Pixeltable Function backed by a Python Callable.
@@ -192,18 +195,18 @@ class CallableFunction(Function):
         batch_size = md['batch_size']
         return CallableFunction([sig], [py_fn], self_name=name, batch_size=batch_size)
 
-    def validate_call(self, bound_args: dict[str, Any]) -> None:
+    def validate_call(self, bound_args: dict[str, 'exprs.Expr']) -> None:
         from pixeltable import exprs
 
-        assert not self.is_polymorphic
+        super().validate_call(bound_args)
         if self.is_batched:
             signature = self.signatures[0]
             for param in signature.constant_parameters:
-                if param.name in bound_args and isinstance(bound_args[param.name], exprs.Expr):
-                    raise ValueError(
-                        f'{self.display_name}(): '
-                        f'parameter {param.name} must be a constant value, not a Pixeltable expression'
-                    )
+                # Check that constant parameters map to constant arguments. It's ok for the argument to be a Variable,
+                # since in that case the FunctionCall is part of an unresolved template; the check will be done again
+                # when the template is fully resolved.
+                if param.name in bound_args and not isinstance(bound_args[param.name], (exprs.Literal, exprs.Variable)):
+                    raise ValueError(f'{self.display_name}(): parameter {param.name} must be a constant value')
 
     def __repr__(self) -> str:
         return f'<Pixeltable UDF {self.name}>'

pixeltable/func/expr_template_function.py

@@ -32,17 +32,11 @@ class ExprTemplate:
             assert var.name in self.param_exprs, f"Variable '{var.name}' in expression is not a parameter"
 
         # verify default values
-        self.defaults: dict[str, exprs.Literal] = {}  # key: param name, value: default value converted to a Literal
+        self.defaults: dict[str, exprs.Literal] = {}
         for param in self.signature.parameters.values():
-            if param.default is inspect.Parameter.empty:
+            if param.default is None:
                 continue
-            param_expr = self.param_exprs[param.name]
-            try:
-                literal_default = exprs.Literal(param.default, col_type=param_expr.col_type)
-                self.defaults[param.name] = literal_default
-            except TypeError as e:
-                msg = str(e)
-                raise excs.Error(f"Default value for parameter '{param.name}': {msg[0].lower() + msg[1:]}")
+            self.defaults[param.name] = param.default
 
 
 class ExprTemplateFunction(Function):

pixeltable/func/function.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import importlib
 import inspect
+import typing
 from abc import ABC, abstractmethod
 from copy import copy
 from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, cast
@@ -17,6 +18,8 @@ from .globals import resolve_symbol
 from .signature import Signature
 
 if TYPE_CHECKING:
+    from pixeltable import exprs
+
     from .expr_template_function import ExprTemplate, ExprTemplateFunction
 
 
@@ -152,9 +155,22 @@ class Function(ABC):
     def __call__(self, *args: Any, **kwargs: Any) -> 'pxt.exprs.FunctionCall':
         from pixeltable import exprs
 
+        args = [exprs.Expr.from_object(arg) for arg in args]
+        kwargs = {k: exprs.Expr.from_object(v) for k, v in kwargs.items()}
+
+        for i, expr in enumerate(args):
+            if expr is None:
+                raise excs.Error(f'Argument {i + 1} in call to {self.self_path!r} is not a valid Pixeltable expression')
+        for param_name, expr in kwargs.items():
+            if expr is None:
+                raise excs.Error(
+                    f'Argument {param_name!r} in call to {self.self_path!r} is not a valid Pixeltable expression'
+                )
+
         resolved_fn, bound_args = self._bind_to_matching_signature(args, kwargs)
-        return_type = resolved_fn.call_return_type(args, kwargs)
-        return exprs.FunctionCall(resolved_fn, bound_args, return_type)
+        return_type = resolved_fn.call_return_type(bound_args)
+
+        return exprs.FunctionCall(resolved_fn, args, kwargs, return_type)
 
     def _bind_to_matching_signature(self, args: Sequence[Any], kwargs: dict[str, Any]) -> tuple[Self, dict[str, Any]]:
         result: int = -1
@@ -185,49 +201,115 @@ class Function(ABC):
 
         signature = self.signatures[signature_idx]
         bound_args = signature.py_signature.bind(*args, **kwargs).arguments
-        self._resolved_fns[signature_idx].validate_call(bound_args)
-        exprs.FunctionCall.normalize_args(self.name, signature, bound_args)
-        return bound_args
+        normalized_args = {k: exprs.Expr.from_object(v) for k, v in bound_args.items()}
+        self._resolved_fns[signature_idx].validate_call(normalized_args)
+        return normalized_args
 
-    def validate_call(self, bound_args: dict[str, Any]) -> None:
+    def validate_call(self, bound_args: dict[str, Optional['exprs.Expr']]) -> None:
         """Override this to do custom validation of the arguments"""
         assert not self.is_polymorphic
+        self.signature.validate_args(bound_args, context=f'in function {self.name!r}')
 
-    def _get_callable_args(self, callable: Callable, kwargs: dict[str, Any]) -> dict[str, Any]:
-        """Return the kwargs to pass to callable, given kwargs passed to this function"""
-        bound_args = self.signature.py_signature.bind(**kwargs).arguments
-        # add defaults to bound_args, if not already present
-        bound_args.update(
-            {
-                name: param.default
-                for name, param in self.signature.parameters.items()
-                if name not in bound_args and param.has_default()
-            }
-        )
-        result: dict[str, Any] = {}
-        sig = inspect.signature(callable)
-        for param in sig.parameters.values():
-            if param.name in bound_args:
-                result[param.name] = bound_args[param.name]
-        return result
-
-    def call_resource_pool(self, kwargs: dict[str, Any]) -> str:
+    def call_resource_pool(self, bound_args: dict[str, 'exprs.Expr']) -> str:
         """Return the resource pool to use for calling this function with the given arguments"""
-        kw_args = self._get_callable_args(self._resource_pool, kwargs)
-        return self._resource_pool(**kw_args)
-
-    def call_return_type(self, args: Sequence[Any], kwargs: dict[str, Any]) -> ts.ColumnType:
+        rp_kwargs = self._assemble_callable_args(self._resource_pool, bound_args)
+        if rp_kwargs is None:
+            # TODO: What to do in this case? An example where this can happen is if model_id is not a constant
+            #   in a call to one of the OpenAI endpoints.
+            raise excs.Error('Could not determine resource pool')
+        return self._resource_pool(**rp_kwargs)
+
+    def call_return_type(self, bound_args: dict[str, 'exprs.Expr']) -> ts.ColumnType:
         """Return the type of the value returned by calling this function with the given arguments"""
-        assert not self.is_polymorphic
         if self._conditional_return_type is None:
-            return self.signature.return_type
-        bound_args = self.signature.py_signature.bind(*args, **kwargs).arguments
-        kw_args: dict[str, Any] = {}
-        sig = inspect.signature(self._conditional_return_type)
-        for param in sig.parameters.values():
+            # No conditional return type specified; use the default return type
+            return_type = self.signature.return_type
+        else:
+            crt_kwargs = self._assemble_callable_args(self._conditional_return_type, bound_args)
+            if crt_kwargs is None:
+                # A conditional return type is specified, but one of its arguments is not a constant.
+                # Use the default return type
+                return_type = self.signature.return_type
+            else:
+                # A conditional return type is specified and all its arguments are constants; use the specific
+                # call return type
+                return_type = self._conditional_return_type(**crt_kwargs)
+
+        if return_type.nullable:
+            return return_type
+
+        # If `return_type` is non-nullable, but the function call has a nullable input to any of its non-nullable
+        # parameters, then we need to make it nullable. This is because Pixeltable defaults a function output to
+        # `None` when any of its non-nullable inputs are `None`.
+        for arg_name, arg in bound_args.items():
+            param = self.signature.parameters[arg_name]
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                continue
+            if arg.col_type.nullable and not param.col_type.nullable:
+                return_type = return_type.copy(nullable=True)
+                break
+
+        return return_type
+
+    def _assemble_callable_args(
+        self, callable: Callable, bound_args: dict[str, 'exprs.Expr']
+    ) -> Optional[dict[str, Any]]:
+        """
+        Return the kwargs to pass to callable, given bound_args passed to this function.
+
+        This is used by `conditional_return_type` and `get_resource_pool` to determine call-specific characteristics
+        of this function.
+
+        In both cases, the specified `Callable` takes a subset of the parameters of this Function, which may
+        be typed as either `Expr`s or Python values. Any parameters typed as Python values expect to see constants
+        (Literals); if the corresponding entries in `bound_args` are not constants, then the return value is None.
+        """
+        from pixeltable import exprs
+
+        assert not self.is_polymorphic
+
+        callable_signature = inspect.signature(callable)
+        callable_type_hints = typing.get_type_hints(callable)
+        callable_args: dict[str, Any] = {}
+
+        for param in callable_signature.parameters.values():
+            assert param.name in self.signature.parameters
+
+            arg: exprs.Expr
             if param.name in bound_args:
-                kw_args[param.name] = bound_args[param.name]
-        return self._conditional_return_type(**kw_args)
+                arg = bound_args[param.name]
+            elif self.signature.parameters[param.name].has_default():
+                arg = self.signature.parameters[param.name].default
+            else:
+                # This parameter is missing from bound_args and has no default value, so return None.
+                return None
+            assert isinstance(arg, exprs.Expr)
+
+            expects_expr: Optional[type[exprs.Expr]] = None
+            type_hint = callable_type_hints.get(param.name)
+            if typing.get_origin(type_hint) is not None:
+                type_hint = typing.get_origin(type_hint)  # Remove type subscript if one exists
+            if isinstance(type_hint, type) and issubclass(type_hint, exprs.Expr):
+                # The callable expects an Expr for this parameter. We allow for the case where the
+                # callable requests a specific subtype of Expr.
+                expects_expr = type_hint
+
+            if expects_expr is not None:
+                # The callable is expecting `param.name` to be an Expr. Validate that it's of the appropriate type;
+                # otherwise return None.
+                if isinstance(arg, expects_expr):
+                    callable_args[param.name] = arg
+                else:
+                    return None
+            else:
+                # The callable is expecting `param.name` to be a constant Python value. Unpack a Literal if we find
+                # one; otherwise return None.
+                if isinstance(arg, exprs.Literal):
+                    callable_args[param.name] = arg.val
+                else:
+                    return None
+
+        return callable_args
 
     def conditional_return_type(self, fn: Callable[..., ts.ColumnType]) -> Callable[..., ts.ColumnType]:
         """Instance decorator for specifying a conditional return type for this function"""
@@ -280,18 +362,38 @@ class Function(ABC):
                 raise excs.Error(f'Unknown parameter: {k}')
             param = self.signature.parameters[k]
             expr = exprs.Expr.from_object(v)
+            if not isinstance(expr, exprs.Literal):
+                raise excs.Error(f'Expected a constant value for parameter {k!r} in call to .using()')
             if not param.col_type.is_supertype_of(expr.col_type):
-                raise excs.Error(f'Expected type `{param.col_type}` for parameter `{k}`; got `{expr.col_type}`')
-            bindings[k] = v  # Use the original value, not the Expr (The Expr is only for validation)
+                raise excs.Error(f'Expected type `{param.col_type}` for parameter {k!r}; got `{expr.col_type}`')
+            bindings[k] = expr
 
         residual_params = [p for p in self.signature.parameters.values() if p.name not in bindings]
 
-        # Bind each remaining parameter to a like-named variable
-        for param in residual_params:
-            bindings[param.name] = exprs.Variable(param.name, param.col_type)
-
-        return_type = self.call_return_type([], bindings)
-        call = exprs.FunctionCall(self, bindings, return_type)
+        # Bind each remaining parameter to a like-named variable.
+        # Also construct the call arguments for the template function call. Variables become args when possible;
+        # otherwise, they are passed as kwargs.
+        template_args: list[exprs.Expr] = []
+        template_kwargs: dict[str, exprs.Expr] = {}
+        args_ok = True
+        for name, param in self.signature.parameters.items():
+            if name in bindings:
+                template_kwargs[name] = bindings[name]
+                args_ok = False
+            else:
+                var = exprs.Variable(name, param.col_type)
+                bindings[name] = var
+                if args_ok and param.kind in (
+                    inspect.Parameter.POSITIONAL_ONLY,
+                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                ):
+                    template_args.append(var)
+                else:
+                    template_kwargs[name] = var
+                    args_ok = False
+
+        return_type = self.call_return_type(bindings)
+        call = exprs.FunctionCall(self, template_args, template_kwargs, return_type)
 
         # Construct the (n-k)-ary signature of the new function. We use `call.col_type` for this, rather than
         # `self.signature.return_type`, because the return type of the new function may be specialized via a
@@ -370,35 +472,7 @@ class Function(ABC):
         assert 'signature' in d and d['signature'] is not None
         instance = resolve_symbol(d['path'])
         assert isinstance(instance, Function)
-
-        # Load the signature from the DB and check that it is still valid (i.e., is still consistent with a signature
-        # in the code).
-        signature = Signature.from_dict(d['signature'])
-        idx = instance.__find_matching_overload(signature)
-        if idx is None:
-            # No match; generate an informative error message.
-            signature_note_str = 'any of its signatures' if instance.is_polymorphic else 'its signature as'
-            instance_signature_str = (
-                f'{len(instance.signatures)} signatures' if instance.is_polymorphic else str(instance.signature)
-            )
-            # TODO: Handle this more gracefully (instead of failing the DB load, allow the DB load to succeed, but
-            #       mark any enclosing FunctionCall as unusable). It's the same issue as dealing with a renamed UDF or
-            #       FunctionCall return type mismatch.
-            raise excs.Error(
-                f'The signature stored in the database for the UDF `{instance.self_path}` no longer matches '
-                f'{signature_note_str} as currently defined in the code.\nThis probably means that the code for '
-                f'`{instance.self_path}` has changed in a backward-incompatible way.\n'
-                f'Signature in database: {signature}\n'
-                f'Signature in code: {instance_signature_str}'
-            )
-        # We found a match; specialize to the appropriate overload resolution (non-polymorphic form) and return that.
-        return instance._resolved_fns[idx]
-
-    def __find_matching_overload(self, sig: Signature) -> Optional[int]:
-        for idx, overload_sig in enumerate(self.signatures):
-            if sig.is_consistent_with(overload_sig):
-                return idx
-        return None
+        return instance
 
     def to_store(self) -> tuple[dict, bytes]:
         """