TASK-38: fold an unquoted struct-column qualifier

[claude-agent-ahrzb]

SELECT S.x against a struct column named s raised Unknown column: S on native, while DataFusion folds the unquoted qualifier like any other identifier and returns the value — so TASK-28's folding rule silently did not apply in the struct-qualifier position.

This is TASK-28's AC#5 ceiling, which shipped with a note saying the case was "unreachable today". Struct field access made it reachable; the flag did its job.

Why the one-line fix doesn't work

The ticket framed this as folding the qualifier in expr_build.rs. Measured:

expr_build.rs   Some(parts[0].value.clone())  ->  Some(fold_ident(&parts[0]))
result:         96 failed, 477 passed

Our own rewrite emits SELECT __THIS__.age / __STATE__.avg_age … FROM __THIS__ LEFT JOIN __STATE__, so folding at parse turns __THIS__ into __this__ and every windowed transform on native dies.

expr_build structurally cannot make the call: a qualifier is either a relation alias or a struct column, and only plan.rs knows which — once resolved.get(t) hits or misses.

The fix

The qualifier is carried to that decision point as a type instead of a bare string:

pub struct QualifiedName { pub value: String, pub quoted: bool }
impl QualifiedName { pub fn folded(&self) -> String { … } }   // unquoted -> lowercase

Fold only where the qualifier names data; never where it names a relation.

site	branch	takes
resolve_column, resolve_column_type, column_qualifier, validate_expr's alias lookup	relation	.value
struct-column fallback (plan.rs)	data	.folded()
unnest_display_name	display name	.folded()

folded() matches expr_build::fold_ident exactly — the established rule for ordinary identifiers.

Commit structure

Task 1 is a deliberate pure refactor (34b61be): QualifiedName threaded through with every consumer taking .value — byte-for-byte the old String — and the suite proven identical at 572/12 with the target test still xfailing. Behaviour changes only in a5b0059. A regression is therefore attributable to one commit rather than tangled with the refactor.

Two scope corrections found during implementation

1. The planned unnest(T.s) FROM t test was impossible — resolving a qualifier whose case differs from the relation needs relation-alias folding, the forbidden path, and both engines fail it identically. Dropped.

2. The final review caught that a5b0059's message then over-claimed — it said the unnest fold was dropped, but only the test was. The fold shipped with zero coverage: mutating it back to .value passed the whole suite. Fixed in ebafe1d, which covers it using a relation registered as T (DataFusion renders the registered, folded qualifier into unnest output names, so T yields t.s.x).

Pre-existing codegen bugs exposed (not caused)

Both pinned xfail_on_codegen(strict=True), codegen's Python untouched by this branch:

• codegen accepts "S".x where the oracle rejects it (over-folds a quoted qualifier) — verified on origin/master before this branch.
• codegen renders the unnest qualifier raw (T.s.x) instead of the oracle's t.s.x.

Both want their own ticket rather than an inline fix, per the file-ownership rule.

Verification

• Suite 575 passed, 13 xfailed (572 baseline + 3 new tests, 1 native xfail flipped, 2 codegen xfails added).
• Mutation-checked both directions: forcing folded() to always fold breaks the quoted test; never folding breaks the unquoted test.
• check_both_raise hardened with match="S" — it previously accepted any error from either engine and could have passed for an unrelated reason.
• No changes to sql_transform/_codegen/plan.py or tests/test_codegen_coverage.py.

Out of scope

Relation qualifiers still diverge from the oracle, which registers relations under a folded name ("__THIS__".age misses there, hits on native). Measured, unreachable through the public API, fails loudly. Different branch, second core change — deliberately not folded in, and tracked separately.

🤖 Generated with Claude Code

[claude-agent-ahrzb]

Closing as obsolete: the SQLTransform line this targets has been reset (#54). The DataFusion native engine, the codegen backend, and the batch transform() path are removed; what remains is the confit-served fit-and-serve path.

Nothing here is lost — the branch and its commits stay reachable if this work is ever revived.