vgi-python 0.46.1__py3-none-any.whl → 0.48.0__py3-none-any.whl

vgi/__init__.py

@@ -79,6 +79,7 @@ from vgi.filter_v2_builder import (
     type_payload,
     value_payload,
 )
+from vgi.invocation import BindRepeatability
 from vgi.metadata import (
     ArgumentMonotonicity,
     CatalogFunctionType,
@@ -99,6 +100,8 @@ from vgi.metadata import (
 from vgi.protocol import (
     BindRequest,
     InitRequest,
+    TableFunctionProjectionRequest,
+    TableFunctionProjectionResponse,
     VgiOutputCollector,
 )
 from vgi.scalar_function import (
@@ -132,6 +135,8 @@ from vgi.worker import Worker
 from vgi.write_results import WriteOperation, WriteResultMode, write_changes_batch, write_result_schema
 
 __all__ = [
+    "TableFunctionProjectionRequest",
+    "TableFunctionProjectionResponse",
     "AggregateBindParams",
     "AggregateFunction",
     "WriteOperation",
@@ -151,6 +156,7 @@ __all__ = [
     "argument_specs_to_schema",
     "parameter_default_values_from_specs",
     "BindRequest",
+    "BindRepeatability",
     "ColumnBounds",
     "ColumnRefNode",
     "ComparisonNode",

vgi/_test_fixtures/accumulate/worker.py

@@ -69,6 +69,7 @@ from vgi.catalog.catalog_interface import AttachOpaqueData, CatalogAttachResult,
 from vgi.function_storage import BoundStorage, FunctionStorage
 from vgi.invocation import BindResponse
 from vgi.metadata import FunctionExample
+from vgi.protocol import ClientCapabilities
 from vgi.table_buffering_function import TableBufferingFunction, TableBufferingParams
 from vgi.table_function import (
     BindParams,
@@ -734,6 +735,7 @@ class AccumulateCatalog(ReadOnlyCatalogInterface):
         options: dict[str, Any],
         data_version_spec: str | None,
         implementation_version: str | None,
+        client_capabilities: ClientCapabilities | None = None,
         ctx: CallContext | None = None,
     ) -> CatalogAttachResult:
         """Attach, minting a random per-ATTACH storage scope id."""
@@ -742,6 +744,7 @@ class AccumulateCatalog(ReadOnlyCatalogInterface):
             options=options,
             data_version_spec=data_version_spec,
             implementation_version=implementation_version,
+            client_capabilities=client_capabilities,
             ctx=ctx,
         )
         return dataclasses.replace(

vgi/_test_fixtures/attach_options.py

@@ -46,6 +46,7 @@ from vgi.catalog.catalog_interface import (
 )
 from vgi.catalog.descriptors import Catalog, Schema
 from vgi.invocation import BindResponse
+from vgi.protocol import ClientCapabilities
 from vgi.schema_utils import schema
 from vgi.table_function import BindParams, ProcessParams, TableFunctionGenerator, init_single_worker
 from vgi.worker import Worker
@@ -260,6 +261,7 @@ class AttachOptionsCatalog(ReadOnlyCatalogInterface):
         options: dict[str, Any],
         data_version_spec: str | None,
         implementation_version: str | None,
+        client_capabilities: ClientCapabilities | None = None,
         ctx: CallContext | None = None,
     ) -> CatalogAttachResult:
         del data_version_spec, implementation_version, ctx

vgi/_test_fixtures/bad_protocol.py

@@ -51,7 +51,7 @@ class BadProtocol(VgiProtocol):
     # finds no such protocol hosted, and the caller gets
     # ``ProtocolNotSupportedError`` before the version gate it came to test
     # ever runs.
-    protocol_name: ClassVar[str] = "vgi.v2"
+    protocol_name: ClassVar[str] = "vgi.v3"
     protocol_version: ClassVar[str] = BAD_PROTOCOL_VERSION
 
 

vgi/_test_fixtures/catalog.py

@@ -8,13 +8,13 @@ be used for testing and as a reference implementation.
 
 from __future__ import annotations
 
+import dataclasses
 import uuid
 from collections.abc import Sequence
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Literal, overload
 
 if TYPE_CHECKING:
-    import pyarrow as pa
     from vgi_rpc.rpc import CallContext
 
 from vgi._redact import short_hash
@@ -35,7 +35,11 @@ from vgi.catalog import (
     TransactionOpaqueData,
     ViewInfo,
 )
+from vgi.catalog.layout import TableLayout
+from vgi.catalog.macros import MacroOverload
+from vgi.protocol import ClientCapabilities
 from vgi.schema_path import SchemaKey, schema_path_key
+from vgi.typed_values import TypedValueBatch
 from vgi.worker import Worker
 
 
@@ -154,6 +158,7 @@ class InMemoryCatalog(CatalogInterface):
         options: dict[str, Any],
         data_version_spec: str | None,
         implementation_version: str | None,
+        client_capabilities: ClientCapabilities | None = None,
         ctx: CallContext | None = None,
     ) -> CatalogAttachResult:
         """Attach to a catalog with the given name.
@@ -354,19 +359,27 @@ class InMemoryCatalog(CatalogInterface):
         on_conflict: OnConflict = OnConflict.ERROR,
         comment: str | None,
         tags: dict[str, str],
+        options: TypedValueBatch | None = None,
     ) -> None:
         """Create a new schema."""
+        if options is not None:
+            raise NotImplementedError("Schema options are not supported by this fixture")
         catalog = self._get_catalog(attach_opaque_data)
         path_key = schema_path_key(path)
         if path_key in catalog.schemas:
-            msg = f"Schema {path!r} already exists"
-            raise ValueError(msg)
+            if on_conflict == OnConflict.IGNORE:
+                return
+            if on_conflict != OnConflict.REPLACE:
+                msg = f"Schema {path!r} already exists"
+                raise ValueError(msg)
+        if len(path) > 1 and schema_path_key(path[:-1]) not in catalog.schemas:
+            raise ValueError("Parent schema does not exist")
         catalog.schemas[path_key] = SchemaData(
             info=SchemaInfo(
                 attach_opaque_data=attach_opaque_data,
                 path=list(path),
                 comment=comment,
-                tags=tags,
+                tags=dict(tags),
             )
         )
         self._increment_version(attach_opaque_data)
@@ -507,13 +520,18 @@ class InMemoryCatalog(CatalogInterface):
         name: str,
         columns: SerializedSchema,
         on_conflict: OnConflict,
-        not_null_constraints: list[int],
-        unique_constraints: list[list[int]],
-        check_constraints: list[str],
-        primary_key_constraints: list[list[int]] | None = None,
-        foreign_key_constraints: list[bytes] | None = None,
+        constraint_definitions: list[bytes],
+        comment: str | None = None,
+        tags: dict[str, str] | None = None,
+        options: TypedValueBatch | None = None,
+        layout: TableLayout | None = None,
     ) -> None:
         """Create a new table."""
+        if constraint_definitions:
+            raise NotImplementedError("this metadata-only catalog does not enforce canonical constraints")
+        if any(value is not None for value in (comment, tags, options, layout)):
+            raise NotImplementedError("table creation metadata/options/layout profiles are not supported")
+
         schema_data = self._get_schema(attach_opaque_data, schema_path)
         if name in schema_data.tables:
             if on_conflict == OnConflict.ERROR:
@@ -528,9 +546,7 @@ class InMemoryCatalog(CatalogInterface):
                 name=name,
                 schema_path=schema_path,
                 columns=columns,
-                not_null_constraints=not_null_constraints,
-                unique_constraints=unique_constraints,
-                check_constraints=check_constraints,
+                constraints=[],
                 comment=None,
                 tags={},
             )
@@ -582,9 +598,8 @@ class InMemoryCatalog(CatalogInterface):
                 name=old_info.name,
                 schema_path=old_info.schema_path,
                 columns=old_info.columns,
-                not_null_constraints=old_info.not_null_constraints,
-                unique_constraints=old_info.unique_constraints,
-                check_constraints=old_info.check_constraints,
+                constraints=old_info.constraints,
+                definition_revision=old_info.definition_revision,
                 comment=comment,
                 tags=old_info.tags,
             )
@@ -619,9 +634,8 @@ class InMemoryCatalog(CatalogInterface):
                 name=new_name,
                 schema_path=old_info.schema_path,
                 columns=old_info.columns,
-                not_null_constraints=old_info.not_null_constraints,
-                unique_constraints=old_info.unique_constraints,
-                check_constraints=old_info.check_constraints,
+                constraints=old_info.constraints,
+                definition_revision=old_info.definition_revision,
                 comment=old_info.comment,
                 tags=old_info.tags,
             )
@@ -637,8 +651,15 @@ class InMemoryCatalog(CatalogInterface):
         name: str,
         definition: str,
         on_conflict: OnConflict,
+        aliases: list[str] | None = None,
+        security: str = "regular",
+        comment: str | None = None,
+        tags: dict[str, str] | None = None,
+        column_comments: dict[str, str] | None = None,
     ) -> None:
         """Create a new view."""
+        if security != "regular":
+            raise NotImplementedError("view security mode is unsupported by this provider")
         schema_data = self._get_schema(attach_opaque_data, schema_path)
         if name in schema_data.views:
             if on_conflict == OnConflict.ERROR:
@@ -653,8 +674,10 @@ class InMemoryCatalog(CatalogInterface):
                 name=name,
                 schema_path=schema_path,
                 definition=definition,
-                comment=None,
-                tags={},
+                aliases=list(aliases or []),
+                comment=comment,
+                tags=dict(tags or {}),
+                column_comments=dict(column_comments or {}),
             )
         )
         self._increment_version(attach_opaque_data)
@@ -707,6 +730,9 @@ class InMemoryCatalog(CatalogInterface):
                 name=new_name,
                 schema_path=old_info.schema_path,
                 definition=old_info.definition,
+                aliases=list(old_info.aliases),
+                security=old_info.security,
+                column_comments=dict(old_info.column_comments),
                 comment=old_info.comment,
                 tags=old_info.tags,
             )
@@ -738,12 +764,43 @@ class InMemoryCatalog(CatalogInterface):
                 name=old_info.name,
                 schema_path=old_info.schema_path,
                 definition=old_info.definition,
+                aliases=list(old_info.aliases),
+                security=old_info.security,
+                column_comments=dict(old_info.column_comments),
                 comment=comment,
                 tags=old_info.tags,
             )
         )
         self._increment_version(attach_opaque_data)
 
+    def view_column_comment_set(
+        self,
+        *,
+        attach_opaque_data: AttachOpaqueData,
+        transaction_opaque_data: TransactionOpaqueData | None,
+        schema_path: list[str],
+        name: str,
+        column_path: list[str],
+        comment: str | None,
+        ignore_not_found: bool,
+    ) -> None:
+        """Set or clear the comment keyed by a raw view output name."""
+        if len(column_path) != 1 or not column_path[0] or "\0" in column_path[0]:
+            raise ValueError("view column comments require one raw output identifier")
+        schema_data = self._get_schema(attach_opaque_data, schema_path)
+        view = schema_data.views.get(name)
+        if view is None:
+            if ignore_not_found:
+                return
+            raise ValueError(f"View {name!r} not found in schema {schema_path!r}")
+        comments = dict(view.info.column_comments)
+        if comment is None:
+            comments.pop(column_path[0], None)
+        else:
+            comments[column_path[0]] = comment
+        schema_data.views[name] = ViewData(info=dataclasses.replace(view.info, column_comments=comments))
+        self._increment_version(attach_opaque_data)
+
     def macro_create(
         self,
         *,
@@ -752,11 +809,8 @@ class InMemoryCatalog(CatalogInterface):
         schema_path: list[str],
         name: str,
         macro_type: MacroType,
-        parameters: list[str],
-        definition: str,
+        overloads: list[MacroOverload],
         on_conflict: OnConflict,
-        parameter_default_values: pa.RecordBatch | None = None,
-        arguments_schema: pa.Schema | None = None,
     ) -> None:
         """Create a new macro."""
         schema_data = self._get_schema(attach_opaque_data, schema_path)
@@ -773,12 +827,9 @@ class InMemoryCatalog(CatalogInterface):
                 name=name,
                 schema_path=schema_path,
                 macro_type=macro_type,
-                parameters=parameters,
-                parameter_default_values=parameter_default_values,
-                definition=definition,
+                overloads=overloads,
                 comment=None,
                 tags={},
-                arguments_schema=arguments_schema,
             )
         )
         self._increment_version(attach_opaque_data)

vgi/_test_fixtures/catalog_contents.py

@@ -78,6 +78,7 @@ from vgi.catalog import (
     Table,
     View,
 )
+from vgi.protocol import ClientCapabilities
 from vgi.worker import Worker
 
 CATALOG_PROBE = "contents_probe"
@@ -232,6 +233,7 @@ class _PrivateMemoryCatalog(InMemoryCatalog):
         options: dict[str, Any],
         data_version_spec: str | None,
         implementation_version: str | None,
+        client_capabilities: ClientCapabilities | None = None,
         ctx: Any = None,
     ) -> CatalogAttachResult:
         """Attach a fresh private catalog, advertising ``catalog_contents``."""
@@ -248,6 +250,7 @@ class _PrivateMemoryCatalog(InMemoryCatalog):
             options=options,
             data_version_spec=data_version_spec,
             implementation_version=implementation_version,
+            client_capabilities=client_capabilities,
             ctx=ctx,
         )
         return replace(

vgi/_test_fixtures/constraint_facts.py

@@ -0,0 +1,45 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+"""Explicit facts for fixed fixture tables; never an inference from Arrow flags.
+
+Callers own the proof: immutable rows are checked before publication, or every
+fixture storage write validates values. Keys are fixed provider-owned identifiers
+for tables whose definitions cannot be dropped/recreated through their API.
+"""
+
+from typing import Any
+
+from vgi.catalog.constraints import (
+    ConstraintDefinition,
+    ConstraintEnforcement,
+    ConstraintInfo,
+    ConstraintKind,
+    ConstraintValidation,
+)
+from vgi.catalog.dependencies import CatalogObjectRef
+
+
+def fixed_fact(
+    table: str, path: list[str], key: str, definition: ConstraintDefinition, **kwargs: Any
+) -> ConstraintInfo:
+    """Attach an explicit fixture definition to its stable provider-owned key."""
+    return ConstraintInfo(
+        ref=CatalogObjectRef(kind="constraint", schema_path=path, owner_table=table, name=key),
+        definition=definition,
+        enforcement=ConstraintEnforcement.ENFORCED,
+        validation=ConstraintValidation.ALL_ROWS,
+        **kwargs,
+    )
+
+
+def fixed_not_null(table: str, path: list[str], columns: tuple[tuple[str, ...], ...]) -> tuple[ConstraintInfo, ...]:
+    """Encode explicit NOT_NULL facts that the fixed fixture actually enforces."""
+    return tuple(
+        fixed_fact(
+            table,
+            path,
+            f"not-null-{index}",
+            ConstraintDefinition(kind=ConstraintKind.NOT_NULL, column_paths=[list(column)]),
+        )
+        for index, column in enumerate(columns)
+    )

vgi/_test_fixtures/http_server.py

@@ -310,16 +310,6 @@ def main() -> None:
             )
             sys.stderr.flush()
 
-        import socket
-
-        if port == 0:
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                s.bind((host, 0))
-                port = int(s.getsockname()[1])
-
-        if demo_storage:
-            demo_blob_storage.set_base_url(f"http://{host}:{port}")
-
         from vgi.serve import _resolve_authenticate, _resolve_oauth_resource_metadata
 
         authenticate = _resolve_authenticate()
@@ -487,6 +477,15 @@ def main() -> None:
         # we serve the Falcon app directly.
         serving_app: Any = wsgi_app
 
+        # Keep the selected socket bound while publishing its port. Selecting
+        # and releasing a free port first lets another test worker take it.
+        # Auto-selection has always used IPv4; retain one listener for port 0.
+        http_server = waitress.create_server(serving_app, host=host, port=port, ipv6=port != 0)
+        if port == 0:
+            port = int(http_server.effective_port)
+        if demo_storage:
+            demo_blob_storage.set_base_url(f"http://{host}:{port}")
+
         if port_file is not None:
             # Atomic side-channel publication so test harnesses can watch
             # for the file without racing a partial write. Same helper the
@@ -498,7 +497,7 @@ def main() -> None:
         print(f"PORT:{port}", flush=True)
         sys.stderr.write(f"Serving ExampleWorker on http://{host}:{port}{prefix}\n")
         sys.stderr.flush()
-        waitress.serve(serving_app, host=host, port=port, _quiet=True)
+        http_server.run()
 
     app()
 

vgi/_test_fixtures/narrow_bind/worker.py

@@ -156,9 +156,7 @@ class NarrowBindCatalog(ReadOnlyCatalogInterface):
             name=table_name,
             schema_path=["main"],
             columns=SerializedSchema(_serialize_schema(_TABLE_SCHEMA)),
-            not_null_constraints=[],
-            unique_constraints=[],
-            check_constraints=[],
+            constraints=[],
         )
 
     def schemas(

vgi/_test_fixtures/projection_repro/worker.py

@@ -42,8 +42,10 @@ from vgi_rpc import ArrowSerializableDataclass
 from vgi_rpc.rpc import OutputCollector
 
 from vgi import Worker
+from vgi._test_fixtures.constraint_facts import fixed_not_null
 from vgi.arguments import Arg
 from vgi.catalog import Catalog, Schema
+from vgi.catalog.capabilities import CONSTRAINT_RECORDS_READ, CatalogCapabilities
 from vgi.catalog.catalog_interface import (
     AttachOpaqueData,
     ReadOnlyCatalogInterface,
@@ -357,6 +359,10 @@ class ProjReproCatalog(ReadOnlyCatalogInterface):
     catalog = _CATALOG
     catalog_name = CATALOG_NAME
 
+    def catalog_capabilities(self, *, attach_opaque_data: AttachOpaqueData) -> CatalogCapabilities:
+        """The generator always supplies these four fields and exposes no writes."""
+        return CatalogCapabilities(read=[CONSTRAINT_RECORDS_READ])
+
     def _info(self, table_name: str) -> TableInfo:
         return TableInfo(
             comment=f"reproducer table -> {_TABLE_NAMES[table_name]}",
@@ -364,9 +370,12 @@ class ProjReproCatalog(ReadOnlyCatalogInterface):
             name=table_name,
             schema_path=["main"],
             columns=SerializedSchema(_serialize_schema(WIDE_SCHEMA)),
-            not_null_constraints=[],
-            unique_constraints=[],
-            check_constraints=[],
+            constraints=[
+                fact.serialize_to_bytes()
+                for fact in fixed_not_null(
+                    table_name, ["main"], (("topic",), ("partition",), ("offset",), ("headers",))
+                )
+            ],
         )
 
     def schemas(

vgi/_test_fixtures/schema_reconcile/worker.py

@@ -37,7 +37,9 @@ import pyarrow as pa
 from vgi_rpc.rpc import OutputCollector
 
 from vgi import Worker
+from vgi._test_fixtures.constraint_facts import fixed_not_null
 from vgi.catalog import Catalog, Schema
+from vgi.catalog.capabilities import CONSTRAINT_ENFORCE, CONSTRAINT_RECORDS_READ, CatalogCapabilities
 from vgi.catalog.catalog_interface import (
     AttachOpaqueData,
     ReadOnlyCatalogInterface,
@@ -56,6 +58,7 @@ from vgi.table_function import (
     TableFunctionGenerator,
 )
 from vgi.table_in_out_function import TableInOutGenerator
+from vgi.typed_values import TypedValueBatch
 
 CATALOG_NAME = "schema_reconcile"
 _SCHEMA_NAME = "main"
@@ -217,6 +220,7 @@ def _all_rows(spec: TableSpec) -> list[tuple[Any, dict[str, Any]]]:
 
 
 def _insert_row(spec: TableSpec, rid: Any, payload: dict[str, Any]) -> None:
+    TypedValueBatch(pa.RecordBatch.from_pylist([{**payload, "rowid": rid}], schema=spec.table_schema))
     with _lock, _connect() as conn:
         conn.execute(
             f"INSERT OR REPLACE INTO {spec.storage_table} (rid_blob, payload) VALUES (?, ?)",
@@ -234,6 +238,7 @@ def _update_row(spec: TableSpec, rid: Any, updates: dict[str, Any]) -> bool:
             return False
         payload = pickle.loads(row[0])
         payload.update(updates)
+        TypedValueBatch(pa.RecordBatch.from_pylist([{**payload, "rowid": rid}], schema=spec.table_schema))
         conn.execute(
             f"UPDATE {spec.storage_table} SET payload = ? WHERE rid_blob = ?",
             (pickle.dumps(payload), _rid_key(rid)),
@@ -518,16 +523,27 @@ class SchemaReconcileCatalog(ReadOnlyCatalogInterface):
     catalog = _CATALOG
     catalog_name = CATALOG_NAME
 
+    def catalog_capabilities(self, *, attach_opaque_data: AttachOpaqueData) -> CatalogCapabilities:
+        """Every fixture insert/update checks required values before publication."""
+        return CatalogCapabilities(read=[CONSTRAINT_RECORDS_READ], write=[CONSTRAINT_ENFORCE])
+
     def _table_info(self, spec: TableSpec) -> TableInfo:
+        # Qualify ALL_ROWS for storage created by a previous fixture process,
+        # as well as the writes validated by the current implementation.
+        for rid, payload in _all_rows(spec):
+            TypedValueBatch(pa.RecordBatch.from_pylist([{**payload, "rowid": rid}], schema=spec.table_schema))
         return TableInfo(
             comment=f"Schema-reconcile {spec.name} (rowid type {spec.rowid_field.type})",
             tags={},
             name=spec.name,
             schema_path=[_SCHEMA_NAME],
             columns=SerializedSchema(_serialize_schema(spec.table_schema)),
-            not_null_constraints=[],
-            unique_constraints=[],
-            check_constraints=[],
+            constraints=[
+                fact.serialize_to_bytes()
+                for fact in fixed_not_null(
+                    spec.name, [_SCHEMA_NAME], (("id",), ("ts",), ("nested",), ("nested", "a"), ("tags",))
+                )
+            ],
             write_result_modes={"insert": "changes", "update": "changes", "delete": "changes"},
         )
 

vgi/_test_fixtures/simple_writable.py

@@ -56,6 +56,7 @@ from vgi.catalog import (
 )
 from vgi.catalog.descriptors import Catalog, Schema
 from vgi.invocation import BindResponse, GlobalInitResponse
+from vgi.protocol import ClientCapabilities
 from vgi.schema_utils import schema as build_schema
 from vgi.table_function import BindParams, InitParams, ProcessParams, TableFunctionGenerator
 from vgi.table_in_out_function import TableInOutGenerator
@@ -336,6 +337,7 @@ class SimpleScan(TableFunctionGenerator[None, "_ScanState"]):
         state.cursor = len(state.rows)
         arrow_arrays = [pa.array(col, type=state.schema.field(i).type) for i, col in enumerate(col_arrays)]
         out.emit(pa.RecordBatch.from_arrays(arrow_arrays, schema=state.schema))
+        out.finish()
 
 
 @dataclass(kw_only=True)
@@ -599,6 +601,7 @@ class SimpleWritableCatalog(ReadOnlyCatalogInterface):
         options: dict[str, Any],
         data_version_spec: str | None,
         implementation_version: str | None,
+        client_capabilities: ClientCapabilities | None = None,
         ctx: Any | None = None,
     ) -> CatalogAttachResult:
         del options, data_version_spec, implementation_version, ctx
@@ -653,11 +656,7 @@ class SimpleWritableCatalog(ReadOnlyCatalogInterface):
             name=name,
             schema_path=schema_path,
             columns=SerializedSchema(full.serialize().to_pybytes()),
-            not_null_constraints=[],
-            unique_constraints=[],
-            check_constraints=[],
-            primary_key_constraints=[],
-            foreign_key_constraints=[],
+            constraints=[],
             write_result_modes={
                 operation: _table_result_mode(name)
                 for operation, supported in (("insert", True), ("update", ud), ("delete", ud))

vgi/_test_fixtures/table/cache.py

@@ -30,6 +30,7 @@ from dataclasses import dataclass
 from typing import Annotated, Any, ClassVar, cast
 
 import pyarrow as pa
+import pyarrow.compute as pc
 from vgi_rpc import ArrowSerializableDataclass
 from vgi_rpc.rpc import OutputCollector
 
@@ -945,7 +946,7 @@ class CacheBenchFunction(TableFunctionGenerator[CacheBenchArgs, _CacheCountdownS
 # sequence [0..rows) so COUNT=rows and SUM=rows*(rows-1)/2 regardless of how the
 # chunks were distributed across workers. Positional Arg(0) so the direct path
 # `vgi_table_function(w, 'cache_parallel', [rows])` honors the size; a named
-# `batch_size` (default 24000) controls batch width for the 2 GB streaming guard.
+# `batch_size` (default 24000) controls batch width for the disk-streaming guard (parallel_2gb.test_slow).
 _PC_ITEM_FMT = ">QQ"  # (start, end) as two uint64
 _PC_ITEM_SIZE = struct.calcsize(_PC_ITEM_FMT)
 
@@ -1001,6 +1002,16 @@ class CacheParallelFunction(TableFunctionGenerator[CacheParallelArgs, _CachePara
 
     FunctionArguments = CacheParallelArgs
 
+    _OFFSETS: ClassVar[dict[int, pa.Int64Array]] = {}
+
+    @classmethod
+    def _offsets(cls, n: int) -> pa.Int64Array:
+        """0 .. n-1 as int64, built once per batch size per process."""
+        arr = cls._OFFSETS.get(n)
+        if arr is None:
+            arr = cls._OFFSETS[n] = pa.array(range(n), type=pa.int64())
+        return arr
+
     @classmethod
     def on_init(cls, params: InitParams[CacheParallelArgs]) -> GlobalInitResponse:
         """Primary worker enqueues (start, end) chunks covering [0, rows)."""
@@ -1032,8 +1043,11 @@ class CacheParallelFunction(TableFunctionGenerator[CacheParallelArgs, _CachePara
             state.current_idx = state.current_start
 
         batch_end = min(state.current_idx + params.args.batch_size, state.current_end or 0)
-        values = list(range(state.current_idx, batch_end))
-        batch = pa.RecordBatch.from_pydict({"v": values}, schema=params.output_schema)
+        # v = current_idx .. batch_end-1, as one vectorised add to a cached 0..n-1
+        # (a Python list costs ~1 µs a row, which the 640 MB streaming guard pays 80M times).
+        base = cls._offsets(params.args.batch_size).slice(0, batch_end - state.current_idx)
+        values = pc.add(base, pa.scalar(state.current_idx, type=pa.int64()))
+        batch = pa.RecordBatch.from_arrays([values], schema=params.output_schema)
         cache_control = CacheControl(ttl=_DEFAULT_TTL_SECONDS) if not state.advertised else None
         cast(VgiOutputCollector, out).emit(batch, cache_control=cache_control)
         state.advertised = True

vgi/_test_fixtures/table/catalog_scans.py

@@ -18,6 +18,8 @@ from vgi.table_function import (
     init_single_worker,
 )
 
+STATIC_CATALOG_ROWS: dict[str, pa.Table] = {}
+
 
 def _static_scan_function(
     func_name: str,
@@ -31,6 +33,7 @@ def _static_scan_function(
     return a fixed dataset. Each generated class is decorated with
     ``@init_single_worker`` and has a unique ``Meta.name``.
     """
+    STATIC_CATALOG_ROWS[func_name] = pa.Table.from_pydict(data, schema=output_schema)
 
     @init_single_worker
     class StaticScanFunction(TableFunctionGenerator[_EmptyArgs, _OneShotState]):

vgi/_test_fixtures/table/splits.py

@@ -1113,6 +1113,12 @@ def _render_filters_canonical(filters: PushdownFilters | None) -> str:
     for c in columns:
         bounds = filters.get_column_bounds(c)
         if bounds is None:
+            # DuckDB 2.0 can send an exact IN set without redundant range
+            # predicates. Render its integer envelope in the same canonical form.
+            values = filters.get_column_values(c)
+            discrete = [] if values is None else [_bound_as_int(value) for value in values if value.is_valid]
+            if discrete:
+                parts.extend((f"{c}>={min(discrete)}", f"{c}<={max(discrete)}"))
             continue
         # Normalized to INCLUSIVE integer bounds, because that is the only form
         # every SDK can produce: Rust's ColumnBounds is integer-coerced and