test(filter-v2): cover the bare boolean predicate where it can actually fail

The fix alone is not a guard. Two places had to gain a case, and neither
was the obvious one.

`bool_filter_echo` is a table function with a nullable BOOLEAN column
(`flag` cycling TRUE, FALSE, NULL) that echoes the SQL rendering of what was
pushed. It exists because nothing else could express the shape:

  - `filter_echo` has no boolean column, so `WHERE flag` cannot be written
    against it at all.
  - The table-in-out `example.echo` path is not handed a bare boolean column
    as a pushed predicate. Cases written there pass whether or not the
    worker can decode one -- I checked, by reverting the fix and watching
    them stay green. A test that cannot fail is worse than no test.

It takes a TABLE FUNCTION with a boolean column to see the shape at all,
which is how a filter-pushdown suite of 348 files -- including one dedicated
to booleans, added to close a boolean coverage gap -- missed a decoder that
refused every `WHERE flag` there is.

Echoing `pushed_filters` covers both halves: the rows prove the decode, and
the rendering proves `to_sql()` emits something. A shape that parses but
renders no SQL reads as "(none)" there, and for a worker that builds a WHERE
clause from it that is silently wrong rows -- DuckDB does not re-apply a
predicate it pushed into a table function.

The conformance corpus gains `structural.boolean-column-predicate`, a
positive case for a bare `column_ref` root and for `not` over one. That is
the cross-port contract, and its absence is why this is not a Python bug so
much as a Python *sighting*: every port's decoder is free to have the same
gap, and none had a case that would say so.

`bool_filter_echo` is excluded from function_registration.test's portable
baseline for now -- counting it would fail every SDK fixture worker that has
not shipped it. It belongs in the baseline (167) once they do.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: rustyconover

conformance/filter-v2/cases/positive/boolean-column-predicate.json

@@ -0,0 +1,32 @@
+{
+  "encoding": "vgi.filters.v2",
+  "semantics": "vgi.duckdb.standard.v1",
+  "kind": "snapshot",
+  "predicates": [
+    {
+      "id": "query:bare-boolean-column",
+      "revision": 0,
+      "mode": "required",
+      "source": "query",
+      "expression": {
+        "node": "column_ref",
+        "column_index": 0,
+        "column_name": "flag"
+      }
+    },
+    {
+      "id": "query:negated-boolean-column",
+      "revision": 0,
+      "mode": "required",
+      "source": "query",
+      "expression": {
+        "node": "not",
+        "expression": {
+          "node": "column_ref",
+          "column_index": 1,
+          "column_name": "other_flag"
+        }
+      }
+    }
+  ]
+}

conformance/filter-v2/manifest.json

@@ -30,6 +30,11 @@
       "document": "cases/positive/runtime-filter-snapshot.json",
       "expected": "valid"
     },
