pixeltable 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

pixeltable/exprs/__init__.py

@@ -6,9 +6,10 @@ from .comparison import Comparison
 from .compound_predicate import CompoundPredicate
 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 .image_similarity_predicate import ImageSimilarityPredicate
+from .in_predicate import InPredicate
 from .inline_array import InlineArray
 from .inline_dict import InlineDict
 from .is_null import IsNull
@@ -16,9 +17,9 @@ from .json_mapper import JsonMapper
 from .json_path import RELATIVE_PATH_ROOT, JsonPath
 from .literal import Literal
 from .object_ref import ObjectRef
-from  .variable import Variable
 from .predicate import Predicate
 from .row_builder import RowBuilder, ColumnSlotIdx, ExecProfile
 from .rowid_ref import RowidRef
-from .expr_set import ExprSet
+from .similarity_expr import SimilarityExpr
 from .type_cast import TypeCast
+from .variable import Variable

pixeltable/exprs/column_ref.py

@@ -63,6 +63,15 @@ class ColumnRef(Expr):
 
         return super().__getattr__(name)
 
+    def similarity(self, other: Any) -> Expr:
+        if isinstance(other, Expr):
+            raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')
+        item = Expr.from_object(other)
+        if item is None or not(item.col_type.is_string_type() or item.col_type.is_image_type()):
+            raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not a {type(other)}')
+        from .similarity_expr import SimilarityExpr
+        return SimilarityExpr(self, item)
+
     def default_column_name(self) -> Optional[str]:
         return str(self)
 
@@ -99,7 +108,7 @@ class ColumnRef(Expr):
     def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
         tbl_id, version, col_id = UUID(d['tbl_id']), d['tbl_version'], d['col_id']
         tbl_version = catalog.Catalog.get().tbl_versions[(tbl_id, version)]
-        assert col_id in tbl_version.cols_by_id
-        col = tbl_version.cols_by_id[col_id]
+        # don't use tbl_version.cols_by_id here, this might be a snapshot reference to a column that was then dropped
+        col = next(col for col in tbl_version.cols if col.id == col_id)
         return cls(col)
 

pixeltable/exprs/comparison.py

@@ -4,18 +4,44 @@ from typing import Optional, List, Any, Dict, Tuple
 
 import sqlalchemy as sql
 
+from .column_ref import ColumnRef
 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
 
 
 class Comparison(Predicate):
     def __init__(self, operator: ComparisonOperator, op1: Expr, op2: Expr):
         super().__init__()
         self.operator = operator
-        self.components = [op1, op2]
+
+        # if this is a comparison of a column to a literal (ie, could be used as a search argument in an index lookup),
+        # normalize it to <column> <operator> <literal>.
+        if isinstance(op1, ColumnRef) and isinstance(op2, Literal):
+            self.is_search_arg_comparison = True
+            self.components = [op1, op2]
+        elif isinstance(op1, Literal) and isinstance(op2, ColumnRef):
+            self.is_search_arg_comparison = True
+            self.components = [op2, op1]
+            self.operator = self.operator.reverse()
+        else:
+            self.is_search_arg_comparison = False
+            self.components = [op1, op2]
+
+        import pixeltable.index as index
+        if self.is_search_arg_comparison and self._op2.col_type.is_string_type() \
+                and len(self._op2.val) >= index.BtreeIndex.MAX_STRING_LEN:
+            # we can't use an index for this after all
+            raise excs.Error(
+                f'String literal too long for comparison against indexed column {self._op1.col.name!r} '
+                f'(max length is {index.BtreeIndex.MAX_STRING_LEN - 1})'
+            )
+
         self.id = self._create_id()
 
     def __str__(self) -> str:
@@ -37,6 +63,18 @@ class Comparison(Predicate):
 
     def sql_expr(self) -> Optional[sql.ClauseElement]:
         left = self._op1.sql_expr()
