pixeltable 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

pixeltable/exprs/expr.py

@@ -341,26 +341,67 @@ class Expr(abc.ABC):
                 result.extend(cls.get_refd_columns(component_dict))
         return result
 
+    def is_constant(self) -> bool:
+        """Returns True if this expr is a constant."""
+        return all(comp.is_constant() for comp in self.components)
+
+    def _as_constant(self) -> Any:
+        return None
+
+    def as_constant(self) -> Any:
+        """
+        If expression is a constant then return the associated value which will be converted to a Literal.
+        """
+        if self.is_constant():
+            return self._as_constant()
+        return None
+
+    @classmethod
+    def from_array(cls, elements: Iterable) -> Optional[Expr]:
+        from .inline_expr import InlineArray
+        inline_array = InlineArray(elements)
+        constant_array = inline_array.as_constant()
+        if constant_array is not None:
+            from .literal import Literal
+            return Literal(constant_array, inline_array.col_type)
+        else:
+            return inline_array
+
     @classmethod
     def from_object(cls, o: object) -> Optional[Expr]:
         """
         Try to turn a literal object into an Expr.
         """
-        if isinstance(o, Expr):
-            return o
         # Try to create a literal. We need to check for InlineList/InlineDict
         # first, to prevent them from inappropriately being interpreted as JsonType
         # literals.
-        if isinstance(o, list):
-            from .inline_expr import InlineList
-            return InlineList(o)
-        if isinstance(o, dict):
-            from .inline_expr 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, (list, tuple, dict, Expr)):
+            expr: Optional[Expr] = None
+            if isinstance(o, (list, tuple)):
+                from .inline_expr import InlineList
+                expr = InlineList(o)
+            elif isinstance(o, dict):
+                from .inline_expr import InlineDict
+                expr = InlineDict(o)
+            elif isinstance(o, Expr):
+                expr = o
+                from .literal import Literal
+                if isinstance(expr, Literal):
+                    return expr
+            # Check if the expression is constant
+            if expr is not None:
+                expr_value = expr.as_constant()
+                if expr_value is not None:
+                    from .literal import Literal
+                    return Literal(expr_value)
+                else:
+                    return expr
+        else:
+            # convert scalar to a literal
+            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)
         return None
 
     @abc.abstractmethod
@@ -508,6 +549,10 @@ class Expr(abc.ABC):
                 # Return the `MethodRef` object itself; it requires arguments to become a `FunctionCall`
                 return method_ref
 
+    def __rshift__(self, other: object) -> 'exprs.Expr':
+        # Implemented here for type-checking purposes
+        raise excs.Error('The `>>` operator can only be applied to Json expressions')
+
     def __bool__(self) -> bool:
         raise TypeError(
             'Pixeltable expressions cannot be used in conjunction with Python boolean operators (and/or/not)')

pixeltable/exprs/function_call.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import inspect
 import json
 import sys
-from typing import Any, Optional
+from typing import Any, Optional, Sequence
 
 import sqlalchemy as sql
 
@@ -26,6 +26,7 @@ class FunctionCall(Expr):
     fn: func.Function
     is_method_call: bool
     agg_init_args: dict[str, Any]
+    resource_pool: Optional[str]
 
     # tuple[Optional[int], Optional[Any]]:
     # - for Exprs: (index into components, None)
@@ -33,6 +34,12 @@ class FunctionCall(Expr):
     args: list[tuple[Optional[int], Optional[Any]]]
     kwargs: dict[str, tuple[Optional[int], Optional[Any]]]
 
+    # maps each parameter name to tuple representing the value it has in the call:
+    # - argument's index in components, if an argument is given in the call
+    # - default value, if no argument given in the call
+    # (in essence, this combines init()'s bound_args and default values)
+    _param_values: dict[str, tuple[Optional[int], Optional[Any]]]
+
     arg_types: list[ts.ColumnType]
     kwarg_types: dict[str, ts.ColumnType]
     return_type: ts.ColumnType
@@ -62,7 +69,8 @@ class FunctionCall(Expr):
 
         self.fn = fn
         self.is_method_call = is_method_call
