fix(codegen): fold struct-column qualifier; +equality/fold coverage (Tasks 3-4 review)

Review of Tasks 3-4 flagged an unquoted uppercase struct-column qualifier not
being folded: S.x built a lookup for column 'S' while DataFusion folds it to
's'. Fold the qualifier when the validate rewrite reinterprets it as a column
(safe: the relation lookup already matched it raw and missed). Locked with an
xfail_on_native diff test -- native has the same (worse) gap, wants a ticket.

Also: comment the deliberate drop of the plan's 4-part catalog raise (lets
t.s.a.b resolve via layered FieldAccess), and add list-inequality coverage.

Left unfixed (noted for tickets): struct=scalar returns False where DataFusion
type-errors; field access on a NULL struct (DataFusion returns 0, not NULL) --
both out of Phase B's committed surface.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: ahrzb

sql_transform/_codegen/plan.py

@@ -317,7 +317,10 @@ def _convert_expr(e: exp.Expression) -> Any:
         # [s,a,b] -> FieldAccess(Column(s,a), b); the 2-part `s.x` stays a Column
         # (table.column vs struct.field is ambiguous until schemas resolve, in
         # _validate_expr). The qualifier (parts[0]) names a relation and stays
-        # raw; column/field parts fold.
+        # raw; column/field parts fold. No `catalog` raise: deliberately dropped
+        # from the plan so `t.s.a.b` (table + nested struct) resolves via layered
+        # FieldAccess rather than erroring -- only a true 4-part catalog.db.tbl.col
+        # (never emitted in __THIS__-scoped SQL) would misparse.
         quals = [q for q in (e.args.get("catalog"), e.args.get("db")) if q is not None]
         if e.args.get("table"):
             quals.append(e.args["table"])
@@ -747,7 +750,12 @@ def _validate_expr(e: Any, resolved, row_schemas, static_schemas, used) -> Any:
                 # and re-validate (mirrors native plan.rs). A relation alias
                 # always wins, so this only runs after the alias lookup fails;
                 # the base column resolves below, erroring if it isn't real.
-                fa = FieldAccess(Column(table=None, name=e.table), e.name)
+                # Fold the qualifier as a column here (the relation lookup above
+                # matched it raw): an unquoted `MyStruct.x` base folds to
+                # `mystruct` like any column, matching DataFusion. (Quotedness is
+                # lost by this point, so a quoted mixed-case struct base is
+                # unsupported -- exotic and untested.)
+                fa = FieldAccess(Column(table=None, name=e.table.lower()), e.name)
                 return _validate_expr(fa, resolved, row_schemas, static_schemas, used)
             real, is_row = entry
             schema = (row_schemas if is_row else static_schemas).get(real)

tests/test_diff_types.py

@@ -148,6 +148,17 @@ def test_qualified_struct_field_access():
     )
 
 
+def test_uppercase_qualifier_field_access(xfail_on_native):
+    # An unquoted struct-column qualifier folds like any column: `S.x` -> `s.x`,
+    # matching DataFusion. Native doesn't fold the qualifier (raises "Unknown
+    # column: S") -- parity gap, wants its own ticket.
+    xfail_on_native("native does not fold an unquoted struct-column qualifier (S.x)")
+    check(
+        "SELECT S.x AS v FROM t",
+        {"t": rows({"s": "struct{x:int}"}, [{"s": {"x": 7}}])},
+    )
+
+
 def test_struct_equality_true():
     check(
         "SELECT (s = s) AS eq FROM t",
@@ -170,6 +181,13 @@ def test_list_equality():
     )
 
 
+def test_list_inequality():
+    check(
+        "SELECT (l = [9, 9, 9]) AS eq FROM t",
+        {"t": rows({"l": "list[int]"}, [{"l": [1, 2, 3]}])},
+    )
+
+
 def test_unnest_struct_expands_columns():
     check(
         "SELECT unnest(named_struct('x', a, 'y', b)) FROM t",