vgi-python 0.19.0__tar.gz → 0.20.0__tar.gz

{vgi_python-0.19.0 → vgi_python-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vgi-python
-Version: 0.19.0
+Version: 0.20.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.19.0 → vgi_python-0.20.0}/pyproject.toml

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

{vgi_python-0.19.0 → vgi_python-0.20.0}/tests/conformance/test_protocol_version.py

@@ -32,14 +32,14 @@ CLIENT_PROTOCOL_VERSION = VgiProtocol.protocol_version
 
 def test_client_protocol_version_is_canonical() -> None:
     """Sanity-check the constants this test reasons about haven't drifted apart."""
-    assert CLIENT_PROTOCOL_VERSION == "1.1.0"
+    assert CLIENT_PROTOCOL_VERSION == "1.2.0"
     # The fixture must be a genuine mismatch in the major/minor that the
     # framework compares; a patch-only difference would (correctly) pass.
     assert BAD_PROTOCOL_VERSION.split(".")[:2] != CLIENT_PROTOCOL_VERSION.split(".")[:2]
 
 
 def test_mismatched_worker_protocol_version_raises() -> None:
-    """A worker enforcing 99.0.0 must reject the 1.1.0 client at dispatch."""
+    """A worker enforcing 99.0.0 must reject the 1.2.0 client at dispatch."""
     with Client("vgi-fixture-bad-protocol-worker") as client, pytest.raises(ClientError) as exc_info:
         list(
             client.table_function(
@@ -54,5 +54,5 @@ def test_mismatched_worker_protocol_version_raises() -> None:
     assert "protocol_version mismatch" in message
     assert CLIENT_PROTOCOL_VERSION in message
     assert BAD_PROTOCOL_VERSION in message
-    # Directional hint: the client (1.1.0) is older than the worker (99.0.0).
+    # Directional hint: the client (1.2.0) is older than the worker (99.0.0).
     assert "upgrade the VGI extension/client" in message

{vgi_python-0.19.0 → vgi_python-0.20.0}/tests/landing/describe.expected.json

@@ -3,7 +3,7 @@
     {
       "attach_options": [],
       "counts": {
-        "functions": 209,
+        "functions": 217,
         "schemas": 2,
         "tables": 59,
         "views": 3
@@ -16,6 +16,19 @@
         {
           "doc": "Example tables backed by functions",
           "functions": [
+            {
+              "args": [
+                {
+                  "desc": "Integer value to accumulate",
+                  "name": "value",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Schema-disambiguation probe; the data-schema aggregate",
+              "name": "test_same_name_agg",
+              "returns": "string",
+              "type": "aggregate"
+            },
             {
               "args": [
                 {
@@ -28,6 +41,24 @@
               "name": "test_same_name_bind",
               "returns": "string",
               "type": "scalar"
+            },
+            {
+              "args": [],
+              "doc": "Schema-disambiguation probe; the data-schema cacheable producer",
+              "name": "test_same_name_cached",
+              "type": "table"
+            },
+            {
+              "args": [],
+              "doc": "Schema-disambiguation probe; the data-schema table-in-out",
+              "name": "test_same_name_transform",
+              "type": "table"
+            },
+            {
+              "args": [],
+              "doc": "Schema-disambiguation probe; the data-schema buffered function",
+              "name": "test_same_name_buffered",
+              "type": "table_in_out"
             }
           ],
           "name": "data",
@@ -371,6 +402,19 @@
               "returns": "null",
               "type": "aggregate"
             },
+            {
+              "args": [
+                {
+                  "desc": "Integer value to accumulate",
+                  "name": "value",
+                  "type": "int64"
+                }
+              ],
+              "doc": "Schema-disambiguation probe; the main-schema aggregate",
+              "name": "test_same_name_agg",
+              "returns": "string",
+              "type": "aggregate"
+            },
             {
               "args": [
                 {
@@ -2884,6 +2928,18 @@
               "name": "ten_thousand",
               "type": "table"
             },
+            {
+              "args": [],
+              "doc": "Schema-disambiguation probe; the main-schema cacheable producer",
+              "name": "test_same_name_cached",
+              "type": "table"
+            },
+            {
+              "args": [],
+              "doc": "Schema-disambiguation probe; the main-schema table-in-out",
+              "name": "test_same_name_transform",
+              "type": "table"
+            },
             {
               "args": [
                 {
@@ -3314,6 +3370,12 @@
               "doc": "Distributed sum using the buffered (Sink+Combine+Source) model",
               "name": "sum_all_columns_simple_distributed",
               "type": "table_in_out"
+            },
+            {
+              "args": [],
+              "doc": "Schema-disambiguation probe; the main-schema buffered function",
+              "name": "test_same_name_buffered",
+              "type": "table_in_out"
             }
           ],
           "name": "main",

{vgi_python-0.19.0 → vgi_python-0.20.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.same_name import SameNameDataAgg, SameNameMainAgg
 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
@@ -45,6 +46,8 @@ from vgi._test_fixtures.aggregate.window import (
 __all__ = [
     "AvgFunction",
     "CountFunction",
+    "SameNameDataAgg",
+    "SameNameMainAgg",
     "DynamicAggregateFunction",
     "DynamicMLAggregateFunction",
     "GenericSumFunction",

vgi_python-0.20.0/vgi/_test_fixtures/aggregate/same_name.py

@@ -0,0 +1,139 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+"""Same-name-in-two-schemas *aggregate* fixtures.
+
+The third member of the schema-disambiguation family, after
+:mod:`vgi._test_fixtures.scalar.same_name` (scalar) and
+:mod:`vgi._test_fixtures.table_in_out_same_name` (table-in-out + buffering).
+
+Aggregates are the widest surface of the three. Every aggregate RPC —
+``aggregate_update`` / ``_combine`` / ``_finalize`` / ``_destructor``, the four
+window calls, and the three streaming calls — resolves the function through the
+worker's single ``_resolve_aggregate`` entry point, which had no schema to work
+with: none of those request types carried one, not even ``AggregateBindRequest``.
+So an aggregate name declared in two schemas resolved to whichever the by-name
+lookup found first.
+
+Both classes register under ``test_same_name_agg``, in the ``main`` and ``data``
+schemas of the ``example`` catalog. Each returns a VARCHAR tagged with its own
+schema *and* the aggregated value, so a mis-routed call reads as the wrong tag
+rather than a plausible answer, and a call that mis-routes only partway (bind to
+one implementation, update/finalize to another) still shows up — the tag is
+stamped at ``finalize`` while the accumulation happens in ``update``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Annotated
+
+import pyarrow as pa
+from vgi_rpc import ArrowSerializableDataclass, ArrowType
+
+from vgi.aggregate_function import AggregateFunction
+from vgi.arguments import Param, Returns
+from vgi.metadata import (
+    DistinctDependence,
+    FunctionExample,
+    NullHandling,
+    OrderDependence,
+)
+from vgi.table_function import ProcessParams
+
+# Deliberately identical in both schemas — the collision is the point.
+FUNCTION_NAME = "test_same_name_agg"
+
+
+@dataclass(kw_only=True)
+class SameNameAggState(ArrowSerializableDataclass):
+    """Running total for one group."""
+
+    total: Annotated[int, ArrowType(pa.int64())] = 0
+
+
+class _SameNameAgg(AggregateFunction[SameNameAggState]):
+    """Shared body; each subclass supplies the schema it is declared in."""
+
+    #: Schema this implementation is registered into — the tag it stamps.
+    OWNING_SCHEMA: str = ""
+
+    @classmethod
+    def initial_state(cls, params: ProcessParams[None]) -> SameNameAggState:
+        """Start each group at zero."""
+        return SameNameAggState()
+
+    @classmethod
+    def update(
+        cls,
+        states: dict[int, SameNameAggState],
+        group_ids: pa.Int64Array,
+        value: Annotated[pa.Int64Array, Param(doc="Integer value to accumulate")],
+    ) -> None:
+        """Accumulate each row's value into its group."""
+        for gid, v in zip(group_ids.to_pylist(), value.to_pylist(), strict=True):
+            if v is None or gid is None:
+                continue
+            states[gid] = SameNameAggState(total=states[gid].total + v)
+
+    @classmethod
+    def combine(
+        cls,
+        source: SameNameAggState,
+        target: SameNameAggState,
+        params: ProcessParams[None],
+    ) -> SameNameAggState:
+        """Merge two partial states."""
+        return SameNameAggState(total=source.total + target.total)
+
+    @classmethod
+    def finalize(
+        cls,
+        group_ids: pa.Int64Array,
+        states: dict[int, SameNameAggState],
+        params: ProcessParams[None],
+    ) -> Annotated[pa.RecordBatch, Returns(pa.string())]:
+        """Tag each group's total with the owning schema."""
+        results = [f"{cls.OWNING_SCHEMA}:{states[gid.as_py()].total}" for gid in group_ids]
+        return pa.record_batch({"result": pa.array(results, type=pa.string())})
+
+
+class SameNameMainAgg(_SameNameAgg):
+    """``test_same_name_agg`` as declared in the ``main`` schema."""
+
+    OWNING_SCHEMA = "main"
+
+    class Meta:
+        """Function metadata."""
+
+        name = FUNCTION_NAME
+        description = "Schema-disambiguation probe; the main-schema aggregate"
+        null_handling = NullHandling.SPECIAL
+        order_dependent = OrderDependence.NOT_ORDER_DEPENDENT
+        distinct_dependent = DistinctDependence.NOT_DISTINCT_DEPENDENT
+        examples = [
+            FunctionExample(
+                sql="SELECT example.main.test_same_name_agg(n) FROM range(3) t(n)",
+                description="Returns 'main:3'",
+            ),
+        ]
+
+
+class SameNameDataAgg(_SameNameAgg):
+    """``test_same_name_agg`` as declared in the ``data`` schema."""
+
+    OWNING_SCHEMA = "data"
+
+    class Meta:
+        """Function metadata."""
+
+        name = FUNCTION_NAME
+        description = "Schema-disambiguation probe; the data-schema aggregate"
+        null_handling = NullHandling.SPECIAL
+        order_dependent = OrderDependence.NOT_ORDER_DEPENDENT
+        distinct_dependent = DistinctDependence.NOT_DISTINCT_DEPENDENT
+        examples = [
+            FunctionExample(
+                sql="SELECT example.data.test_same_name_agg(n) FROM range(3) t(n)",
+                description="Returns 'data:3'",
+            ),
+        ]

vgi_python-0.20.0/vgi/_test_fixtures/table/same_name_cached.py

@@ -0,0 +1,131 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+"""Cacheable same-name-in-two-schemas producer fixtures.
+
+The result-cache member of the schema-disambiguation family (see
+``scalar/same_name.py``, ``table_in_out_same_name.py``, ``aggregate/same_name.py``).
+Those probe *dispatch*; this one probes the *result cache*, a distinct layer.
+
+``test_same_name_cached`` is a one-row producer table function that advertises
+``vgi.cache.ttl`` and is registered in BOTH the ``main`` and ``data`` schemas of
+the ``example`` catalog. Each schema's implementation emits a single row tagged
+with its own schema name.
+
+The result cache keyed on catalog + auth + function name with no schema
+dimension, so the two implementations produced byte-identical cache keys and one
+schema's memoized rows cross-served the other — the caching-layer twin of the
+``(schema, name)`` dispatch bug. The tag makes a cross-serve visible:
+``example.data.test_same_name_cached()`` would return a ``main`` row. With the
+schema in the key, each schema gets its own entry (so ``vgi_result_cache()``
+holds two rows for the one function name) and returns its own tag. Driven by
+``cache/same_name_schemas.test``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import ClassVar, cast
+
+import pyarrow as pa
+from vgi_rpc import ArrowSerializableDataclass
+from vgi_rpc.rpc import OutputCollector
+
+from vgi.cache_control import CacheControl
+from vgi.metadata import FunctionExample
+from vgi.protocol import VgiOutputCollector
+from vgi.schema_utils import schema
+from vgi.table_function import (
+    ProcessParams,
+    TableFunctionGenerator,
+    bind_fixed_schema,
+    init_single_worker,
+)
+
+FUNCTION_NAME = "test_same_name_cached"
+
+# Long enough that the TTL never lapses mid-test.
+_TTL_SECONDS = 300
+
+
+@dataclass(slots=True, frozen=True)
+class _CachedArgs:
+    """Arguments for the cacheable same-name producer (none)."""
+
+
+@dataclass(kw_only=True)
+class _CachedState(ArrowSerializableDataclass):
+    """One-shot emit latch for the single output row."""
+
+    done: bool = False
+
+
+class _SameNameCached(TableFunctionGenerator[_CachedArgs, _CachedState]):
+    """Shared body; each subclass supplies the schema it is declared in."""
+
+    #: Schema this implementation is declared in — the tag it stamps.
+    OWNING_SCHEMA: ClassVar[str] = ""
+
+    FunctionArguments = _CachedArgs
+    FIXED_SCHEMA: ClassVar[pa.Schema] = schema(tag=pa.string())
+
+    @classmethod
+    def initial_state(cls, params: ProcessParams[_CachedArgs]) -> _CachedState:
+        """Fresh latch per (real, cache-missing) invocation."""
+        return _CachedState()
+
+    @classmethod
+    def process(
+        cls,
+        params: ProcessParams[_CachedArgs],
+        state: _CachedState,
+        out: OutputCollector,
+    ) -> None:
+        """Emit the single schema-tagged row once, advertising a cache TTL."""
+        if state.done:
+            out.finish()
+            return
+        batch = pa.RecordBatch.from_pydict({"tag": [cls.OWNING_SCHEMA]}, schema=params.output_schema)
+        cast(VgiOutputCollector, out).emit(batch, cache_control=CacheControl(ttl=_TTL_SECONDS))
+        state.done = True
+
+
+@init_single_worker
+@bind_fixed_schema
+class SameNameMainCached(_SameNameCached):
+    """``test_same_name_cached`` as declared in the ``main`` schema."""
+
+    OWNING_SCHEMA = "main"
+
+    class Meta:
+        """Function metadata."""
+
+        name = FUNCTION_NAME
+        description = "Schema-disambiguation probe; the main-schema cacheable producer"
+        categories = ["generator", "cache", "testing"]
+        examples = [
+            FunctionExample(
+                sql="SELECT * FROM example.main.test_same_name_cached()",
+                description="One cacheable row tagged 'main'",
+            ),
+        ]
+
+
+@init_single_worker
+@bind_fixed_schema
+class SameNameDataCached(_SameNameCached):
+    """``test_same_name_cached`` as declared in the ``data`` schema."""
+
+    OWNING_SCHEMA = "data"
+
+    class Meta:
+        """Function metadata."""
+
+        name = FUNCTION_NAME
+        description = "Schema-disambiguation probe; the data-schema cacheable producer"
+        categories = ["generator", "cache", "testing"]
+        examples = [
+            FunctionExample(
+                sql="SELECT * FROM example.data.test_same_name_cached()",
+                description="One cacheable row tagged 'data'",
+            ),
+        ]

vgi_python-0.20.0/vgi/_test_fixtures/table_in_out_same_name.py

@@ -0,0 +1,243 @@
+# Copyright 2025, 2026 Query Farm LLC - https://query.farm
+
+"""Same-name-in-two-schemas *exchange-mode* fixtures.
+
+The scalar analogue lives in :mod:`vgi._test_fixtures.scalar.same_name` and is
+driven by ``scalar/same_name_schemas.test``. This module covers the two
+exchange-mode shapes, which reach the worker through **different bind call
+sites** in the DuckDB extension than scalars do:
+
+* **table-in-out** (:class:`SameNameMainTransform` / :class:`SameNameDataTransform`)
+  — ``VgiTableInOutBind`` builds its bind-time connection directly rather than
+  going through ``AcquireAndBindConnection``.
+* **table-buffering** (:class:`SameNameMainBuffered` / :class:`SameNameDataBuffered`)
+  — shares that same bind site, but its *runtime* connections come from the
+  buffering operator's own ``BuildAcquireParams``.
+
+That distinction is the point. The extension originally threaded the owning
+schema onto the runtime exchange connections but not onto the bind-time one, so
+an exchange-mode call reached the worker with no ``BindRequest.schema_name`` and
+could not be resolved when the same name was declared in two schemas. The scalar
+fixture could not catch it — scalars bind through an entirely separate call site.
+
+Each class registers under a name shared with its sibling, in the ``main`` and
+``data`` schemas of the ``example`` catalog, and tags its rows with its own
+schema, so a mis-routed bind reads as the wrong tag rather than a plausible
+answer.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pyarrow as pa
+from vgi_rpc import ArrowSerializableDataclass
+from vgi_rpc.rpc import OutputCollector
+
+from vgi._test_fixtures.table_in_out import SingleTableArguments
+from vgi.invocation import BindResponse
+from vgi.metadata import FunctionExample
+from vgi.table_buffering_function import (
+    TableBufferingFunction,
+    TableBufferingParams,
+)
+from vgi.table_function import BindParams, ProcessParams
+from vgi.table_in_out_function import TableInOutGenerator
+
+# Deliberately shared across the two schemas — the collision is the point.
+TRANSFORM_NAME = "test_same_name_transform"
+BUFFERED_NAME = "test_same_name_buffered"
+
+# The single output column every implementation here emits.
+_OUTPUT_SCHEMA = pa.schema([pa.field("tag", pa.string())])
+
+
+def _tags(schema_name: str, batch: pa.RecordBatch) -> pa.RecordBatch:
+    """Render ``<schema_name>:<value>`` for every row of the first input column."""
+    return pa.RecordBatch.from_pydict(
+        {"tag": [None if v is None else f"{schema_name}:{v}" for v in batch.column(0).to_pylist()]},
+        schema=_OUTPUT_SCHEMA,
+    )
+
+
+@dataclass(kw_only=True)
+class _DrainState(ArrowSerializableDataclass):
+    """Cursor over the buffered state_log; ``after_id`` starts before-first."""
+
+    after_id: int = -1
+
+
+# ---------------------------------------------------------------------------
+# Table-in-out (streaming) pair
+# ---------------------------------------------------------------------------
+
+
+class _SameNameTransform(TableInOutGenerator[SingleTableArguments]):
+    """Shared body; each subclass supplies the schema it is declared in."""
+
+    #: Schema this implementation is registered into — the tag it stamps.
+    OWNING_SCHEMA: str = ""
+
+    @classmethod
+    def on_bind(cls, params: BindParams[SingleTableArguments]) -> BindResponse:
+        """Emit a single VARCHAR column regardless of the input schema."""
+        return BindResponse(output_schema=_OUTPUT_SCHEMA)
+
+    @classmethod
+    def process(
+        cls,
+        params: ProcessParams[SingleTableArguments],
+        state: None,
+        batch: pa.RecordBatch,
+        out: OutputCollector,
+    ) -> None:
+        """Tag each input row with the owning schema."""
+        out.emit(_tags(cls.OWNING_SCHEMA, batch))
+
+
+class SameNameMainTransform(_SameNameTransform):
+    """``test_same_name_transform`` as declared in the ``main`` schema."""
+
+    OWNING_SCHEMA = "main"
+
+    class Meta:
+        """Function metadata."""
+
+        name = TRANSFORM_NAME
+        description = "Schema-disambiguation probe; the main-schema table-in-out"
+        examples = [
+            FunctionExample(
+                sql=("SELECT * FROM example.main.test_same_name_transform((SELECT 1 AS n))"),
+                description="Returns 'main:1'",
+            ),
+        ]
+
+
+class SameNameDataTransform(_SameNameTransform):
+    """``test_same_name_transform`` as declared in the ``data`` schema."""
+
+    OWNING_SCHEMA = "data"
+
+    class Meta:
+        """Function metadata."""
+
+        name = TRANSFORM_NAME
+        description = "Schema-disambiguation probe; the data-schema table-in-out"
+        examples = [
+            FunctionExample(
+                sql=("SELECT * FROM example.data.test_same_name_transform((SELECT 1 AS n))"),
+                description="Returns 'data:1'",
+            ),
+        ]
+
+
+# ---------------------------------------------------------------------------
+# Table-buffering pair
+# ---------------------------------------------------------------------------
+
+
+class _SameNameBuffered(TableBufferingFunction[SingleTableArguments, _DrainState]):
+    """Shared body; buffers tagged rows in Sink, drains them in Source."""
+
+    #: Schema this implementation is registered into — the tag it stamps.
+    OWNING_SCHEMA: str = ""
+
+    @classmethod
+    def on_bind(cls, params: BindParams[SingleTableArguments]) -> BindResponse:
+        """Emit a single VARCHAR column regardless of the input schema."""
+        return BindResponse(output_schema=_OUTPUT_SCHEMA)
+
+    @classmethod
+    def process(
+        cls,
+        batch: pa.RecordBatch,
+        params: TableBufferingParams[SingleTableArguments],
+    ) -> bytes:
+        """Tag the batch in the Sink phase and buffer it for the Source phase.
+
+        Tagging here (rather than in ``finalize``) is deliberate: it proves the
+        SINK-side worker resolved the right implementation, which is a distinct
+        connection from the one the Source phase acquires.
+        """
+        sink = pa.BufferOutputStream()
+        tagged = _tags(cls.OWNING_SCHEMA, batch)
+        with pa.ipc.new_stream(sink, tagged.schema) as writer:
+            writer.write_batch(tagged)
+        params.storage.state_append(b"buf", b"", sink.getvalue().to_pybytes())
+        return params.execution_id
+
+    @classmethod
+    def combine(
+        cls,
+        state_ids: list[bytes],  # noqa: ARG003 - collapse to one finalize stream
+        params: TableBufferingParams[SingleTableArguments],
+    ) -> list[bytes]:
+        """Collapse every Sink bucket into one finalize stream."""
+        return [params.execution_id]
+
+    @classmethod
+    def initial_finalize_state(
+        cls,
+        finalize_state_id: bytes,  # noqa: ARG003 - one bucket per execution
+        params: TableBufferingParams[SingleTableArguments],  # noqa: ARG003
+    ) -> _DrainState:
+        """Start the drain cursor before the first buffered batch."""
+        return _DrainState(after_id=-1)
+
+    @classmethod
+    def finalize(
+        cls,
+        params: TableBufferingParams[SingleTableArguments],
+        finalize_state_id: bytes,  # noqa: ARG003
+        state: _DrainState,
+        out: OutputCollector,
+    ) -> None:
+        """Emit one buffered batch per tick."""
+        rows = params.storage.state_log_scan(
+            b"buf",
+            b"",
+            after_id=state.after_id,
+            limit=1,
+        )
+        if not rows:
+            out.finish()
+            return
+        log_id, value = rows[0]
+        out.emit(pa.ipc.open_stream(value).read_next_batch())
+        state.after_id = log_id
+
+
+class SameNameMainBuffered(_SameNameBuffered):
+    """``test_same_name_buffered`` as declared in the ``main`` schema."""
+
+    OWNING_SCHEMA = "main"
+
+    class Meta:
+        """Function metadata."""
+
+        name = BUFFERED_NAME
+        description = "Schema-disambiguation probe; the main-schema buffered function"
+        examples = [
+            FunctionExample(
+                sql=("SELECT * FROM example.main.test_same_name_buffered((SELECT 1 AS n))"),
+                description="Returns 'main:1'",
+            ),
+        ]
+
+
+class SameNameDataBuffered(_SameNameBuffered):
+    """``test_same_name_buffered`` as declared in the ``data`` schema."""
+
+    OWNING_SCHEMA = "data"
+
+    class Meta:
+        """Function metadata."""
+
+        name = BUFFERED_NAME
+        description = "Schema-disambiguation probe; the data-schema buffered function"
+        examples = [
+            FunctionExample(
+                sql=("SELECT * FROM example.data.test_same_name_buffered((SELECT 1 AS n))"),
+                description="Returns 'data:1'",
+            ),
+        ]