-
+        #self.normalize_args(fn.name, signature, bound_args)
+        self.resource_pool = fn.call_resource_pool(bound_args)
         signature = fn.signature
 
         # If `return_type` is non-nullable, but the function call has a nullable input to any of its non-nullable
@@ -93,6 +101,7 @@ class FunctionCall(Expr):
         # construct components, args, kwargs
         self.args = []
         self.kwargs = {}
+        self._param_values = {}
 
         # we record the types of non-variable parameters for runtime type checks
         self.arg_types = []
@@ -106,9 +115,11 @@ class FunctionCall(Expr):
             arg = bound_args[py_param.name]
             if isinstance(arg, Expr):
                 self.args.append((len(self.components), None))
+                self._param_values[py_param.name] = (len(self.components), None)
                 self.components.append(arg.copy())
             else:
                 self.args.append((None, arg))
+                self._param_values[py_param.name] = (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)
@@ -119,12 +130,21 @@ class FunctionCall(Expr):
                 arg = bound_args[param_name]
                 if isinstance(arg, Expr):
                     self.kwargs[param_name] = (len(self.components), None)
+                    self._param_values[param_name] = (len(self.components), None)
                     self.components.append(arg.copy())
                 else:
                     self.kwargs[param_name] = (None, arg)
+                    self._param_values[param_name] = (None, arg)
                 if signature.py_signature.parameters[param_name].kind != inspect.Parameter.VAR_KEYWORD:
                     self.kwarg_types[param_name] = signature.parameters[param_name].col_type
 
+        # fill in default values for parameters that don't have explicit arguments
+        for param in fn.signature.parameters.values():
+            if param.name not in self._param_values:
+                self._param_values[param.name] = (
+                    (None, None) if param.default is inspect.Parameter.empty else (None, param.default)
+                )
+
         # window function state:
         # self.components[self.group_by_start_idx:self.group_by_stop_idx] contains group_by exprs
         self.group_by_start_idx, self.group_by_stop_idx = 0, 0
@@ -374,11 +394,11 @@ class FunctionCall(Expr):
         Update agg state
         """
         assert self.is_agg_fn_call
-        args, kwargs = self._make_args(data_row)
+        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]]:
-        """Return args and kwargs, constructed for data_row"""
+    def make_args(self, data_row: DataRow) -> Optional[tuple[list[Any], dict[str, Any]]]:
+        """Return args and kwargs, constructed for data_row; returns None if any non-nullable arg is None."""
         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]
@@ -388,6 +408,8 @@ class FunctionCall(Expr):
                 kwargs.update(val)
             else:
                 assert param.kind != inspect.Parameter.VAR_POSITIONAL
+                if not param.col_type.nullable and val is None:
+                    return None
                 kwargs[param_name] = val
 
         args: list[Any] = []
@@ -403,9 +425,30 @@ class FunctionCall(Expr):
                 assert isinstance(val, dict)
                 kwargs.update(val)
             else:
+                if not param.col_type.nullable and val is None:
+                    return None
                 args.append(val)
         return args, kwargs
 
+    def get_param_values(self, param_names: Sequence[str], data_rows: list[DataRow]) -> list[dict[str, Any]]:
+        """
+        Returns a list of dicts mapping each param name to its value when this FunctionCall is evaluated against
+        data_rows
+        """
+        assert all(name in self._param_values for name in param_names)
+        result: list[dict[str, Any]] = []
+        for row in data_rows:
+            d: dict[str, Any] = {}
+            for param_name in param_names:
+                component_idx, default_val = self._param_values[param_name]
+                if component_idx is None:
+                    d[param_name] = default_val
+                else:
+                    slot_idx = self.components[component_idx].slot_idx
+                    d[param_name] = row[slot_idx]
+            result.append(d)
+        return result
+
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         if isinstance(self.fn, func.ExprTemplateFunction):
             # we need to evaluate the template
@@ -419,20 +462,12 @@ class FunctionCall(Expr):
             data_row[self.slot_idx] = self.aggregator.value()
             return
 
-        args, kwargs = self._make_args(data_row)
-        signature = self.fn.signature
-        if signature.parameters is not None:
-            # check for nulls
-            for i in range(len(self.arg_types)):
-                if args[i] is None and not self.arg_types[i].nullable:
-                    # we can't evaluate this function
-                    data_row[self.slot_idx] = None
-                    return
-            for param_name, param_type in self.kwarg_types.items():
-                if kwargs[param_name] is None and not param_type.nullable:
-                    # we can't evaluate this function
-                    data_row[self.slot_idx] = None
-                    return
+        args_kwargs = self.make_args(data_row)
+        if args_kwargs is None:
+            # we can't evaluate this function
+            data_row[self.slot_idx] = None
+            return
+        args, kwargs = args_kwargs
 
         if isinstance(self.fn, func.CallableFunction) and not self.fn.is_batched:
             # optimization: avoid additional level of indirection we'd get from calling Function.exec()

pixeltable/exprs/inline_expr.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import copy
 from typing import Any, Iterable, Optional
 
 import numpy as np
@@ -26,8 +25,8 @@ class InlineArray(Expr):
         for el in elements:
             if isinstance(el, Expr):
                 exprs.append(el)
-            elif isinstance(el, list) or isinstance(el, tuple):
-                exprs.append(InlineArray(el))
+            elif isinstance(el, (list, tuple)):
+                exprs.append(Expr.from_array(el))
             else:
                 exprs.append(Literal(el))
 
@@ -83,6 +82,9 @@ class InlineArray(Expr):
             # loaded and their types are known.
             return InlineList(components)  # type: ignore[return-value]
 
+    def _as_constant(self) -> Optional[np.ndarray]:
+        assert isinstance(self.col_type, ts.ArrayType)
+        return np.array([c.as_constant() for c in self.components], dtype=self.col_type.numpy_dtype())
 
 class InlineList(Expr):
     """