+        if self.is_search_arg_comparison:
+            # reference the index value column if there is an index and this is not a snapshot
+            # (indices don't apply to snapshots)
+            tbl = self._op1.col.tbl
+            idx_info = [
+                info for info in self._op1.col.get_idx_info().values() if isinstance(info.idx, index.BtreeIndex)
+            ]
+            if len(idx_info) > 0 and not tbl.is_snapshot:
+                # there shouldn't be multiple B-tree indices on a column
+                assert len(idx_info) == 1
+                left = idx_info[0].val_col.sa_col
+
         right = self._op2.sql_expr()
         if left is None or right is None:
             return None

pixeltable/exprs/data_row.py

@@ -197,3 +197,10 @@ class DataRow:
             pass
         self.vals[index] = None
 
+    @property
+    def rowid(self) -> Tuple[int]:
+        return self.pk[:-1]
+
+    @property
+    def v_min(self) -> int:
+        return self.pk[-1]

pixeltable/exprs/expr.py

@@ -60,9 +60,9 @@ class Expr(abc.ABC):
 
         # index of the expr's value in the data row:
         # - set for all materialized exprs
-        # - -1: not executable
+        # - 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 = -1
+        self.slot_idx: Optional[int] = None
         self.components: List[Expr] = []  # the subexprs that are needed to construct this expr
 
     def dependencies(self) -> List[Expr]:
@@ -110,6 +110,11 @@ class Expr(abc.ABC):
                 return False
         return self._equals(other)
 
+    def _equals(self, other: Expr) -> bool:
+        # we already compared the type and components in equals(); subclasses that require additional comparisons
+        # override this
+        return True
+
     def _id_attrs(self) -> List[Tuple[str, Any]]:
         """Returns attribute name/value pairs that are used to construct the instance id.
 
@@ -148,7 +153,7 @@ class Expr(abc.ABC):
         cls = self.__class__
         result = cls.__new__(cls)
         result.__dict__.update(self.__dict__)
-        result.slot_idx = -1
+        result.slot_idx = None
         result.components = [c.copy() for c in self.components]
         return result
 
@@ -164,16 +169,22 @@ class Expr(abc.ABC):
         memo[id(self)] = result
         return result
 
-    def substitute(self, old: Expr, new: Expr) -> Expr:
+    def substitute(self, spec: dict[Expr, Expr]) -> Expr:
         """
         Replace 'old' with 'new' recursively.
         """
-        if self.equals(old):
-            return new.copy()
+        for old, new in spec.items():
+            if self.equals(old):
+                return new.copy()
         for i in range(len(self.components)):
-            self.components[i] = self.components[i].substitute(old, new)
+            self.components[i] = self.components[i].substitute(spec)
         return self
 
+    @classmethod
+    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:
         """
         Recursively replace ColRefs to unstored computed columns with their value exprs.
@@ -191,9 +202,7 @@ class Expr(abc.ABC):
             ])
             if len(target_col_refs) == 0:
                 return result
-            for ref in target_col_refs:
-                assert ref.col.value_expr is not None
-                result = result.substitute(ref, ref.col.value_expr)
+            result = result.substitute({ref: ref.col.value_expr for ref in target_col_refs})
 
     def is_bound_by(self, tbl: catalog.TableVersionPath) -> bool:
         """Returns True if this expr can be evaluated in the context of tbl."""
@@ -220,11 +229,6 @@ class Expr(abc.ABC):
             self.components[i] = self.components[i]._retarget(tbl_versions)
         return self
 
-    @classmethod
-    def list_substitute(cls, expr_list: List[Expr], old: Expr, new: Expr) -> None:
-        for i in range(len(expr_list)):
-            expr_list[i] = expr_list[i].substitute(old, new)
-
     @abc.abstractmethod
     def __str__(self) -> str:
         pass
@@ -313,10 +317,6 @@ class Expr(abc.ABC):
             return InlineArray(tuple(o))
         return None
 
