vgi-python 0.9.0__tar.gz → 0.10.0__tar.gz

{vgi_python-0.9.0 → vgi_python-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vgi-python
-Version: 0.9.0
+Version: 0.10.0
 Summary: Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow
 Project-URL: Homepage, https://query.farm
 Project-URL: Repository, https://github.com/Query-farm/vgi-python

{vgi_python-0.9.0 → vgi_python-0.10.0}/packages/vgi-fixtures/pyproject.toml

@@ -38,6 +38,7 @@ dependencies = ["vgi-python[test-fixtures-writable]", "vgi-python[duckdb]"]
 
 [project.scripts]
 vgi-fixture-worker = "vgi._test_fixtures.worker:main"
+vgi-fixture-companion-worker = "vgi._test_fixtures.companion:main"
 vgi-fixture-http = "vgi._test_fixtures.http_server:main"
 vgi-fixture-versioned-worker = "vgi._test_fixtures.versioned:main"
 vgi-fixture-versioned-tables-worker = "vgi._test_fixtures.versioned_tables:main"

{vgi_python-0.9.0 → vgi_python-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vgi-python"
-version = "0.9.0"
+version = "0.10.0"
 description = "Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow"
 readme = "README.md"
 keywords = [

{vgi_python-0.9.0 → vgi_python-0.10.0}/tests/catalog/test_declarative.py

@@ -41,8 +41,10 @@ from vgi.catalog import (
     View,
     ViewInfo,
 )
+from vgi.invocation import BindResponse
 from vgi.schema_utils import schema
 from vgi.table_function import (
+    BindParams,
     ProcessParams,
     TableFunctionGenerator,
     bind_fixed_schema,
@@ -81,6 +83,31 @@ class UsersFunction(TableFunctionGenerator[EmptyArgs]):
         out.finish()
 
 
+@init_single_worker
+class SecretLookupFunction(TableFunctionGenerator[EmptyArgs]):
+    """Backing function whose ``on_bind`` performs a two-phase secret lookup.
+
+    This exercises the bug where ``Table(function=...)`` schema derivation took
+    the empty secret-scope-request schema instead of retrying the bind.
+    """
+
+    class Meta:  # noqa: D106
+        name = "secret_scan"
+        description = "Backing function that looks up a secret at bind time"
+
+    FIXED_SCHEMA: ClassVar[pa.Schema] = schema({"id": pa.int64(), "name": pa.string()})
+
+    @classmethod
+    def on_bind(cls, params: BindParams[EmptyArgs]) -> BindResponse:  # noqa: D102
+        params.secrets.get("some_secret")  # unresolved -> registers a two-phase lookup
+        return BindResponse(output_schema=cls.FIXED_SCHEMA)
+
+    @classmethod
+    def process(cls, params: ProcessParams[EmptyArgs], state: None, out: OutputCollector) -> None:  # noqa: D102
+        out.emit(pa.RecordBatch.from_pydict({"id": [1], "name": ["x"]}, schema=params.output_schema))
+        out.finish()
+
+
 @init_single_worker
 @bind_fixed_schema
 class EventsFunction(TableFunctionGenerator[EmptyArgs]):
@@ -186,6 +213,18 @@ class TestTableWithFunction:
         assert resolved.field(0).name == "id"
         assert resolved.field(1).name == "name"
 
+    def test_function_backed_table_derives_schema_despite_secret_lookup(self) -> None:
+        """A backing function that calls secrets.get() in on_bind still yields its schema.
+
+        Regression: on_bind's two-phase secret lookup makes the first bind return an
+        empty secret-scope-request schema; schema derivation must retry with resolved
+        secrets rather than adopt the empty schema (which produced 0-column tables).
+        """
+        table = Table(name="things", function=SecretLookupFunction)
+        resolved = table.resolved_columns
+        assert [f.name for f in resolved] == ["id", "name"]
+        assert len(resolved) == 2
+
     def test_table_function_backed_with_constraints(self) -> None:
         """Function-backed table can have constraints validated."""
         table = Table(
@@ -336,7 +375,6 @@ class TestTableWithFunction:
         from typing import Any as _Any
 
         from vgi.invocation import BindResponse
-        from vgi.table_function import BindParams
 
         @init_single_worker
         class _ManualBindFn(TableFunctionGenerator[EmptyArgs]):

{vgi_python-0.9.0 → vgi_python-0.10.0}/tests/catalog/test_serialization.py

@@ -1110,7 +1110,7 @@ class TestArrowSchemaCorrectness:
     def test_catalog_attach_result_schema(self) -> None:
         """Verify CatalogAttachResult Arrow schema."""
         schema = CatalogAttachResult.ARROW_SCHEMA
-        assert len(schema) == 14
+        assert len(schema) == 15
         assert schema.field("attach_opaque_data").type == pa.binary()
         assert schema.field("supports_transactions").type == pa.bool_()
         assert schema.field("supports_time_travel").type == pa.bool_()
@@ -1120,6 +1120,7 @@ class TestArrowSchemaCorrectness:
         assert schema.field("default_schema").type == pa.string()
         assert schema.field("settings").type == pa.list_(pa.binary())
         assert schema.field("secret_types").type == pa.list_(pa.binary())
+        assert schema.field("attach_catalogs").type == pa.list_(pa.binary())
         assert schema.field("resolved_data_version").type == pa.string()
         assert schema.field("resolved_implementation_version").type == pa.string()
 

vgi_python-0.10.0/tests/conformance/test_const_param_enforcement.py

@@ -0,0 +1,69 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+"""Conformance test: ConstParam value constraints are enforced at bind.
+
+A ``ConstParam`` may declare ``choices``/``ge``/``le``/``gt``/``lt``/``pattern``.
+Those are surfaced for agent discovery (via ``vgi_function_arguments()``) AND
+must be enforced: a const value that violates a declared constraint fails at
+bind with ``ArgumentValidationError``, rather than silently reaching
+``compute()``. This mirrors the legacy ``Arg`` descriptor path.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import pyarrow as pa
+import pytest
+
+from vgi.arguments import Arguments, ArgumentValidationError, ConstParam, Param, Returns
+from vgi.protocol import BindRequest, FunctionType
+from vgi.scalar_function import BindResult, ScalarFunction
+
+
+class _Measure(ScalarFunction):
+    class Meta:
+        name = "measure"
+
+    @classmethod
+    def on_bind(cls, params: object) -> BindResult:
+        return BindResult(pa.string())
+
+    @classmethod
+    def compute(
+        cls,
+        unit: Annotated[str, ConstParam("Output unit", choices=["mm", "cm", "m"])],
+        precision: Annotated[int, ConstParam("Decimals", ge=0, le=10)],
+        value: Annotated[pa.DoubleArray, Param(doc="Value")],
+    ) -> Annotated[pa.StringArray, Returns()]:
+        return pa.array([str(value)], type=pa.string())
+
+
+def _bind(unit: str, precision: int) -> None:
+    _Measure.bind(
+        BindRequest(
+            function_name="measure",
+            arguments=Arguments(positional=(pa.scalar(unit), pa.scalar(precision))),
+            function_type=FunctionType.SCALAR,
+            input_schema=pa.schema([("value", pa.float64())]),
+        )
+    )
+
+
+def test_valid_const_values_bind() -> None:
+    """A const value inside every declared constraint binds cleanly."""
+    _bind("cm", 2)
+
+
+def test_choice_violation_raises_at_bind() -> None:
+    """A const value outside the choice set fails at bind."""
+    with pytest.raises(ArgumentValidationError) as exc:
+        _bind("xx", 2)
+    assert "unit" in str(exc.value)
+
+
+def test_range_violation_raises_at_bind() -> None:
+    """A const value outside the numeric range fails at bind."""
+    with pytest.raises(ArgumentValidationError) as exc:
+        _bind("cm", 99)
+    assert "precision" in str(exc.value)

vgi_python-0.10.0/tests/conformance/test_container.py

@@ -0,0 +1,17 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+"""Conformance stub for ``vgi/test/sql/integration/container/``."""
+
+from __future__ import annotations
+
+from tests.conformance._stub import skip_area
+
+skip_area(
+    "container",
+    [
+        "errors.test",
+        "shared_http.test",
+        "shared_tcp.test",
+        "sklearn_smoke.test",
+    ],
+)

vgi_python-0.10.0/tests/conformance/test_copy_from.py

@@ -0,0 +1,16 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+"""Conformance stub for ``vgi/test/sql/integration/copy_from/``."""
+
+from __future__ import annotations
+
+from tests.conformance._stub import skip_area
+
+skip_area(
+    "copy_from",
+    [
+        "basic.test",
+        "options.test",
+        "secrets.test",
+    ],
+)

vgi_python-0.10.0/tests/conformance/test_copy_to.py

@@ -0,0 +1,21 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+"""Conformance stub for ``vgi/test/sql/integration/copy_to/``."""
+
+from __future__ import annotations
+
+from tests.conformance._stub import skip_area
+
+skip_area(
+    "copy_to",
+    [
+        "basic.test",
+        "failure.test",
+        "options.test",
+        "ordered.test",
+        "parallel.test",
+        "secrets.test",
+        "tmp_file.test",
+        "types.test",
+    ],
+)

vgi_python-0.10.0/tests/conformance/test_github.py

@@ -0,0 +1,15 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+"""Conformance stub for ``vgi/test/sql/integration/github/``."""
+
+from __future__ import annotations
+
+from tests.conformance._stub import skip_area
+
+skip_area(
+    "github",
+    [
+        "download.test",
+        "errors.test",
+    ],
+)

{vgi_python-0.9.0 → vgi_python-0.10.0}/tests/conformance/test_secret.py

@@ -9,10 +9,13 @@ from tests.conformance._stub import skip_area
 skip_area(
     "secret",
     [
+        "secret_aggregate.test",
+        "secret_function_backed_table.test",
         "secret_no_secret.test",
         "secret_registration.test",
         "secret_scalar.test",
         "secret_scoped.test",
         "secret_table_function.test",
+        "secret_table_in_out.test",
     ],
 )

{vgi_python-0.9.0 → vgi_python-0.10.0}/tests/test_aggregate_function.py

@@ -13,7 +13,14 @@ import pytest
 from vgi_rpc import ArrowSerializableDataclass, ArrowType
 
 from vgi.aggregate_function import AggregateFunction
-from vgi.arguments import ConstParam, Param, Returns
+from vgi.arguments import (
+    Arguments,
+    ArgumentValidationError,
+    ConstParam,
+    Param,
+    Returns,
+    validate_const_arg_constraints,
+)
 from vgi.table_function import ProcessParams
 
 # ---------------------------------------------------------------------------
@@ -199,6 +206,49 @@ class TestInitSubclassParameterExtraction:
         assert arg.arrow_type == pa.float64()
         assert arg.const is True
 
+    def test_const_param_constraints_enforced(self) -> None:
+        """A ConstParam's declared constraints are enforced at bind (same as scalar)."""
+
+        class BoundedAgg(AggregateFunction[SimpleState]):
+            class Meta:
+                name = "test_bounded_agg"
+
+            @classmethod
+            def initial_state(cls, params: ProcessParams[Any]) -> SimpleState:
+                return SimpleState()
+
+            @classmethod
+            def update(
+                cls,
+                states: dict[int, SimpleState],
+                group_ids: pa.Int64Array,
+                value: Annotated[pa.DoubleArray, Param(doc="Values")],
+                mode: Annotated[str, ConstParam("Mode", choices=["min", "max"])] = "min",
+            ) -> None:
+                pass
+
+            @classmethod
+            def combine(cls, source: SimpleState, target: SimpleState, params: ProcessParams[Any]) -> SimpleState:
+                return SimpleState()
+
+            @classmethod
+            def finalize(
+                cls,
+                group_ids: pa.Int64Array,
+                states: dict[int, SimpleState],
+                params: ProcessParams[Any],
+            ) -> Annotated[pa.RecordBatch, Returns(pa.float64())]:
+                return pa.record_batch({"result": pa.array([], type=pa.float64())})
+
+        # The ConstParam carries its choices (threaded via _const_param_to_arg)...
+        const_params = BoundedAgg._const_params
+        assert const_params["mode"].choices == ["min", "max"]
+        # ...and the shared bind-time validator (called by aggregate_bind) enforces it.
+        validate_const_arg_constraints(const_params, Arguments(positional=(pa.scalar("max"),)))
+        with pytest.raises(ArgumentValidationError) as exc:
+            validate_const_arg_constraints(const_params, Arguments(positional=(pa.scalar("median"),)))
+        assert "mode" in str(exc.value)
+
     def test_const_param_phases(self) -> None:
         """ConstParam phase values are stored correctly."""
 

{vgi_python-0.9.0 → vgi_python-0.10.0}/tests/test_argument_spec.py

@@ -12,13 +12,18 @@ import pytest
 from vgi.argument_spec import (
     VGI_ARG_KEY,
     VGI_ARG_NAMED,
+    VGI_CHOICES_KEY,
+    VGI_DEFAULT_KEY,
     VGI_DOC_KEY,
+    VGI_PATTERN_KEY,
+    VGI_RANGE_KEY,
     VGI_TYPE_ANY,
     VGI_TYPE_KEY,
     VGI_TYPE_TABLE,
     VGI_VARARGS_KEY,
     VGI_VARARGS_TRUE,
     ArgumentSpec,
+    _format_range,
     argument_specs_to_schema,
     extract_argument_specs,
     schema_to_argument_specs,
@@ -722,3 +727,99 @@ class TestArgumentDoc:
         specs = {s.name: s for s in extract_argument_specs(FunctionWithDocs)}
         assert specs["unit"].doc == "Unit string, e.g. 'mi'"
         assert specs["scale"].doc == ""
+
+
+class TestArgumentConstraints:
+    """Per-argument constraint metadata (choices / range / pattern / default)."""
+
+    def test_format_range_notation(self) -> None:
+        """Interval notation covers inclusive, exclusive, open, and empty bounds."""
+        assert _format_range(0, 100, None, None) == "[0, 100]"
+        assert _format_range(None, None, 0, None) == "(0, +inf)"
+        assert _format_range(1, None, None, 10) == "[1, 10)"
+        assert _format_range(None, 5, None, None) == "(-inf, 5]"
+        assert _format_range(None, None, None, None) is None
+
+    def test_writer_emits_constraint_keys(self) -> None:
+        """A constrained spec writes value-encoded constraint metadata keys."""
+        spec = ArgumentSpec(
+            name="unit",
+            position="unit",
+            arrow_type=pa.utf8(),
+            default_json='"mm"',
+            choices_json='["mm", "cm", "m"]',
+            range_notation="[0, 100]",
+            pattern="^[A-Z]{2}$",
+        )
+        meta = argument_specs_to_schema([spec])[0].metadata
+        assert meta[VGI_DEFAULT_KEY] == b'"mm"'
+        assert meta[VGI_CHOICES_KEY] == b'["mm", "cm", "m"]'
+        assert meta[VGI_RANGE_KEY] == b"[0, 100]"
+        assert meta[VGI_PATTERN_KEY] == b"^[A-Z]{2}$"
+
+    def test_unconstrained_arg_omits_keys(self) -> None:
+        """An arg without constraints yields none of the constraint keys."""
+        meta = argument_specs_to_schema([ArgumentSpec(name="v", position=0, arrow_type=pa.int64())])[0].metadata
+        for key in (VGI_DEFAULT_KEY, VGI_CHOICES_KEY, VGI_RANGE_KEY, VGI_PATTERN_KEY):
+            assert meta is None or key not in meta
+
+    def test_constraints_round_trip(self) -> None:
+        """Constraint metadata survives the schema round-trip."""
+        spec = ArgumentSpec(
+            name="mode",
+            position="mode",
+            arrow_type=pa.utf8(),
+            default_json='"add"',
+            choices_json='["add", "mul"]',
+            range_notation="[0, 10)",
+            pattern="^x+$",
+        )
+        out = schema_to_argument_specs(argument_specs_to_schema([spec]))[0]
+        assert out.default_json == '"add"'
+        assert out.choices_json == '["add", "mul"]'
+        assert out.range_notation == "[0, 10)"
+        assert out.pattern == "^x+$"
+
+    def test_extract_constraints_from_arg(self) -> None:
+        """extract_argument_specs reads choices/default/bounds/pattern off Arg."""
+
+        class FunctionWithConstraints(TableInOutFunction):  # type: ignore[type-arg]
+            mode: str = Arg[str](  # type: ignore[assignment]
+                "mode", doc="Blend mode", choices=["add", "mul"], default="add"
+            )
+            level: int = Arg[int](0, ge=1, le=10)  # type: ignore[assignment]
+            code: str = Arg[str](1, pattern="^[A-Z]{2}$")  # type: ignore[assignment]
+
+        specs = {s.name: s for s in extract_argument_specs(FunctionWithConstraints)}
+        assert specs["mode"].choices_json == '["add", "mul"]'
+        assert specs["mode"].default_json == '"add"'
+        assert specs["level"].range_notation == "[1, 10]"
+        assert specs["code"].pattern == "^[A-Z]{2}$"
+
+    def test_const_param_constraints_surface(self) -> None:
+        """The modern Param/ConstParam API surfaces choices / range / pattern."""
+        from vgi.arguments import ConstParam, Param, Returns
+        from vgi.scalar_function import ScalarFunction
+
+        class ConstrainedScalar(ScalarFunction):
+            class Meta:
+                name = "constrained_scalar"
+                description = "constraint demo"
+
+            @classmethod
+            def compute(
+                cls,
+                unit: Annotated[str, ConstParam("Output unit", choices=["mm", "cm", "m"])],
+                precision: Annotated[int, ConstParam("Decimals", ge=0, le=10)],
+                code: Annotated[str, ConstParam("Label code", pattern="^[A-Z]{2}$")],
+                value: Annotated[pa.DoubleArray, Param(doc="Value")],
+            ) -> Annotated[pa.StringArray, Returns()]:
+                return value  # never executed — the test only reads arg specs
+
+        specs = {s.name: s for s in extract_argument_specs(ConstrainedScalar)}
+        assert specs["unit"].choices_json == '["mm", "cm", "m"]'
+        assert specs["precision"].range_notation == "[0, 10]"
+        assert specs["code"].pattern == "^[A-Z]{2}$"
+        # The columnar Param carries no constraints.
+        assert specs["value"].choices_json is None
+        assert specs["value"].range_notation is None

{vgi_python-0.9.0 → vgi_python-0.10.0}/vgi/_test_fixtures/aggregate/__init__.py

@@ -32,6 +32,7 @@ from vgi._test_fixtures.aggregate.dynamic import (
 from vgi._test_fixtures.aggregate.generic import GenericSumFunction
 from vgi._test_fixtures.aggregate.listagg import ListAggFunction
 from vgi._test_fixtures.aggregate.percentile import PercentileFunction
+from vgi._test_fixtures.aggregate.secret_typed import SecretTypedSumFunction
 from vgi._test_fixtures.aggregate.streaming import StreamingSumFunction
 from vgi._test_fixtures.aggregate.varargs import SumAllFunction
 from vgi._test_fixtures.aggregate.window import (
@@ -50,6 +51,7 @@ __all__ = [
     "ListAggFunction",
     "ListAggState",
     "PercentileFunction",
+    "SecretTypedSumFunction",
     "StreamingSumFunction",
     "SumAllFunction",
     "SumFunction",

vgi_python-0.10.0/vgi/_test_fixtures/aggregate/secret_typed.py

@@ -0,0 +1,115 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+"""Secret-aware aggregate fixture (secret_typed_sum).
+
+Demonstrates the *supported* aggregate x secret intersection: an aggregate
+reads a statically-resolved secret in ``on_bind`` (declared via the ``Secret()``
+annotation, so the C++ extension resolves it up front and delivers it on
+``AggregateBindRequest.secrets``) and uses a secret *value* to shape its output
+type. The aggregated value itself is computed normally in ``update`` /
+``finalize``.
+
+Boundary (intentional, see ``vgi.worker.aggregate_bind``): secret *values* are
+only available at bind time. ``aggregate_update`` / ``aggregate_finalize``
+receive an empty ``ResolvedSecrets`` (persisting secrets to shared aggregate
+storage would leak them), and a two-phase ``params.secrets.get()`` inside an
+aggregate's ``on_bind`` raises ``NotImplementedError``. This fixture therefore
+resolves the secret statically and threads the bind-time decision to
+``finalize`` via the output schema (which round-trips bind -> finalize).
+"""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+import pyarrow as pa
+
+from vgi._test_fixtures.aggregate._common import SumState
+from vgi.aggregate_function import AggregateBindParams, AggregateFunction
+from vgi.arguments import Param, Returns, Secret
+from vgi.invocation import BindResponse
+from vgi.metadata import FunctionExample
+from vgi.schema_utils import schema
+from vgi.table_function import ProcessParams
+
+
+class SecretTypedSumFunction(AggregateFunction[SumState]):
+    """Sum an integer column, choosing the result type from a secret.
+
+    ``on_bind`` reads the ``vgi_example`` secret (resolved statically by the C++
+    extension). When the secret's ``use_ssl`` field is true the aggregate returns
+    the sum as ``DOUBLE``; otherwise as ``BIGINT``. This proves the secret's
+    *value* was delivered to the aggregate's bind — an aggregate that never
+    declared a secret could not vary its output type this way.
+
+    SQL: ``SELECT secret_typed_sum(n) FROM t GROUP BY g``
+    """
+
+    class Meta:
+        name = "secret_typed_sum"
+        description = "Sum an integer column; the result type is chosen from a secret"
+        categories = ["aggregate", "secret"]
+        examples = [
+            FunctionExample(
+                sql="SELECT secret_typed_sum(n) FROM (SELECT 1 AS n UNION ALL SELECT 2)",
+                description="Sum a column with the result type selected by the vgi_example secret",
+            ),
+        ]
+
+    @classmethod
+    def on_bind(
+        cls,
+        params: AggregateBindParams,
+        *,
+        vgi_example: Annotated[dict[str, pa.Scalar[Any]] | None, Secret("vgi_example")] = None,
+        **kwargs: Any,
+    ) -> BindResponse:
+        """Choose the result type from the statically-resolved secret.
+
+        The ``Secret()`` annotation advertises the requirement so the extension
+        pre-resolves the secret and delivers it on the bind request (keyed by the
+        DuckDB secret *name*). ``to_dict().of_type()`` matches it by the secret's
+        connector-serialized ``type`` field — no ``get()`` (which would register a
+        pending lookup and trigger the unsupported two-phase retry).
+        """
+        secret = next(iter(params.secrets.to_dict().of_type("vgi_example")), {})
+        use_ssl = secret.get("use_ssl")
+        as_double = bool(use_ssl.as_py()) if use_ssl is not None else False
+        result_type = pa.float64() if as_double else pa.int64()
+        return BindResponse(output_schema=schema(result=result_type))
+
+    @classmethod
+    def initial_state(cls, params: ProcessParams[None]) -> SumState:
+        """Identity element for the sum."""
+        return SumState(total=0)
+
+    @classmethod
+    def update(
+        cls,
+        states: dict[int, SumState],
+        group_ids: pa.Int64Array,
+        value: Annotated[pa.Int64Array, Param(doc="Integer column to sum")],
+    ) -> None:
+        """Accumulate integer values into per-group totals."""
+        for i in range(len(group_ids)):
+            gid: int = group_ids[i].as_py()
+            v = value[i].as_py()
+            if v is not None:
+                states[gid] = SumState(total=states[gid].total + v)
+
+    @classmethod
+    def combine(cls, source: SumState, target: SumState, params: ProcessParams[None]) -> SumState:
+        """Merge two partial sums."""
+        return SumState(total=target.total + source.total)
+
+    @classmethod
+    def finalize(
+        cls,
+        group_ids: pa.Int64Array,
+        states: dict[int, SumState],
+        params: ProcessParams[None],
+    ) -> Annotated[pa.RecordBatch, Returns()]:
+        """Emit each group's sum, cast to the bind-time (secret-chosen) type."""
+        result_field = params.output_schema.field(0)
+        results = [s.total if (s := states[gid.as_py()]) is not None else None for gid in group_ids]
+        return pa.record_batch({result_field.name: pa.array(results, type=result_field.type)})