@@ -90,16 +92,7 @@ class InlineList(Expr):
     """
 
     def __init__(self, elements: Iterable):
-        exprs = []
-        for el in elements:
-            if isinstance(el, Expr):
-                exprs.append(el)
-            elif isinstance(el, list) or isinstance(el, tuple):
-                exprs.append(InlineList(el))
-            elif isinstance(el, dict):
-                exprs.append(InlineDict(el))
-            else:
-                exprs.append(Literal(el))
+        exprs = [Expr.from_object(el) for el in elements]
 
         json_schema = {
             'type': 'array',
@@ -131,6 +124,8 @@ class InlineList(Expr):
     def _from_dict(cls, _: dict, components: list[Expr]) -> InlineList:
         return cls(components)
 
+    def _as_constant(self) -> Optional[list[Any]]:
+       return list(c.as_constant() for c in self.components)
 
 class InlineDict(Expr):
     """
@@ -146,14 +141,7 @@ class InlineDict(Expr):
             if not isinstance(key, str):
                 raise excs.Error(f'Dictionary requires string keys; {key} has type {type(key)}')
             self.keys.append(key)
-            if isinstance(val, Expr):
-                exprs.append(val)
-            elif isinstance(val, dict):
-                exprs.append(InlineDict(val))
-            elif isinstance(val, list) or isinstance(val, tuple):
-                exprs.append(InlineList(val))
-            else:
-                exprs.append(Literal(val))
+            exprs.append(Expr.from_object(val))
 
         json_schema: Optional[dict[str, Any]]
         try:
@@ -218,3 +206,6 @@ class InlineDict(Expr):
         assert len(d['keys']) == len(components)
         arg = dict(zip(d['keys'], components))
         return InlineDict(arg)
+
+    def _as_constant(self) -> Optional[dict[str, Any]]:
+        return dict(zip(self.keys, (c.as_constant() for c in self.components)))

pixeltable/exprs/literal.py

@@ -4,6 +4,7 @@ import datetime
 from typing import Any, Optional
 
 import sqlalchemy as sql
+import numpy as np
 
 import pixeltable.type_system as ts
 from pixeltable.env import Env
@@ -33,6 +34,9 @@ class Literal(Expr):
                     val = val.replace(tzinfo=default_tz)
             # Now convert to UTC
             val = val.astimezone(datetime.timezone.utc)