+    {
+      "id": "structural.boolean-column-predicate",
+      "document": "cases/positive/boolean-column-predicate.json",
+      "expected": "valid"
+    },
     {
       "id": "structural.and-too-few-children",
       "document": "cases/negative/and-too-few-children.json",

vgi/_test_fixtures/table/__init__.py

@@ -65,6 +65,7 @@
     ProjectsScanFunction,
 )
 from vgi._test_fixtures.table.filters import (
+    BoolFilterEchoFunction,
     DictFilterEchoFunction,
     DynamicFilterEchoFunction,
     ExpressionFilterTestFunction,
@@ -216,6 +217,7 @@
     "ConstantColumnsFunction",
     "CountryPartitionedSalesFunction",
     "DepartmentsScanFunction",
+    "BoolFilterEchoFunction",
     "DictFilterEchoFunction",
     "DisjointRangePartitionedFunction",
     "DoubleSequenceFunction",

vgi/_test_fixtures/table/filters.py

@@ -191,6 +191,129 @@ def process(
         state.remaining -= size
 
 
+# ============================================================================
+# BoolFilterEchoFunction — a table function with a BOOLEAN column, so the
+# bare-column predicate shapes (`WHERE flag`, `WHERE NOT flag`) can be driven
+# end to end.
+#
+# filter_echo cannot cover these: its schema has no boolean column, so the
+# predicate cannot even be written. The table-in-out `echo` path cannot either
+# — DuckDB does not hand it a bare boolean column as a pushed predicate, so a
+# test written there passes whether or not the worker can decode one. It takes
+# a TABLE FUNCTION with a boolean column to see the shape at all, which is why
+# a decoder that refused every one of them ("predicate root must resolve to
+# BOOLEAN", vgi-python < 0.36.2) went unnoticed by a filter-pushdown suite of
+# 348 files including one dedicated to booleans.
+#
+# `pushed_filters` echoes the SQL rendering, so this covers both halves: the
+# decode (the rows are auto-applied and must be right) and `to_sql()` (a shape
+# that parses but renders nothing would show up here as "(none)").
+# ============================================================================
+
+
+@dataclass(slots=True, frozen=True)
+class _BoolFilterEchoArgs:
+    """Arguments for BoolFilterEchoFunction."""
+
+    count: Annotated[int, Arg(0, doc="Number of rows to generate", ge=0)]
+
+
+@dataclass(kw_only=True)
+class _BoolFilterEchoState(ArrowSerializableDataclass):
+    """Remaining rows plus the echoed SQL rendering of the pushed filters."""
+
+    remaining: int
+    current_index: int = 0
+    filter_str: str = "(none)"
+
+
+@init_single_worker
+@bind_fixed_schema
+@_cardinality_from_count
+class BoolFilterEchoFunction(TableFunctionGenerator[_BoolFilterEchoArgs, _BoolFilterEchoState]):
+    """Rows with a nullable BOOLEAN column, echoing the pushed-down filters.
+
+    SCHEMA
+    ------
+    Output: {"n": int64, "flag": bool, "pushed_filters": string}
+
+    ``flag`` cycles TRUE, FALSE, NULL so every predicate is exercised against
+    all three truth values -- the NULL row is what distinguishes ``WHERE flag``
+    from ``WHERE flag IS NOT FALSE``, and ``WHERE NOT flag`` from
+    ``WHERE flag IS NOT TRUE``.
+
+    Attributes:
+        FIXED_SCHEMA: The fixed Arrow output schema this function always produces.
+
+    """
+
+    class Meta:
+        """Metadata for BoolFilterEchoFunction."""
+
+        name = "bool_filter_echo"
+        description = "Rows with a nullable BOOLEAN column, echoing pushed-down filters"
+        categories = ["generator", "diagnostic"]
+        filter_pushdown = True
+        auto_apply_filters = True
+        projection_pushdown = True
+        examples = [
+            FunctionExample(
+                sql="SELECT * FROM bool_filter_echo(6) WHERE flag",
+                description="A boolean column is a predicate on its own",
+            ),
+        ]
+
+    FIXED_SCHEMA: ClassVar[pa.Schema] = schema({"n": pa.int64(), "flag": pa.bool_(), "pushed_filters": pa.utf8()})
+
+    @classmethod
+    def initial_state(cls, params: ProcessParams[_BoolFilterEchoArgs]) -> _BoolFilterEchoState:
+        """Create initial state, caching the SQL rendering of the pushed filters."""
+        assert params.init_call is not None
+        pf = params.init_call.pushdown_filters
+        filters = (
+            cls.pushdown_filters(
+                pf,
+                join_keys=params.init_call.join_keys,
+                output_schema=params.init_call.output_schema,
+            )
+            if pf is not None
+            else None
+        )
+        return _BoolFilterEchoState(
+            remaining=params.args.count,
+            filter_str=_format_pushed_filters(filters),
+        )
+
+    @classmethod
+    def process(
+        cls,
+        params: ProcessParams[_BoolFilterEchoArgs],
+        state: _BoolFilterEchoState,
+        out: OutputCollector,
+    ) -> None:
+        """Emit rows whose ``flag`` cycles TRUE, FALSE, NULL."""
+        if state.remaining <= 0:
+            out.finish()
+            return
+
+        n_values = list(range(state.current_index, state.current_index + state.remaining))
+        flags: list[bool | None] = [(True, False, None)[i % 3] for i in n_values]
+
+        out.emit(
+            pa.RecordBatch.from_pydict(
+                {
+                    "n": n_values,
+                    "flag": flags,
+                    "pushed_filters": [state.filter_str] * len(n_values),
+                },
+                schema=params.output_schema,
+            )
+        )
+
+        state.current_index += state.remaining
+        state.remaining = 0
+
+
 # ============================================================================
 # ValuePruneFunction — exercises PushdownFilters.get_column_values('n'), the
 # partition-pruning idiom (resolve the discrete value set up front, fetch only

vgi/_test_fixtures/worker.py

@@ -140,6 +140,7 @@
     RFF_SIMPLE_COLUMNS,
     RFF_STRUCT_COLUMNS,
     BatchIndexOverflowFunction,
+    BoolFilterEchoFunction,
     BrokenMissingPartitionValuesFunction,
     BrokenPartitionColumnAbsentFromBatchFunction,
     BrokenPartitionMinNeqMaxFunction,
@@ -486,6 +487,7 @@ def _build_fixture_stats() -> tuple[
                 # TableFunctionGenerator - generate output without input
                 ConstantColumnsFunction,
                 SlowCancellableFunction,
+                BoolFilterEchoFunction,
                 FilterEchoFunction,
                 FilterEchoPartitionedFunction,
                 FilterEchoTableScanFunction,