pixeltable 0.4.0rc3__py3-none-any.whl → 0.4.20__py3-none-any.whl

pixeltable/exprs/expr_set.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Generic, Iterable, Iterator, Optional, TypeVar
+from typing import Generic, Iterable, Iterator, TypeVar
 
 from .expr import Expr
 
@@ -9,26 +9,33 @@ T = TypeVar('T', bound='Expr')
 
 class ExprSet(Generic[T]):
     """
-    A set that also supports indexed lookup (by slot_idx and Expr.id). Exprs are uniquely identified by Expr.id.
+    An ordered set that also supports indexed lookup (by slot_idx and Expr.id). Exprs are uniquely identified by
+    Expr.id.
     """
 
     exprs: dict[int, T]  # key: Expr.id
+    expr_offsets: dict[int, int]  # key: Expr.id, value: offset into self.exprs.keys()
     exprs_by_idx: dict[int, T]  # key: slot_idx
 
-    def __init__(self, elements: Optional[Iterable[T]] = None):
+    def __init__(self, elements: Iterable[T] | None = None):
         self.exprs = {}
+        self.expr_offsets = {}
         self.exprs_by_idx = {}
         if elements is not None:
             for e in elements:
                 self.add(e)
 
-    def add(self, expr: T) -> None:
-        if expr.id in self.exprs:
-            return
+    def add(self, expr: T) -> int:
+        """Returns offset corresponding to iteration order"""
+        offset = self.expr_offsets.get(expr.id)
+        if offset is not None:
+            return offset
+        offset = len(self.exprs)
         self.exprs[expr.id] = expr
-        if expr.slot_idx is None:
-            return
-        self.exprs_by_idx[expr.slot_idx] = expr
+        self.expr_offsets[expr.id] = offset
+        if expr.slot_idx is not None:
+            self.exprs_by_idx[expr.slot_idx] = expr
+        return offset
 
     def update(self, *others: Iterable[T]) -> None:
         for other in others:
@@ -44,7 +51,7 @@ class ExprSet(Generic[T]):
     def __iter__(self) -> Iterator[T]:
         return iter(self.exprs.values())
 
-    def __getitem__(self, index: object) -> Optional[T]:
+    def __getitem__(self, index: object) -> T | None:
         """Indexed lookup by slot_idx or Expr.id."""
         assert isinstance(index, (int, Expr))
         if isinstance(index, int):

pixeltable/exprs/function_call.py

@@ -4,7 +4,7 @@ import inspect
 import logging
 import sys
 from textwrap import dedent
-from typing import Any, Optional, Sequence, Union
+from typing import Any, Sequence
 
 import sqlalchemy as sql
 
@@ -24,7 +24,7 @@ class FunctionCall(Expr):
     fn: func.Function
     is_method_call: bool
     agg_init_args: dict[str, Any]
-    resource_pool: Optional[str]
+    resource_pool: str | None
 
     # These collections hold the component indices corresponding to the args and kwargs
     # that were passed to the FunctionCall. They're 1:1 with the original call pattern.
@@ -36,17 +36,17 @@ class FunctionCall(Expr):
     # - a component index, if the parameter is a non-variadic parameter
     # - a list of component indices, if the parameter is a variadic positional parameter
     # - a dict mapping keyword names to component indices, if the parameter is a variadic keyword parameter
-    bound_idxs: dict[str, Union[int, list[int], dict[str, int]]]
+    bound_idxs: dict[str, int | list[int] | dict[str, int]]
 
     return_type: ts.ColumnType
     group_by_start_idx: int
     group_by_stop_idx: int
     fn_expr_idx: int
     order_by_start_idx: int
-    aggregator: Optional[Any]
-    current_partition_vals: Optional[list[Any]]
+    aggregator: Any | None
+    current_partition_vals: list[Any] | None
 
-    _validation_error: Optional[str]
+    _validation_error: str | None
 
     def __init__(
         self,
@@ -54,10 +54,10 @@ class FunctionCall(Expr):
         args: list[Expr],
         kwargs: dict[str, Expr],
         return_type: ts.ColumnType,
-        order_by_clause: Optional[list[Any]] = None,
-        group_by_clause: Optional[list[Any]] = None,
+        order_by_clause: list[Any] | None = None,
+        group_by_clause: list[Any] | None = None,
         is_method_call: bool = False,
-        validation_error: Optional[str] = None,
+        validation_error: str | None = None,
     ):
         assert not fn.is_polymorphic
         assert all(isinstance(arg, Expr) for arg in args)