+        if isinstance(val, tuple):
+            # Tuples are stored as a list
+            val = list(val)
         self.val = val
         self.id = self._create_id()
 
@@ -46,6 +50,9 @@ class Literal(Expr):
             assert isinstance(self.val, datetime.datetime)
             default_tz = Env.get().default_time_zone
             return f"'{self.val.astimezone(default_tz).isoformat()}'"
+        if self.col_type.is_array_type():
+            assert isinstance(self.val, np.ndarray)
+            return str(self.val.tolist())
         return str(self.val)
 
     def __repr__(self) -> str:
@@ -67,7 +74,7 @@ class Literal(Expr):
         data_row[self.slot_idx] = self.val
 
     def _as_dict(self) -> dict:
-        # For some types, we need to explictly record their type, because JSON does not know
+        # For some types, we need to explicitly record their type, because JSON does not know
         # how to interpret them unambiguously
         if self.col_type.is_timestamp_type():
             assert isinstance(self.val, datetime.datetime)
@@ -76,18 +83,28 @@ class Literal(Expr):
             # stored as UTC in the database)
             encoded_val = self.val.isoformat()
             return {'val': encoded_val, 'val_t': self.col_type._type.name, **super()._as_dict()}
+        elif self.col_type.is_array_type():
+            assert isinstance(self.val, np.ndarray)
+            return {'val': self.val.tolist(), 'val_t': self.col_type._type.name, **super()._as_dict()}
         else:
             return {'val': self.val, **super()._as_dict()}
 
+    def _as_constant(self) -> Any:
+        return self.val
+
+    def is_constant(self) -> bool:
+        return True
+
     @classmethod
     def _from_dict(cls, d: dict, components: list[Expr]) -> Literal:
         assert 'val' in d
         if 'val_t' in d:
             val_t = d['val_t']
-            # Currently the only special-cased literal type is TIMESTAMP
-            assert val_t == ts.ColumnType.Type.TIMESTAMP.name
-            dt = datetime.datetime.fromisoformat(d['val'])
-            assert dt.tzinfo == datetime.timezone.utc  # Must be UTC in the database
-            return cls(dt)
-        else:
-            return cls(d['val'])
+            if val_t == ts.ColumnType.Type.TIMESTAMP.name:
+                dt = datetime.datetime.fromisoformat(d['val'])
+                assert dt.tzinfo == datetime.timezone.utc  # Must be UTC in the database
+                return cls(dt)
+            elif val_t == ts.ColumnType.Type.ARRAY.name:
+                arrays = np.array(d['val'])
+                return cls(arrays)
+        return cls(d['val'])

pixeltable/exprs/row_builder.py

@@ -6,12 +6,14 @@ from dataclasses import dataclass
 from typing import Any, Iterable, Optional, Sequence
 from uuid import UUID
 
+import numpy as np
 import sqlalchemy as sql
 
 import pixeltable.catalog as catalog
 import pixeltable.exceptions as excs
 import pixeltable.func as func
 import pixeltable.utils as utils
+from pixeltable.utils.media_store import MediaStore
 from .data_row import DataRow
 from .expr import Expr
 from .expr_set import ExprSet
@@ -68,6 +70,12 @@ class RowBuilder:
     # (list of set of slot_idxs, indexed by slot_idx)
     _exc_dependents: list[set[int]]
 
+    # dependents[i] = direct dependents of expr with slot idx i; dependents[i, j] == True: expr j depends on expr i
+    dependents: np.ndarray  # of bool
+    transitive_dependents: np.ndarray  # of bool
+    # dependencies[i] = direct dependencies of expr with slot idx i; transpose of dependents
+    dependencies: np.ndarray  # of bool
+
     # records the output_expr that a subexpr belongs to
     # (a subexpr can be shared across multiple output exprs)
     output_expr_ids: list[set[int]]
@@ -176,6 +184,8 @@ class RowBuilder:
 
         # determine transitive dependencies for the purpose of exception propagation
         # (list of set of slot_idxs, indexed by slot_idx)
