[NOTICKET] fix: compiler parity — F-17 fabricated column, F-18 LIKE nulls, F-25 empty in/not_in

Three execution-verified findings from CODE_REVIEW_2026-07-23 that had no DEV_PLAN
row — the tracker went from #39 straight to #40 and lost them. Same IR must not mean
two different things depending on whether the source is a database or a file.

F-17 (High) — the bare-select check was gated on `if ir.group_by`, so a select mixing
a bare column with an aggregate and group_by=[] passed validation. Postgres then
rejects it loudly, but the pandas path silently DROPS the column while
`output_columns` (built from the select list, not the result) still advertises it.
`data_access` maps rows by name, so the missing name becomes None: the user gets a
real-looking table whose first column is entirely em-dash, presented as data. Wrong
answers presented as correct is the worst outcome for this product.

The check now fires whenever any aggregate is present. No false positives are
possible — a mixed select with no group_by is invalid SQL in every dialect — and the
planner's retry loop self-corrects it, exactly as the original Q1 rule does.

F-18 — `.astype(str)` ran before `na=False` could apply, so NaN/None became the
literal strings "nan"/"None" and matched any pattern containing those letters.
`region LIKE '%an%'` over a column with 200 nulls returned 200 extra rows versus SQL,
with nothing to flag it. Now only non-null values are coerced; null positions stay
False. Uses reindex rather than positional assignment to avoid pandas' incompatible-
dtype FutureWarning.

F-25 — `SqlCompiler` raised on an empty `in`/`not_in` list, while the pandas compiler
AND `_column_values`' own docstring implement the empty-set semantics. A two-step
plan whose first step legitimately returned zero rows ("which customers never
ordered?") hard-failed the task, skipped its dependents, tripped CK1, and answered
with an honest-failure message instead of the correct answer. Empty `in` now compiles
to `1 = 0` and empty `not_in` to `1 = 1` (dialect-portable, parses cleanly through
the sqlglot guard). A non-list value still raises — emptiness became meaningful, a
wrong type did not.

Verification: 16 new parity tests, all green. One existing test replaced —
`test_filter_in_empty_list_raises` pinned exactly the F-25 behaviour being changed;
it becomes two tests for the new semantics plus one keeping the non-list rejection.
Suite 424 passed / 0 failed / 7 skipped (was 394/0/7; +28 new, +2 net from the
replacement). Ruff on touched paths unchanged from HEAD. `import main` OK.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/query/compiler/pandas.py

@@ -182,7 +182,18 @@ def _apply_filters(
         elif op == "is_not_null":
             mask &= series.notna()
         elif op == "like":
-            mask &= series.astype(str).str.fullmatch(_like_to_regex(val), case=True, na=False)
+            # In SQL, `NULL LIKE '<pattern>'` evaluates to NULL, so the row is
+            # excluded. `.astype(str)` used to run FIRST, converting NaN/None into the
+            # literal strings "nan"/"None" — by the time `na=False` would have applied
+            # there were no NAs left, so a pattern like '%an%' matched every null row.
+            # Coerce only the non-null values and leave null positions False. (F-18)
+            non_null = series[series.notna()]
+            matched = non_null.astype(str).str.fullmatch(
+                _like_to_regex(val), case=True, na=False
+            )
+            # Reindex rather than assign into a bool Series — a positional assignment
+            # trips pandas' incompatible-dtype FutureWarning when the subset is empty.
+            mask &= matched.reindex(series.index, fill_value=False).astype(bool)
         elif op == "between":
             mask &= (series >= val[0]) & (series <= val[1])
     return df[mask].copy()

src/query/compiler/sql.py

@@ -229,10 +229,21 @@ class SqlCompiler(BaseCompiler):
             return f"{col_ref} IS NOT NULL"
 
         if op in _LIST_OPS:
-            if not isinstance(f.value, list) or not f.value:
+            if not isinstance(f.value, list):
                 raise SqlCompilerError(
-                    f"filters[{index}]: op {op!r} requires a non-empty list value"
+                    f"filters[{index}]: op {op!r} requires a list value"
                 )
+            if not f.value:
+                # Empty reference set. `in []` matches nothing; `not_in []` matches
+                # everything — the correct set semantics, what `_column_values`'
+                # docstring already promises, and what the pandas compiler already
+                # does (`series.isin([])`). This used to raise, hard-failing the task
+                # and skipping its dependents: a legitimate two-step plan whose first
+                # step returned zero rows ("which customers never ordered?") produced
+                # an honest-failure message instead of the correct answer. Emitted as
+                # `1 = 0` / `1 = 1` rather than FALSE/TRUE so it stays dialect-portable
+                # and parses cleanly through the sqlglot guard. (F-25)
+                return "1 = 0" if op == "in" else "1 = 1"
             placeholders = [
                 ":" + self._next_param(params, param_seq, v) for v in f.value
             ]

src/query/ir/validator.py

@@ -87,18 +87,39 @@ class IRValidator:
         for i, col_id in enumerate(ir.group_by):
             self._require_column(columns_by_id, col_id, f"group_by[{i}]")
 
-        # A grouped query must not select bare columns that aren't in group_by —
-        # the database rejects it only at execution ("must appear in the GROUP BY
-        # clause"), which is past the planner's corrective-retry window. Catching
-        # it here turns a failed turn into a self-correcting re-prompt.
-        if ir.group_by:
+        # A query mixing bare columns with aggregates must not select a bare column
+        # that isn't in group_by — the database rejects it only at execution ("must
+        # appear in the GROUP BY clause"), which is past the planner's corrective-retry
+        # window. Catching it here turns a failed turn into a self-correcting re-prompt.
+        #
+        # Extended 2026-07-23 (F-17): the check used to be gated on `if ir.group_by`,
+        # so a mixed select with group_by=[] passed. On a DB source Postgres then failed
+        # loudly, but on a TABULAR source the pandas compiler silently DROPPED the bare
+        # column while `output_columns` (built from the select list, not the result)
+        # still advertised it — the user got a real-looking table whose first column was
+        # entirely `—`. Wrong answers presented as correct is the worst outcome for this
+        # product, so the check now fires whenever ANY aggregate is present. No false
+        # positives are possible: a mixed select with no group_by is invalid SQL in
+        # every dialect.
+        has_agg = any(item.kind == "agg" for item in ir.select)
+        if ir.group_by or has_agg:
             grouped = set(ir.group_by)
             for i, item in enumerate(ir.select):
                 if item.kind == "column" and item.column_id not in grouped:
+                    context = (
+                        "while group_by is present"
+                        if ir.group_by
+                        else "alongside an aggregate with no group_by"
+                    )
+                    fix = (
+                        "every selected column must either appear in group_by or be "
+                        "wrapped in an aggregate"
+                        if ir.group_by
+                        else "either add it to group_by or wrap it in an aggregate"
+                    )
                     raise IRValidationError(
                         f"select[{i}].column_id {item.column_id!r} is selected bare "
-                        "while group_by is present — every selected column must "
-                        "either appear in group_by or be wrapped in an aggregate "
+                        f"{context} — {fix} "
                         f'(e.g. {{"kind": "agg", "fn": "sum", '
                         f'"column_id": {item.column_id!r}}})'
                     )