@@ -115,6 +115,7 @@ class FunctionCall(Expr):
         self._validation_error = validation_error
 
         if validation_error is not None:
+            self.bound_idxs = {}
             self.resource_pool = None
             return
 
@@ -148,7 +149,7 @@ class FunctionCall(Expr):
         target = tbl._tbl_version_path.tbl_version
         return [RowidRef(target, i) for i in range(target.get().num_rowid_columns())]
 
-    def default_column_name(self) -> Optional[str]:
+    def default_column_name(self) -> str | None:
         return self.fn.name
 
     def _equals(self, other: FunctionCall) -> bool:
@@ -177,7 +178,7 @@ class FunctionCall(Expr):
         return self.display_str()
 
     @property
-    def validation_error(self) -> Optional[str]:
+    def validation_error(self) -> str | None:
         return self._validation_error or super().validation_error
 
     def display_str(self, inline: bool = True) -> str:
@@ -244,7 +245,7 @@ class FunctionCall(Expr):
         assert self.is_agg_fn_call
         return self.order_by
 
-    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, sql_elements: SqlElementCache) -> sql.ColumnElement | None:
         assert self.is_valid
 
         # we currently can't translate aggregate functions with grouping and/or ordering to SQL
@@ -300,8 +301,16 @@ class FunctionCall(Expr):
         """
         res = super().substitute(spec)
         assert res is self
-        self.return_type = self.fn.call_return_type(self.bound_args)
-        self.col_type = self.return_type
+        if self.is_valid:
+            # If this FunctionCall is valid, re-evaluate the call_return_type of the substituted expression. If the
+            # FunctionCall is not valid, it isn't safe to do this. (Really we should be asserting that it *is* valid,
+            # but we still need to be able to do substitutions on invalid FunctionCalls, because loading an
+            # EmbeddingIndex from the db involves reconstructing the requisite (substituted) FunctionCalls. We could
+            # fix this by separately persisting the FunctionCall instances held by EmbeddingIndex to the db. That's
+            # probably a good idea, but it's also probably not urgent, since it only affects Functions that have a
+            # conditional_return_type implemented.)
+            self.return_type = self.fn.call_return_type(self.bound_args)
+            self.col_type = self.return_type
         return self
 
     def update(self, data_row: DataRow) -> None:
@@ -312,7 +321,7 @@ class FunctionCall(Expr):
         args, kwargs = self.make_args(data_row)
         self.aggregator.update(*args, **kwargs)
 
-    def make_args(self, data_row: DataRow) -> Optional[tuple[list[Any], dict[str, Any]]]:
+    def make_args(self, data_row: DataRow) -> tuple[list[Any], dict[str, Any]] | None:
         """Return args and kwargs, constructed for data_row; returns None if any non-nullable arg is None."""
         args: list[Any] = []
         parameters_by_pos = self.fn.signature.parameters_by_pos
@@ -439,18 +448,18 @@ class FunctionCall(Expr):
         group_by_exprs = components[group_by_start_idx:group_by_stop_idx]
         order_by_exprs = components[order_by_start_idx:]
 
-        validation_error: Optional[str] = None
+        validation_error: str | None = None
 
         if isinstance(fn, func.InvalidFunction):
             validation_error = (
                 dedent(
                     f"""
                     The UDF '{fn.self_path}' cannot be located, because