+        #self.dependents = np.zeros((self.num_materialized, self.num_materialized), dtype=bool)
+        self.dependencies = np.zeros((self.num_materialized, self.num_materialized), dtype=bool)
         exc_dependencies: list[set[int]] = [set() for _ in range(self.num_materialized)]
         from .column_property_ref import ColumnPropertyRef
         for expr in self.unique_exprs:
@@ -185,10 +195,19 @@ class RowBuilder:
             # error properties don't have exceptions themselves
             if isinstance(expr, ColumnPropertyRef) and expr.is_error_prop():
                 continue
+            dependency_idxs = [d.slot_idx for d in expr.dependencies()]
+            self.dependencies[expr.slot_idx, dependency_idxs] = True
             for d in expr.dependencies():
                 exc_dependencies[expr.slot_idx].add(d.slot_idx)
                 exc_dependencies[expr.slot_idx].update(exc_dependencies[d.slot_idx])
 
+        self.dependents = self.dependencies.T
+        self.transitive_dependents = np.zeros((self.num_materialized, self.num_materialized), dtype=bool)
+        for i in reversed(range(self.num_materialized)):
+            self.transitive_dependents[i] = (
+                self.dependents[i] | np.any(self.transitive_dependents[self.dependents[i]], axis=0)
+            )
+
         self._exc_dependents = [set() for _ in range(self.num_materialized)]
         for expr in self.unique_exprs:
             assert expr.slot_idx is not None
@@ -389,6 +408,10 @@ class RowBuilder:
                 table_row[col.errortype_store_name()] = type(exc).__name__
                 table_row[col.errormsg_store_name()] = str(exc)
             else:
+                if col.col_type.is_image_type() and data_row.file_urls[slot_idx] is None:
+                    # we have yet to store this image
+                    filepath = str(MediaStore.prepare_media_path(col.tbl.id, col.id, col.tbl.version))
+                    data_row.flush_img(slot_idx, filepath)
                 val = data_row.get_stored_val(slot_idx, col.sa_col.type)
                 table_row[col.store_name()] = val
                 # we unfortunately need to set these, even if there are no errors

pixeltable/func/aggregate_function.py

@@ -123,6 +123,10 @@ class AggregateFunction(Function):
         assert not self.is_polymorphic
         return self.agg_classes[0]
 
+    @property
+    def is_async(self) -> bool:
+        return False
+
     def exec(self, args: Sequence[Any], kwargs: dict[str, Any]) -> Any:
         raise NotImplementedError
 

pixeltable/func/callable_function.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import inspect
 from typing import Any, Callable, Optional, Sequence
 from uuid import UUID
+import asyncio
 
 import cloudpickle  # type: ignore[import-untyped]
 
