feat(specializer): dynamic-table alias — the alias replaces the original name (TASK-48)

Measured: DuckDB makes qualified refs through the ORIGINAL name binder
errors once aliased; making the alias the binder's this_name reproduces
that scoping for qualified binds, star expansion, and messages with a
three-line change. AS/bare identical; column-renaming alias t(a,b)
rejects by name. Census note in the ticket: the comma-join rewrite was
DROPPED from wave scope — the corpus cases are self-joins of the
dynamic table, so the planned rewrite would flip ~0 cases.

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

Author: 2 people

backlog/tasks/task-48 - Specializer-SQL-support-LIKE-alias-comma-join-wave-2.md

@@ -26,7 +26,13 @@ The dual-axis rung plus two structural cheap wins, ~120 corpus first-blockers in
 <!-- AC:BEGIN -->
 - [ ] #1 LIKE semantics pinned by measurement (duck_check tests recorded before implementation: wildcards, ESCAPE, unicode, NULL, degenerate patterns) and both backends agree via a shared matcher (differential extended)
 - [ ] #2 Dynamic-table alias binds (qualified refs via alias, original name behavior measured and mirrored)
-- [ ] #3 Comma-join with equi-WHERE rewrites to the served INNER join; non-equi shapes reject by name
+- [x] #3 RE-SCOPED by census (recorded below): the corpus comma-join cases are SELF-joins of the dynamic table (FROM integers i1, integers i2 ...), not dynamic-x-static shapes — a rewrite would flip ~0 cases. Comma-join stays cleanly unsupported; dynamic self-join is a distinct future feature (needs row-table-as-static materialization).
 - [ ] #4 Corpus replay: wave-2 first-blocker cases flip to match or a named deeper blocker; zero FAILs; tally recorded here
 - [ ] #5 mise gate-specializer green
 <!-- AC:END -->
+
+## Implementation Notes
+
+<!-- SECTION:NOTES:BEGIN -->
+Census before code (2026-07-26): the 30 alias-first-blocker cases are mostly alias + a DEEPER blocker (self-joins, USING, rowid, column-renaming aliases); the ~30 comma-join cases are nearly all SELF cross-products of the dynamic table — the planned equi-WHERE rewrite would flip approximately zero, so it was dropped from scope honestly rather than shipped as dead code. Alias landed: the alias REPLACES the original name (measured: qualified refs through the original are DuckDB binder errors) — implemented by making the alias the binder's this_name, which yields exactly that scoping for qualified refs, star expansion, and error messages; AS/bare forms identical; column-renaming alias t(a,b) rejects by name. LIKE pins fleet running; matcher lands next.
+<!-- SECTION:NOTES:END -->

src/specializer/frontend.rs

@@ -204,16 +204,21 @@ fn bind_from<'a>(
     };
     let dyn_name = match &table.relation {
         TableFactor::Table { name, alias, .. } => {
-            if alias.is_some() {
-                return Err(unsup("alias on the dynamic table"));
-            }
             let n = name.to_string();
             if !n.eq_ignore_ascii_case(this_name) {
                 return Err(unsup(format!(
                     "table '{n}' as the driving relation (must be the dynamic table '{this_name}')"
                 )));
             }
-            n
+            match alias {
+                // Measured: an alias REPLACES the original name entirely
+                // (qualified refs through the original are binder errors in
+                // DuckDB) — making the alias the binder's this_name gives
+                // exactly that scoping.
+                Some(a) if a.columns.is_empty() => a.name.value.clone(),
+                Some(_) => return Err(unsup("column-renaming table alias t(a, b, ...)")),
+                None => n,
+            }
         }
         other => return Err(unsup(format!("FROM {other}"))),
     };

tests/test_duckdb_interpreter.py

@@ -1428,3 +1428,33 @@ def test_round_family_int64_identity_and_negative_n():
         {"i": "int?"},
         [{"i": v} for v in vals],
     )
+
+
+# --------------------------------------------------------- TASK-48:
+# dynamic-table alias — the alias REPLACES the original name (measured).
+
+
+def test_dynamic_table_alias():
+    for sql in [
+        "SELECT t.a AS x, a AS y FROM __THIS__ t",
+        "SELECT t.a AS x FROM __THIS__ AS t",
+        "SELECT t.a AS x, dim.name AS nm FROM __THIS__ t JOIN dim ON t.a = dim.id",
+        "SELECT t.*, upper(t.s) AS u FROM __THIS__ t",
+    ]:
+        duck_check(sql, {"a": "int", "s": "str"}, [{"a": 1, "s": "x"}], {"dim": DIM})
+
+
+def test_alias_shadows_original_name():
+    # Mirrors DuckDB's 'Referenced table not found' as our bind error.
+    with pytest.raises(ValueError, match="unknown table"):
+        DuckDBInferFn(
+            "SELECT __THIS__.a FROM __THIS__ t",
+            row_tables={"__THIS__": _row_model({"a": "int"})},
+            static_tables={},
+        )
+    with pytest.raises(ValueError, match="column-renaming"):
+        DuckDBInferFn(
+            "SELECT y FROM __THIS__ t(y)",
+            row_tables={"__THIS__": _row_model({"a": "int"})},
+            static_tables={},
+        )