-                    {{errormsg}}
+                    {{error_msg}}
                     """
                 )
                 .strip()
-                .format(errormsg=fn.errormsg)
+                .format(error_msg=fn.error_msg)
             )
             return cls(fn, args, kwargs, return_type, is_method_call=is_method_call, validation_error=validation_error)
 
@@ -480,25 +489,54 @@ class FunctionCall(Expr):
             ).strip()
         else:
             # Evaluate the call_return_type as defined in the current codebase.
-            call_return_type = resolved_fn.call_return_type(bound_args)
-            if return_type is None:
-                # Schema versions prior to 25 did not store the return_type in metadata, and there is no obvious way to
-                # infer it during DB migration, so we might encounter a stored return_type of None. In that case, we use
-                # the call_return_type that we just inferred (which matches the deserialization behavior prior to
-                # version 25).
-                return_type = call_return_type
-            elif not return_type.is_supertype_of(call_return_type, ignore_nullable=True):
-                # There is a return_type stored in metadata (schema version >= 25),
-                # and the stored return_type of the UDF call doesn't match the column type of the FunctionCall.
-                validation_error = dedent(
-                    f"""
-                    The return type stored in the database for a UDF call to {fn.self_path!r} no longer
-                    matches its return type as currently defined in the code. This probably means that the
-                    code for {fn.self_path!r} has changed in a backward-incompatible way.
-                    Return type of UDF call in the database: {return_type}
-                    Return type of UDF as currently defined in code: {call_return_type}
-                    """
-                ).strip()
+            call_return_type: ts.ColumnType | None = None
+
+            if isinstance(resolved_fn, func.ExprTemplateFunction) and not resolved_fn.template.expr.is_valid:
+                # The FunctionCall is based on an ExprTemplateFunction, but the template expression is not valid
+                # (because it in turn contains an invalid FunctionCall). In this case, inherit the validation error
+                # from the template expression.
+                validation_error = resolved_fn.template.expr.validation_error
+            else:
+                try:
+                    call_return_type = resolved_fn.call_return_type(bound_args)
+                except ImportError as exc:
+                    validation_error = dedent(
+                        f"""
+                        A UDF call to {fn.self_path!r} could not be fully resolved, because a module required
+                        by the UDF could not be imported:
+                        {exc}
+                        """
+                    )
+
+            assert (call_return_type is None) != (validation_error is None)
+
+            if call_return_type is None and return_type is None:
+                # Schema versions prior to 25 did not store the return_type in metadata, and there is no obvious
+                # way to infer it during DB migration, so we might encounter a stored return_type of None. If the
+                # resolution of call_return_type also fails, then we're out of luck; we have no choice but to
+                # fail-fast.
+                raise excs.Error(validation_error)
+
+            if call_return_type is not None:
+                # call_return_type resolution succeeded.
+                if return_type is None:
+                    # Schema versions prior to 25 did not store the return_type in metadata (as mentioned above), so
+                    # fall back on the call_return_type.
+                    return_type = call_return_type
+                elif not return_type.is_supertype_of(call_return_type, ignore_nullable=True):
+                    # There is a return_type stored in metadata (schema version >= 25),
+                    # and the stored return_type of the UDF call doesn't match the column type of the FunctionCall.
+                    validation_error = dedent(
+                        f"""
+                        The return type stored in the database for a UDF call to {fn.self_path!r} no longer
+                        matches its return type as currently defined in the code. This probably means that the
+                        code for {fn.self_path!r} has changed in a backward-incompatible way.
+                        Return type of UDF call in the database: {return_type}
+                        Return type of UDF as currently defined in code: {call_return_type}
+                        """
+                    ).strip()
+
+        assert return_type is not None  # Guaranteed by the above logic.
 
         fn_call = cls(
             resolved_fn,

pixeltable/exprs/globals.py

@@ -2,10 +2,9 @@ from __future__ import annotations
 
 import datetime
 import enum
-from typing import Union
 
 # Python types corresponding to our literal types
-LiteralPythonTypes = Union[str, int, float, bool, datetime.datetime, datetime.date]
+LiteralPythonTypes = str | int | float | bool | datetime.datetime | datetime.date
 
 
 def print_slice(s: slice) -> str:

pixeltable/exprs/in_predicate.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Iterable, Optional
+from typing import Any, Iterable
 
 import sqlalchemy as sql
 
@@ -16,13 +16,13 @@ from .sql_element_cache import SqlElementCache
 class InPredicate(Expr):
     """Predicate corresponding to the SQL IN operator."""
 
-    def __init__(self, lhs: Expr, value_set_literal: Optional[Iterable] = None, value_set_expr: Optional[Expr] = None):
+    def __init__(self, lhs: Expr, value_set_literal: Iterable | None = None, value_set_expr: Expr | None = 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__(ts.BoolType())
 
-        self.value_list: Optional[list] = None  # only contains values of the correct type
+        self.value_list: list | None = 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(
@@ -73,7 +73,7 @@ class InPredicate(Expr):
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return [*super()._id_attrs(), ('value_list', self.value_list)]
 
-    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, sql_elements: SqlElementCache) -> sql.ColumnElement | None:
         lhs_sql_exprs = sql_elements.get(self.components[0])
         if lhs_sql_exprs is None or self.value_list is None:
             return None

pixeltable/exprs/inline_expr.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Iterable, Optional
+from typing import Any, Iterable
 
 import numpy as np
 import sqlalchemy as sql
@@ -30,7 +30,7 @@ class InlineArray(Expr):
             else:
                 exprs.append(Literal(el))
 
-        inferred_element_type: Optional[ts.ColumnType] = ts.InvalidType()
+        inferred_element_type: ts.ColumnType | None = ts.InvalidType()
         for i, expr in enumerate(exprs):
             supertype = inferred_element_type.supertype(expr.col_type)
             if supertype is None:
@@ -61,7 +61,7 @@ class InlineArray(Expr):
     def _equals(self, _: InlineArray) -> bool:
         return True  # Always true if components match
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
@@ -81,7 +81,7 @@ class InlineArray(Expr):
             # loaded and their types are known.
             return InlineList(components)  # type: ignore[return-value]
 
-    def as_literal(self) -> Optional[Literal]:
+    def as_literal(self) -> Literal | None:
         assert isinstance(self.col_type, ts.ArrayType)
         if not all(isinstance(comp, Literal) for comp in self.components):
             return None
@@ -98,13 +98,7 @@ class InlineList(Expr):
     def __init__(self, elements: Iterable):
         exprs = [Expr.from_object(el) for el in elements]
 
-        json_schema = {
-            'type': 'array',
-            'prefixItems': [expr.col_type.to_json_schema() for expr in exprs],
-            'items': False,  # No additional items (fixed length)
-        }
-
-        super().__init__(ts.JsonType(json_schema))
+        super().__init__(ts.JsonType())
         self.components.extend(exprs)
         self.id = self._create_id()
 
@@ -115,7 +109,7 @@ class InlineList(Expr):
     def _equals(self, _: InlineList) -> bool:
         return True  # Always true if components match
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         return None
 
     def eval(self, data_row: DataRow, _: RowBuilder) -> None:
@@ -128,7 +122,7 @@ class InlineList(Expr):
     def _from_dict(cls, _: dict, components: list[Expr]) -> InlineList:
         return cls(components)
 
-    def as_literal(self) -> Optional[Literal]:
+    def as_literal(self) -> Literal | None:
         if not all(isinstance(comp, Literal) for comp in self.components):
             return None
         return Literal([c.as_literal().val for c in self.components], self.col_type)
@@ -150,18 +144,7 @@ class InlineDict(Expr):
             self.keys.append(key)
             exprs.append(Expr.from_object(val))
 
-        json_schema: Optional[dict[str, Any]]
-        try:
-            json_schema = {
-                'type': 'object',
-                'properties': {key: expr.col_type.to_json_schema() for key, expr in zip(self.keys, exprs)},
-            }
-        except excs.Error:
-            # InlineDicts are used to store iterator arguments, which are not required to be valid JSON types,
-            # so we can't always construct a valid schema.
-            json_schema = None
-
-        super().__init__(ts.JsonType(json_schema))
+        super().__init__(ts.JsonType())
         self.components.extend(exprs)
         self.id = self._create_id()
 
@@ -176,7 +159,7 @@ class InlineDict(Expr):
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return [*super()._id_attrs(), ('keys', self.keys)]
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         return None
 
     def eval(self, data_row: DataRow, _: RowBuilder) -> None:
@@ -208,7 +191,7 @@ class InlineDict(Expr):
         arg = dict(zip(d['keys'], components))
         return InlineDict(arg)
 
-    def as_literal(self) -> Optional[Literal]:
+    def as_literal(self) -> Literal | None:
         if not all(isinstance(comp, Literal) for comp in self.components):
             return None
         return Literal(dict(zip(self.keys, (c.as_literal().val for c in self.components))), self.col_type)

pixeltable/exprs/is_null.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import sqlalchemy as sql
 
 import pixeltable.type_system as ts
@@ -24,7 +22,7 @@ class IsNull(Expr):
     def _equals(self, other: IsNull) -> bool:
         return True
 
-    def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, sql_elements: SqlElementCache) -> sql.ColumnElement | None:
         e = sql_elements.get(self.components[0])
         if e is None:
             return None

pixeltable/exprs/json_mapper.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import sqlalchemy as sql
 
@@ -29,10 +29,10 @@ class JsonMapper(Expr):
     """
 
     target_expr_scope: ExprScope