-    @abc.abstractmethod
-    def _equals(self, other: Expr) -> bool:
-        pass
-
     @abc.abstractmethod
     def sql_expr(self) -> Optional[sql.ClauseElement]:
         """
@@ -396,6 +396,13 @@ class Expr(abc.ABC):
     def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
         assert False, 'not implemented'
 
+    def isin(self, value_set: Any) -> 'pixeltable.exprs.InPredicate':
+        from .in_predicate import InPredicate
+        if isinstance(value_set, Expr):
+            return InPredicate(self, value_set_expr=value_set)
+        else:
+            return InPredicate(self, value_set_literal=value_set)
+
     def astype(self, new_type: ts.ColumnType) -> 'pixeltable.exprs.TypeCast':
         from pixeltable.exprs import TypeCast
         return TypeCast(self, new_type)

pixeltable/exprs/function_call.py

@@ -28,7 +28,7 @@ class FunctionCall(Expr):
         if group_by_clause is None:
             group_by_clause = []
         signature = fn.signature
-        super().__init__(signature.get_return_type(bound_args))
+        super().__init__(fn.call_return_type(bound_args))
         self.fn = fn
         self.is_method_call = is_method_call
         self.check_args(signature, bound_args)
@@ -46,9 +46,9 @@ class FunctionCall(Expr):
 
         # Tuple[int, Any]:
         # - for Exprs: (index into components, None)
-        # - otherwise: (-1, val)
-        self.args: List[Tuple[int, Any]] = []
-        self.kwargs: Dict[str, Tuple[int, Any]] = {}
+        # - otherwise: (None, val)
+        self.args: List[Tuple[Optional[int], Optional[Any]]] = []
+        self.kwargs: Dict[str, Tuple[Optional[int], Optional[Any]]] = {}
 
         # we record the types of non-variable parameters for runtime type checks
         self.arg_types: List[ts.ColumnType] = []
@@ -62,7 +62,7 @@ class FunctionCall(Expr):
                 self.args.append((len(self.components), None))
                 self.components.append(arg.copy())
             else:
-                self.args.append((-1, arg))
+                self.args.append((None, arg))
             if param.kind != inspect.Parameter.VAR_POSITIONAL and param.kind != inspect.Parameter.VAR_KEYWORD:
                 self.arg_types.append(signature.parameters[param.name].col_type)
 
@@ -74,7 +74,7 @@ class FunctionCall(Expr):
                 self.kwargs[param_name] = (len(self.components), None)
                 self.components.append(arg.copy())
             else:
-                self.kwargs[param_name] = (-1, arg)
+                self.kwargs[param_name] = (None, arg)
             if fn.py_signature.parameters[param_name].kind != inspect.Parameter.VAR_KEYWORD:
                 self.kwarg_types[param_name] = signature.parameters[param_name].col_type
 
@@ -174,9 +174,6 @@ class FunctionCall(Expr):
                     f'Parameter {param_name}: argument type {arg.col_type} does not match parameter type '
                     f'{param_type}')
 
-    def is_nos_call(self) -> bool:
-        return isinstance(self.fn, func.NOSFunction)
-
     def _equals(self, other: FunctionCall) -> bool:
         if self.fn != other.fn:
             return False
@@ -215,12 +212,12 @@ class FunctionCall(Expr):
 
     def _print_args(self, start_idx: int = 0, inline: bool = True) -> str:
         arg_strs = [
-            str(arg) if idx == -1 else str(self.components[idx]) for idx, arg in self.args[start_idx:]
+            str(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 == -1 else str(self.components[idx])}'
+            f'{param_name}={print_arg(arg) if idx is None else str(self.components[idx])}'
             for param_name, (idx, arg) in self.kwargs.items()
         ])
         if len(self.order_by) > 0:
@@ -287,7 +284,7 @@ class FunctionCall(Expr):
         """Return args and kwargs, constructed for data_row"""
         kwargs: Dict[str, Any] = {}
         for param_name, (component_idx, arg) in self.kwargs.items():
-            val = arg if component_idx == -1 else data_row[self.components[component_idx].slot_idx]
+            val = arg if component_idx is None else data_row[self.components[component_idx].slot_idx]
             param = self.fn.signature.parameters[param_name]
             if param.kind == inspect.Parameter.VAR_KEYWORD:
                 # expand **kwargs parameter
@@ -298,7 +295,7 @@ class FunctionCall(Expr):
 
         args: List[Any] = []
         for param_idx, (component_idx, arg) in enumerate(self.args):
-            val = arg if component_idx == -1 else data_row[self.components[component_idx].slot_idx]
+            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]
             if param.kind == inspect.Parameter.VAR_POSITIONAL:
                 # expand *args parameter
@@ -333,7 +330,8 @@ class FunctionCall(Expr):
             # TODO: can we get rid of this extra copy?
             fn_expr = self.components[self.fn_expr_idx]
             data_row[self.slot_idx] = data_row[fn_expr.slot_idx]
-        elif isinstance(self.fn, func.CallableFunction):
+        elif isinstance(self.fn, func.CallableFunction) and not self.fn.is_batched:
+            # optimization: avoid additional level of indirection we'd get from calling Function.exec()
             data_row[self.slot_idx] = self.fn.py_fn(*args, **kwargs)
         elif self.is_window_fn_call:
             if self.has_group_by():
@@ -348,9 +346,10 @@ class FunctionCall(Expr):
                 self.aggregator = self.fn.agg_cls(**self.agg_init_args)
             self.aggregator.update(*args)
             data_row[self.slot_idx] = self.aggregator.value()
-        else:
-            assert self.is_agg_fn_call
+        elif self.is_agg_fn_call:
             data_row[self.slot_idx] = self.aggregator.value()
+        else:
+            data_row[self.slot_idx] = self.fn.exec(*args, **kwargs)
 
     def _as_dict(self) -> Dict:
         result = {
@@ -369,9 +368,9 @@ class FunctionCall(Expr):
         # reassemble bound args
         fn = func.Function.from_dict(d['fn'])
         param_names = list(fn.signature.parameters.keys())
-        bound_args = {param_names[i]: arg if idx == -1 else components[idx] for i, (idx, arg) in enumerate(d['args'])}
+        bound_args = {param_names[i]: arg if idx is None else components[idx] for i, (idx, arg) in enumerate(d['args'])}
         bound_args.update(
-            {param_name: val if idx == -1 else components[idx] for param_name, (idx, val) in d['kwargs'].items()})
+            {param_name: val if idx is None else components[idx] for param_name, (idx, val) in d['kwargs'].items()})
         group_by_exprs = components[d['group_by_start_idx']:d['group_by_stop_idx']]
         order_by_exprs = components[d['order_by_start_idx']:]
         fn_call = cls(

pixeltable/exprs/globals.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
+
 import datetime
-from typing import Union
 import enum
-
+from typing import Union
 
 # Python types corresponding to our literal types
 LiteralPythonTypes = Union[str, int, float, bool, datetime.datetime, datetime.date]
@@ -33,6 +34,17 @@ class ComparisonOperator(enum.Enum):
         if self == self.GE:
             return '>='
 
+    def reverse(self) -> ComparisonOperator:
+        if self == self.LT:
+            return self.GT
+        if self == self.LE:
+            return self.GE
+        if self == self.GT:
+            return self.LT
+        if self == self.GE:
+            return self.LE
+        return self
+
 
 class LogicalOperator(enum.Enum):
     AND = 0

pixeltable/exprs/image_member_access.py

@@ -1,19 +1,17 @@
 from __future__ import annotations
-from typing import Optional, List, Any, Dict, Tuple, Union
+
+from typing import Optional, List, Any, Dict, Tuple
 
 import PIL
 import sqlalchemy as sql
 
+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 .column_ref import ColumnRef
 from .function_call import FunctionCall
-from .image_similarity_predicate import ImageSimilarityPredicate
-from .data_row import DataRow
 from .row_builder import RowBuilder
-import pixeltable.catalog as catalog
-import pixeltable.func as func
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
 
 
 # TODO: this doesn't dig up all attrs for actual jpeg images
@@ -43,9 +41,7 @@ class ImageMemberAccess(Expr):
     attr_info = _create_pil_attr_info()
 
     def __init__(self, member_name: str, caller: Expr):
-        if member_name == 'nearest':
-            super().__init__(ts.InvalidType())  # requires FunctionCall to return value
-        elif member_name in self.attr_info:
+        if member_name in self.attr_info:
             super().__init__(self.attr_info[member_name])
         else:
             candidates = func.FunctionRegistry.get().get_type_methods(member_name, ts.ColumnType.Type.IMAGE)
@@ -78,22 +74,8 @@ class ImageMemberAccess(Expr):
         assert len(components) == 1
         return cls(d['member_name'], components[0])
 
-    def __call__(self, *args, **kwargs) -> Union[FunctionCall, ImageSimilarityPredicate]:
-        caller = self._caller
-        call_signature = f'({",".join([type(arg).__name__ for arg in args])})'
-        if self.member_name == 'nearest':
-            # - caller must be ColumnRef
-            # - signature is (Union[PIL.Image.Image, str])
-            if not isinstance(caller, ColumnRef):
-                raise excs.Error(f'nearest(): caller must be an image column')
-            if len(args) != 1 or (not isinstance(args[0], PIL.Image.Image) and not isinstance(args[0], str)):
-                raise excs.Error(f'nearest(): requires a PIL.Image.Image or str, got {call_signature} instead')
-            return ImageSimilarityPredicate(
-                caller,
-                img=args[0] if isinstance(args[0], PIL.Image.Image) else None,
-                text=args[0] if isinstance(args[0], str) else None)
-
-        result = self.img_method(*[caller, *args], **kwargs)
+    def __call__(self, *args, **kwargs) -> FunctionCall:
+        result = self.img_method(*[self._caller, *args], **kwargs)
         result.is_method_call = True
         return result
 
@@ -112,4 +94,3 @@ class ImageMemberAccess(Expr):
             data_row[self.slot_idx] = getattr(caller_val, self.member_name)
         except AttributeError:
             data_row[self.slot_idx] = None
-

pixeltable/exprs/in_predicate.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from typing import Optional, List, Any, Dict, Tuple, Iterable
+
+import sqlalchemy as sql
+
+import pixeltable.exceptions as excs
+from .data_row import DataRow
+from .expr import Expr
+from .predicate import Predicate
+from .row_builder import RowBuilder
+
+
+class InPredicate(Predicate):
+    """Predicate corresponding to the SQL IN operator."""
+
+    def __init__(self, lhs: Expr, value_set_literal: Optional[Iterable] = None, value_set_expr: Optional[Expr] = None):
+        assert (value_set_literal is None) != (value_set_expr is None)
+        if not lhs.col_type.is_scalar_type():
+            raise excs.Error(f'isin(): only supported for scalar types, not {lhs.col_type}')
+        super().__init__()
+
+        self.value_list: Optional[list] = None  # only contains values of the correct type
+        if value_set_expr is not None:
+            if not value_set_expr.col_type.is_json_type():
+                raise excs.Error(
+                    f'isin(): argument must have a JSON type, but {value_set_expr} has type {value_set_expr.col_type}')
+            self.components = [lhs.copy(), value_set_expr.copy()]
+        else:
+            assert value_set_literal is not None
+            self.components = [lhs.copy()]
+            self.value_list = self._normalize_value_set(value_set_literal)
+
+        self.id = self._create_id()
+
+    @property
+    def _lhs(self) -> Expr:
+        return self.components[0]
+
+    @property
+    def _value_set_expr(self) -> Expr:
+        assert len(self.components) == 2
+        return self.components[1]
+
+    def _normalize_value_set(self, value_set: Any, filter_type_mismatches: bool = True) -> Iterable:
+        if not isinstance(value_set, Iterable):
+            raise excs.Error(f'isin(): argument must be an Iterable (eg, list, dict, ...), not {value_set!r}')
+        value_list = list(value_set)
+        if not filter_type_mismatches:
+            return value_list
+
+        # ignore elements of the wrong type
+        result = []
+        for val in value_list:
+            try:
+                self._lhs.col_type.validate_literal(val)
+                result.append(val)
+            except TypeError:
+                pass
+        return result
+
+    def __str__(self) -> str:
+        if self.value_list is not None:
+            return f'{self.components[0]}.isin({self.value_list})'
+        return f'{self.components[0]}.isin({self.components[1]})'
+
+    def _equals(self, other: InPredicate) -> bool:
+        return self.value_list == other.value_list
+
+    def _id_attrs(self) -> List[Tuple[str, Any]]:
+        return super()._id_attrs() + [('value_list', self.value_list)]
+
+    def sql_expr(self) -> Optional[sql.ClauseElement]:
+        lhs_sql_exprs = self.components[0].sql_expr()
+        if lhs_sql_exprs is None or self.value_list is None:
+            return None
+        return lhs_sql_exprs.in_(self.value_list)
+
+    def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
+        lhs_val = data_row[self._lhs.slot_idx]
+        if self.value_list is not None:
+            data_row[self.slot_idx] = lhs_val in self.value_list
+        else:
+            value_set = data_row[self._value_set_expr.slot_idx]
+            value_list = self._normalize_value_set(value_set, filter_type_mismatches=False)
+            data_row[self.slot_idx] = lhs_val in value_list
+
+    def _as_dict(self) -> Dict:
+        return {'value_list': self.value_list, **super()._as_dict()}
+
+    @classmethod
+    def _from_dict(cls, d: Dict, components: List[Expr]) -> Expr:
+        assert 'value_list' in d
+        assert len(components) <= 2
+        return cls(components[0], d['value_list'], components[1] if len(components) == 2 else None)
+

pixeltable/exprs/inline_array.py

@@ -1,16 +1,16 @@
 from __future__ import annotations
-from typing import Optional, List, Any, Dict, Tuple
+
 import copy
+from typing import Optional, List, Any, Dict, Tuple
 
-import sqlalchemy as sql
 import numpy as np
+import sqlalchemy as sql
 
-from .expr import Expr
+import pixeltable.type_system as ts
 from .data_row import DataRow
+from .expr import Expr
 from .inline_dict import InlineDict
 from .row_builder import RowBuilder
-import pixeltable.catalog as catalog
-import pixeltable.type_system as ts
 
 
 class InlineArray(Expr):
@@ -27,8 +27,8 @@ class InlineArray(Expr):
 
         # elements contains
         # - for Expr elements: (index into components, None)
-        # - for non-Expr elements: (-1, value)
-        self.elements: List[Tuple[int, Any]] = []
+        # - for non-Expr elements: (None, value)
+        self.elements: List[Tuple[Optional[int], Any]] = []
         for el in elements:
             el = copy.deepcopy(el)
             if isinstance(el, list):
@@ -41,11 +41,11 @@ class InlineArray(Expr):
                 self.elements.append((len(self.components), None))
                 self.components.append(el)
             else:
-                self.elements.append((-1, el))
+                self.elements.append((None, el))
 
         inferred_element_type = ts.InvalidType()
         for idx, val in self.elements:
-            if idx >= 0:
+            if idx is not None:
                 inferred_element_type = ts.ColumnType.supertype(inferred_element_type, self.components[idx].col_type)
             else:
                 inferred_element_type = ts.ColumnType.supertype(inferred_element_type, ts.ColumnType.infer_literal_type(val))
@@ -83,7 +83,7 @@ class InlineArray(Expr):
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
         result = [None] * len(self.elements)
         for i, (child_idx, val) in enumerate(self.elements):
-            if child_idx >= 0:
+            if child_idx is not None:
                 result[i] = data_row[self.components[child_idx].slot_idx]
             else:
                 result[i] = copy.deepcopy(val)
@@ -100,7 +100,9 @@ class InlineArray(Expr):
         assert 'elements' in d
         arg: List[Any] = []
         for idx, val in d['elements']:
-            if idx >= 0:
+            # TODO Normalize idx -1 to None via schema migrations.
+            # Long-term we should not be allowing idx == -1.
+            if idx is not None and idx >= 0:  # Older schemas might have -1 instead of None
                 arg.append(components[idx])
             else:
                 arg.append(val)