@@ -19,6 +20,9 @@ class CallableFunction(Function):
     - references to lambdas and functions defined in notebooks, which are pickled and serialized to the store
     - functions that are defined in modules are serialized via the default mechanism
     """
+    py_fns: list[Callable]
+    self_name: Optional[str]
+    batch_size: Optional[int]
 
     def __init__(
         self,
@@ -48,6 +52,10 @@ class CallableFunction(Function):
     def is_batched(self) -> bool:
         return self.batch_size is not None
 
+    @property
+    def is_async(self) -> bool:
+        return inspect.iscoroutinefunction(self.py_fn)
+
     def _docstring(self) -> Optional[str]:
         return inspect.getdoc(self.py_fns[0])
 
@@ -56,6 +64,21 @@ class CallableFunction(Function):
         assert not self.is_polymorphic
         return self.py_fns[0]
 
+    async def aexec(self, *args: Any, **kwargs: Any) -> Any:
+        assert not self.is_polymorphic
+        assert self.is_async
+        if self.is_batched:
+            # Pack the batched parameters into singleton lists
+            constant_param_names = [p.name for p in self.signature.constant_parameters]
+            batched_args = [[arg] for arg in args]
+            constant_kwargs = {k: v for k, v in kwargs.items() if k in constant_param_names}
+            batched_kwargs = {k: [v] for k, v in kwargs.items() if k not in constant_param_names}
+            result = await self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs)
+            assert len(result) == 1
+            return result[0]
+        else:
+            return await self.py_fn(*args, **kwargs)
+
     def exec(self, args: Sequence[Any], kwargs: dict[str, Any]) -> Any:
         assert not self.is_polymorphic
         if self.is_batched:
@@ -64,11 +87,31 @@ class CallableFunction(Function):
             batched_args = [[arg] for arg in args]
             constant_kwargs = {k: v for k, v in kwargs.items() if k in constant_param_names}
             batched_kwargs = {k: [v] for k, v in kwargs.items() if k not in constant_param_names}
-            result = self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs)
+            result: list[Any]
+            if inspect.iscoroutinefunction(self.py_fn):
+                result = asyncio.run(self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs))
+            else:
+                result = self.py_fn(*batched_args, **constant_kwargs, **batched_kwargs)
             assert len(result) == 1
             return result[0]
         else:
-            return self.py_fn(*args, **kwargs)
+            if inspect.iscoroutinefunction(self.py_fn):
+                return asyncio.run(self.py_fn(*args, **kwargs))
+            else:
+                return self.py_fn(*args, **kwargs)
+
+    async def aexec_batch(self, *args: Any, **kwargs: Any) -> list:
+        """Execute the function with the given arguments and return the result.
+        The arguments are expected to be batched: if the corresponding parameter has type T,
+        then the argument should have type T if it's a constant parameter, or list[T] if it's
+        a batched parameter.
+        """
+        assert self.is_batched
+        assert self.is_async
+        assert not self.is_polymorphic
+        # Unpack the constant parameters
+        constant_kwargs, batched_kwargs = self.create_batch_kwargs(kwargs)
+        return await self.py_fn(*args, **constant_kwargs, **batched_kwargs)
 
     def exec_batch(self, args: list[Any], kwargs: dict[str, Any]) -> list:
         """Execute the function with the given arguments and return the result.
@@ -79,12 +122,19 @@ class CallableFunction(Function):
         assert self.is_batched
         assert not self.is_polymorphic
         # Unpack the constant parameters
+        constant_kwargs, batched_kwargs = self.create_batch_kwargs(kwargs)
+        if inspect.iscoroutinefunction(self.py_fn):
+            return asyncio.run(self.py_fn(*args, **constant_kwargs, **batched_kwargs))
+        else:
+            return self.py_fn(*args, **constant_kwargs, **batched_kwargs)
+
+    def create_batch_kwargs(self, kwargs: dict[str, Any]) -> tuple[dict[str, Any], dict[str, list[Any]]]:
+        """Converts kwargs containing lists into constant and batched kwargs in the format expected by a batched udf."""
         constant_param_names = [p.name for p in self.signature.constant_parameters]
         constant_kwargs = {k: v[0] for k, v in kwargs.items() if k in constant_param_names}
         batched_kwargs = {k: v for k, v in kwargs.items() if k not in constant_param_names}
-        return self.py_fn(*args, **constant_kwargs, **batched_kwargs)
+        return constant_kwargs, batched_kwargs
 
-    # TODO(aaron-siegel): Implement conditional batch sizing
     def get_batch_size(self, *args: Any, **kwargs: Any) -> Optional[int]:
         return self.batch_size
 

pixeltable/func/expr_template_function.py

@@ -100,7 +100,7 @@ class ExprTemplateFunction(Function):
         assert not self.is_polymorphic
         expr = self.instantiate(args, kwargs)
         row_builder = exprs.RowBuilder(output_exprs=[expr], columns=[], input_exprs=[])
-        row_batch = exec.DataRowBatch(tbl=None, row_builder=row_builder, len=1)
+        row_batch = exec.DataRowBatch(tbl=None, row_builder=row_builder, num_rows=1)
         row = row_batch[0]
         row_builder.eval(row, ctx=row_builder.default_eval_ctx)
         return row[row_builder.get_output_exprs()[0].slot_idx]
@@ -113,6 +113,10 @@ class ExprTemplateFunction(Function):
     def name(self) -> str:
         return self.self_name
 
+    @property
+    def is_async(self) -> bool:
+        return False
+
     def __str__(self) -> str:
         return str(self.templates[0].expr)