-    parent_mapper: Optional[JsonMapper]
-    target_expr_eval_ctx: Optional[RowBuilder.EvalCtx]
+    parent_mapper: JsonMapper | None
+    target_expr_eval_ctx: RowBuilder.EvalCtx | None
 
-    def __init__(self, src_expr: Optional[Expr], target_expr: Optional[Expr]):
+    def __init__(self, src_expr: Expr | None, target_expr: Expr | None):
         # TODO: type spec should be list[target_expr.col_type]
         super().__init__(ts.JsonType())
 
@@ -54,7 +54,7 @@ class JsonMapper(Expr):
     def _equals(self, _: JsonMapper) -> bool:
         return True
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         return None
 
     def eval(self, data_row: DataRow, row_builder: RowBuilder) -> None:
@@ -92,8 +92,8 @@ class JsonMapperDispatch(Expr):
     """
 
     target_expr_scope: ExprScope
-    parent_mapper: Optional[JsonMapperDispatch]
-    target_expr_eval_ctx: Optional[RowBuilder.EvalCtx]
+    parent_mapper: JsonMapperDispatch | None
+    target_expr_eval_ctx: RowBuilder.EvalCtx | None
 
     def __init__(self, src_expr: Expr, target_expr: Expr):
         super().__init__(ts.InvalidType())
@@ -116,7 +116,7 @@ class JsonMapperDispatch(Expr):
         scope_anchor = ObjectRef(self.target_expr_scope, self)
         self.components.append(scope_anchor)
 
-    def _bind_rel_paths(self, mapper: Optional[JsonMapperDispatch] = None) -> None:
+    def _bind_rel_paths(self, mapper: JsonMapperDispatch | None = None) -> None:
         self.src_expr._bind_rel_paths(mapper)
         self.target_expr._bind_rel_paths(self)
         self.parent_mapper = mapper

pixeltable/exprs/json_path.py

@@ -1,12 +1,15 @@
 from __future__ import annotations
 
-from typing import Any, Optional, Union
+import io
+from pathlib import Path
+from typing import Any
 
 import jmespath
 import sqlalchemy as sql
 
 from pixeltable import catalog, exceptions as excs, type_system as ts
 
+from .column_ref import ColumnRef
 from .data_row import DataRow
 from .expr import Expr
 from .globals import print_slice
@@ -17,29 +20,41 @@ from .sql_element_cache import SqlElementCache
 
 
 class JsonPath(Expr):
+    """
+    anchor can be None, in which case this is a relative JsonPath and the anchor is set later via set_anchor().
+    scope_idx: for relative paths, index of referenced JsonMapper
+    (0: indicates the immediately preceding JsonMapper, -1: the parent of the immediately preceding mapper, ...)
+    """
+
+    path_elements: list[str | int | slice]
+    compiled_path: jmespath.parser.ParsedResult | None
+    scope_idx: int
+    file_handles: dict[Path, io.BufferedReader]  # key: file path
+
     def __init__(
-        self, anchor: Optional[Expr], path_elements: Optional[list[Union[str, int, slice]]] = None, scope_idx: int = 0
+        self, anchor: Expr | None, path_elements: list[str | int | slice] | None = None, scope_idx: int = 0
     ) -> None:
-        """
-        anchor can be None, in which case this is a relative JsonPath and the anchor is set later via set_anchor().
-        scope_idx: for relative paths, index of referenced JsonMapper
-        (0: indicates the immediately preceding JsonMapper, -1: the parent of the immediately preceding mapper, ...)
-        """
         if path_elements is None:
             path_elements = []
         super().__init__(ts.JsonType(nullable=True))  # JsonPath expressions are always nullable
         if anchor is not None:
             self.components = [anchor]
-        self.path_elements: list[Union[str, int, slice]] = path_elements
+        self.path_elements = path_elements
         self.compiled_path = jmespath.compile(self._json_path()) if len(path_elements) > 0 else None
         self.scope_idx = scope_idx
         # NOTE: the _create_id() result will change if set_anchor() gets called;
         # this is not a problem, because _create_id() shouldn't be called after init()
         self.id = self._create_id()
+        self.file_handles = {}
+
+    def release(self) -> None:
+        for fh in self.file_handles.values():
+            fh.close()
+        self.file_handles.clear()
 
     def __repr__(self) -> str:
         # else 'R': the anchor is RELATIVE_PATH_ROOT
-        anchor_str = str(self._anchor) if self._anchor is not None else 'R'
+        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()}'
@@ -66,7 +81,7 @@ class JsonPath(Expr):
         return cls(anchor, path_elements, d['scope_idx'])
 
     @property
-    def _anchor(self) -> Optional[Expr]:
+    def anchor(self) -> Expr | None:
         return None if len(self.components) == 0 else self.components[0]
 
     def set_anchor(self, anchor: Expr) -> None:
@@ -74,17 +89,17 @@ class JsonPath(Expr):
         self.components = [anchor]
 
     def is_relative_path(self) -> bool:
-        return self._anchor is None
+        return self.anchor is None
 
     def _has_relative_path(self) -> bool:
         return self.is_relative_path() or super()._has_relative_path()
 
-    def _bind_rel_paths(self, mapper: Optional['JsonMapperDispatch'] = None) -> None:
+    def _bind_rel_paths(self, mapper: 'JsonMapperDispatch' | None = None) -> None:
         if self.is_relative_path():
             # TODO: take scope_idx into account
             self.set_anchor(mapper.scope_anchor)
         else:
-            self._anchor._bind_rel_paths(mapper)
+            self.anchor._bind_rel_paths(mapper)
 
     def __call__(self, *args: object, **kwargs: object) -> 'JsonPath':
         """
