fix(optimizer): preserve UNNEST struct-field columns

[fivetran-kwoodbeck]

canonicalize_internal_names was producing invalid SQL for struct field columns of an UNNEST. An UNNEST of structs exposes struct field names as physical columns, but the rule was treating them as internal handles.

Sample Input

SELECT t.id FROM t
JOIN (SELECT sid FROM UNNEST([STRUCT('x' AS sid), STRUCT('y')])) AS q
  ON q.sid = t.id;

Previous Output, invalid SQL: references non existent _c0

SELECT `_t1`.`id` AS `id` FROM `_t1` AS `_t1`
JOIN (SELECT `_c0` AS `_c0` FROM UNNEST([STRUCT('x' AS `sid`), STRUCT('y')])) AS `_t2` ON `_t2`.`_c0` = `_t1`.`id`;

Fixed Output: field name sid preserved

SELECT `_t1`.`id` AS `id` FROM `_t1` AS `_t1` 
JOIN (SELECT `sid` AS `_c0` FROM UNNEST([STRUCT('x' AS `sid`), STRUCT('y')])) AS `_t2` ON `_t2`.`_c0` = `_t1`.`id`;

Fix

In canonicalize_internal_names, added a preserve_names flag that treats an UNNEST + structs field column as physical. This is the same way is_base_source columns are already preserved. Scalar UNNEST element aliases are renameable definitions, so they still canonicalize like previously.

Behavior

source	column	result
UNNEST of struct (literal)	struct field	preserved
UNNEST of ARRAY column	struct field	preserved
scalar UNNEST / WITH OFFSET	element alias	_cN
correlated scalar UNNEST	element alias	_cN

[github-actions]

SQLGlot Integration Test Results

✅ All tests passed

Comparing:

• this branch (sqlglot:optimizer/fix-numbering-unnest-canonicalize-internal-names @ sqlglot 6dfaa53)
• baseline (main @ sqlglot 323f5a3)

Overall

main: 192414 total, 153545 passed (pass rate: 79.8%)

sqlglot:optimizer/fix-numbering-unnest-canonicalize-internal-names: 180220 total, 142393 passed (pass rate: 79.0%)

Transitions:
No change

Dialect pair changes: 0 previous results not found, 3 current results not found

✅ All tests passed

[geooo109]

Input (bq):
SELECT s.sid FROM UNNEST([STRUCT('a' AS sid)]) AS s;
SELECT z.sid FROM UNNEST([STRUCT('a' AS sid)]) AS z

main (output for both queries):
SELECT `_c0`.`sid` AS `sid` FROM UNNEST([STRUCT('a' AS `sid`)]) AS `_c0`

PR  (output):
SELECT `s`.`sid` AS `sid` FROM UNNEST([STRUCT('a' AS `sid`)]) AS `s`
SELECT `z`.`sid` AS `sid` FROM UNNEST([STRUCT('a' AS `sid`)]) AS `z`

The granularity of the change should be column-level rather than source-level: only the struct field names need preserving, but the source-level flag also preserves the UNNEST's element alias (s/z above), which leaks them into the canonical form. Since both inputs are the same query, they should keep producing the same canonical output, as on main. cc: @georgesittas

[georgesittas]

Yeah, and we should also add a test that does something like:

SELECT s FROM UNNEST([STRUCT('a' AS sid)]) AS s;

Because the source name now acts as both a source and a top-level column (i.e., part of the contract).