@@ -98,15 +113,15 @@ class JsonPath(Expr):
 
     def __getattr__(self, name: str) -> 'JsonPath':
         assert isinstance(name, str)
-        return JsonPath(self._anchor, [*self.path_elements, name])
+        return JsonPath(self.anchor, [*self.path_elements, name])
 
     def __getitem__(self, index: object) -> 'JsonPath':
         if isinstance(index, (int, slice, str)):
-            return JsonPath(self._anchor, [*self.path_elements, index])
+            return JsonPath(self.anchor, [*self.path_elements, index])
         raise excs.Error(f'Invalid json list index: {index}')
 
-    def default_column_name(self) -> Optional[str]:
-        anchor_name = self._anchor.default_column_name() if self._anchor is not None else ''
+    def default_column_name(self) -> str | None:
+        anchor_name = self.anchor.default_column_name() if self.anchor is not None else ''
         ret_name = f'{anchor_name}.{self._json_path()}'
 
         def cleanup_char(s: str) -> str:
@@ -133,7 +148,7 @@ class JsonPath(Expr):
     def _id_attrs(self) -> list[tuple[str, Any]]:
         return [*super()._id_attrs(), ('path_elements', self.path_elements)]
 
-    def sql_expr(self, _: SqlElementCache) -> Optional[sql.ColumnElement]:
+    def sql_expr(self, _: SqlElementCache) -> sql.ColumnElement | None:
         """
         Postgres appears to have a bug: jsonb_path_query('{a: [{b: 0}, {b: 1}]}', '$.a.b') returns
         *two* rows (each containing col val 0), not a single row with [0, 0].
@@ -158,12 +173,31 @@ class JsonPath(Expr):
                 result.append(f'[{print_slice(element)}]')
         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]
+    def eval(self, row: DataRow, row_builder: RowBuilder) -> None:
+        assert self.anchor is not None, self
+        val = row[self.anchor.slot_idx]
         if self.compiled_path is not None:
             val = self.compiled_path.search(val)
-        data_row[self.slot_idx] = val
+        row[self.slot_idx] = val
+        if val is None or self.anchor is None or not isinstance(self.anchor, ColumnRef):
+            return
+
+        # the origin of val is a json-typed column, which might stored inlined objects
+        if self.anchor.slot_idx not in row.slot_md:
+            # we can infer that there aren't any inlined objects because our execution plan doesn't include
+            # materializing the cellmd (eg, insert plans)
+            # TODO: have the planner pass that fact into ExprEvalNode explicitly to streamline this path a bit more
+            return
+
+        # defer import until it's needed
+        from pixeltable.exec.cell_reconstruction_node import json_has_inlined_objs, reconstruct_json
+
+        cell_md = row.slot_md[self.anchor.slot_idx]
+        if cell_md is None or cell_md.file_urls is None or not json_has_inlined_objs(val):
+            # val doesn't contain inlined objects
+            return
+
+        row.vals[self.slot_idx] = reconstruct_json(val, cell_md.file_urls, self.file_handles)
 
 
 RELATIVE_PATH_ROOT = JsonPath(None)