Merge pull request #2910 from GaijinEntertainment/bbatkin/sqlite-linq-join-groupby-alias

sqlite_linq: resolve `_.<alias>` after _join via projection registry (chunk N+2)

Author: borisbat

benchmarks/sql/join_groupby_count.das

@@ -6,16 +6,35 @@ require _common public
 // _join(cars, dealers) |> _group_by(_.Brand) |> _select((Brand, N=_._1|>count)) — joined+grouped,
 // per-group counts returned as an array of (Brand, N) tuples (no terminal count;
 // the inner `count()` is the per-bucket reducer).
-// SQL: SELECT brand, COUNT(*) FROM Cars c JOIN Dealers d ON c.dealer_id = d.id GROUP BY brand.
-// sqlite_linq's `_group_by` after `_join` doesn't currently lower (key column is from
-// the joined projection, not a base table column). Follow-up TODO 2026-05-25.
+// SQL (m1): `SELECT ("t0"."brand"), COUNT(*) FROM "Cars" AS "t0" INNER JOIN "Dealers" AS "t1"
+// ON "t0"."dealer_id" = "t1"."id" GROUP BY ("t0"."brand")`. push_group_key resolves the
+// `_.Brand` key against the join's `into` projection registry — emits the qualified source
+// column (`"t0"."brand"`) rather than the bare alias name. Chunk N+2 (sqlite_linq.das).
 // Decs (m4): plan_decs_group_by's `isDecsJoin` adapter mode (Theme 3 Phase 1, audit C3).
 // Single pass — hashB-collect + srcA-probe emits per-pair result-lam bind directly
 // into plan_group_by_core's bucket update. Vs the tier-2 cascade's 3 intermediate
 // allocations (dealers-array → join-array → group-map → output-array). plan_group_by_core
 // itself is untouched — the abstraction holds.
 // Array (m3f): no array-side join splice; cascade baseline for comparison.
 
+def run_m1(b : B?; n : int) {
+    with_sqlite(":memory:") $(db) {
+        fixture_db(db, n)
+        b |> run("m1_sql/{n}", n) {
+            let groups <- _sql(db |> select_from(type<Car>)
+                |> _join(db |> select_from(type<Dealer>),
+                         $(c : Car, d : Dealer) => c.dealer_id == d.id,
+                         $(c : Car, d : Dealer) => (Brand = c.brand, DealerId = d.id))
+                |> _group_by(_.Brand)
+                |> _select((Brand = _._0, N = _._1 |> count())))
+            b |> accept(groups)
+            if (empty(groups)) {
+                b->failNow()
+            }
+        }
+    }
+}
+
 def run_m3f(b : B?; n : int) {
     let cars <- fixture_array(n)
     let dealers <- fixture_dealers_array()
@@ -51,6 +70,11 @@ def run_m4(b : B?; n : int) {
     }
 }
 
+[benchmark]
+def join_groupby_count_m1(b : B?) {
+    run_m1(b, 100000)
+}
+
 [benchmark]
 def join_groupby_count_m3f(b : B?) {
     run_m3f(b, 100000)

benchmarks/sql/join_groupby_to_array.das

@@ -4,14 +4,35 @@ options persistent_heap
 require _common public
 
 // _join(cars, dealers) |> _group_by(_.Brand) |> _select((Brand, Total=sum price)) |> to_array.
-// SQL: SELECT brand, SUM(price) FROM Cars c JOIN Dealers d ON c.dealer_id = d.id GROUP BY brand.
-// sqlite_linq's `_group_by` after `_join` doesn't currently lower (key column is from
-// the joined projection). Follow-up TODO 2026-05-25.
+// SQL (m1): `SELECT ("t0"."brand"), SUM("t0"."price") FROM "Cars" AS "t0" INNER JOIN
+// "Dealers" AS "t1" ON "t0"."dealer_id" = "t1"."id" GROUP BY ("t0"."brand")`.
+// push_group_key resolves the `_.Brand` key, and try_translate_group_aggregate resolves
+// the inner `_select(_.Price)` to the qualified column — both consult the join's `into`
+// projection snapshot. Chunk N+2 (sqlite_linq.das).
 // Decs (m4): plan_decs_group_by's `isDecsJoin` adapter mode (Theme 3 Phase 1, audit C3).
 // Same shape as join_groupby_count.das but with a reducing aggregate. Single pass,
 // no intermediate allocations.
 // Array (m3f): no array-side join splice; cascade baseline for comparison.
 
+def run_m1(b : B?; n : int) {
+    with_sqlite(":memory:") $(db) {
+        fixture_db(db, n)
+        b |> run("m1_sql/{n}", n) {
+            let groups <- _sql(db |> select_from(type<Car>)
+                |> _join(db |> select_from(type<Dealer>),
+                         $(c : Car, d : Dealer) => c.dealer_id == d.id,
+                         $(c : Car, d : Dealer) => (Brand = c.brand, Price = c.price))
+                |> _group_by(_.Brand)
+                |> _select((Brand = _._0,
+                            Total = _._1 |> _select(_.Price) |> sum())))
+            b |> accept(groups)
+            if (empty(groups)) {
+                b->failNow()
+            }
+        }
+    }
+}
+
 def run_m3f(b : B?; n : int) {
     let cars <- fixture_array(n)
     let dealers <- fixture_dealers_array()
@@ -49,6 +70,11 @@ def run_m4(b : B?; n : int) {
     }
 }
 
+[benchmark]
+def join_groupby_to_array_m1(b : B?) {
+    run_m1(b, 100000)
+}
+
 [benchmark]
 def join_groupby_to_array_m3f(b : B?) {
     run_m3f(b, 100000)

benchmarks/sql/results.md

@@ -51,19 +51,24 @@ require them.
 
 ---
 
-## Other deferred lowerings (independent, each its own PR)
+## ~~`_group_by` after `_join`~~ — closed in PR #2910
+
+Originally catalogued 2 cells as blocked on resolving `_group_by` keys against
+the join's `into` projection. Closed in PR #2910 (chunk N+2) via a central
+`pred_to_sql` extension that consults a snapshot of the join's projection
+registry — single hook transitively enables alias resolution in `_group_by` /
+`_having` / `_order_by` / `try_translate_group_aggregate` / computed-expression
+keys.
 
-### `_group_by` after `_join` — group key from joined projection
+**Closed cells**:
+- `join_groupby_count` — `_join |> _group_by(_.Brand) |> _select((Brand=_._0, N=_._1|>count()))`.
+- `join_groupby_to_array` — `_join |> _group_by(_.Brand) |> _select((Brand=_._0, Total=_._1|>_select(_.Price)|>sum()))`.
 
-Benches: [`join_groupby_count`](join_groupby_count.das),
-[`join_groupby_to_array`](join_groupby_to_array.das).
+The fix surfaced one residual: HAVING with an alias-resolved aggregate in the
+`_sql(...)` runtime form hits a typer-ordering quirk; `_sql_text` emit is
+correct, runtime path deferred to chunk N+3.
 
-`sqlite_linq`'s `_group_by` after `_join` doesn't lower today because the
-group key column comes from the join's `into` projection, not from a
-base-table column. The lowering would need to either emit the `JOIN` as a
-subquery and `GROUP BY` over the subquery's column, or surface the
-projection-column → SQL-fragment mapping into `_group_by`'s key-extractor
-logic. Originally TODO'd 2026-05-25.
+## Other deferred lowerings (independent, each its own PR)
 
 ### `COUNT(DISTINCT computed-expr)`
 

benchmarks/sql/sqlite_linq_gaps.md

@@ -90,6 +90,49 @@ Single-column and named-tuple projections both work. Per-source
 projections (``_select(...)`` on the right side) are rejected ---
 the join's ``into`` lambda is the only projection.
 
+Joining + grouping
+==================
+
+``_group_by`` / ``_having`` / ``_order_by`` after ``_join`` accept the
+join's ``into``-projection alias names as keys, not base-table fields.
+The translator resolves each alias through the join's projection
+registry and emits the underlying qualified column (``"t0"."brand"``,
+``"t1"."Id"``) in the GROUP BY / HAVING / ORDER BY clauses, so the
+SQL composes cleanly with the JOIN:
+
+.. code-block:: das
+
+    let groups <- _sql(db |> select_from(type<Car>)
+        |> _join(db |> select_from(type<Dealer>),
+                 $(c : Car, d : Dealer) => c.dealer_id == d.id,
+                 $(c : Car, d : Dealer) => (Brand = c.brand, Price = c.price))
+        |> _group_by(_.Brand)
+        |> _select((Brand = _._0, N = _._1 |> count())))
+    // SELECT ("t0"."brand"), COUNT(*)
+    //   FROM "Cars" AS "t0" INNER JOIN "Dealers" AS "t1"
+    //     ON "t0"."dealer_id" = "t1"."id"
+    //   GROUP BY ("t0"."brand")
+
+Per-group aggregates over a projection alias resolve the same way ---
+``_._1 |> _select(_.Price) |> sum()`` becomes ``SUM("t0"."price")``,
+not the bare alias:
+
+.. code-block:: das
+
+    let totals <- _sql(db |> select_from(type<Car>)
+        |> _join(db |> select_from(type<Dealer>),
+                 $(c : Car, d : Dealer) => c.dealer_id == d.id,
+                 $(c : Car, d : Dealer) => (Brand = c.brand, Price = c.price))
+        |> _group_by(_.Brand)
+        |> _select((Brand = _._0,
+                    Total = _._1 |> _select(_.Price) |> sum())))
+    // ... SUM("t0"."price") ... GROUP BY ("t0"."brand")
+
+``_order_by`` and computed-expression group keys (``_group_by(_.Price / 100)``)
+read aliases through the same registry. Aliases that don't appear in
+the join's ``into`` projection reject with a clear macro_error listing
+the valid alias names.
+
 What's not shipped
 ==================
 

doc/source/reference/tutorials/sql_15_join.rst

@@ -5570,6 +5570,46 @@ All 4 m1 lanes backfilled in `benchmarks/sql/{distinct_by_order_take,distinct_by
 - **Pre-distinct phase-divert composition** (Copilot R1 #2909). Chains like `take(N) |> _distinct_by(K)` or `skip(N) |> _distinct_by(K)` trigger `divert_to_inner` BEFORE `_distinct_by` peels — `q.innerSql`/`q.innerBindExprs` get populated by the take's inner subquery, and chunk N+1's passthrough finalize would overwrite the inner SQL while orphaning the take's bind. Currently rejected with a clear macro_error pointing the user to restructure as `_distinct_by(K) |> take(N)` (cap-after-distinct semantics). A future composition would 2-level wrap: `SELECT … FROM (SELECT *, MIN(pk) FROM ({prior_innerSql}) GROUP BY K) AS t0` to preserve cap-before-distinct semantics — needs design + tests for arbitrary phase-divert combinations.
 - **Whole-row projection as inner subquery** (Copilot R1 #2909). `_group_by(K) |> _select((K=_._0, R=_._1 |> first())) |> _where(P) |> to_array` triggers `divert_to_inner` (PHASE_WHERE forces a SELECT divert), which would wrap the grouped+first projection as inner. The row entry expands to N source columns without `AS <alias>` under `force_aliases=true`, and `apply_passthrough_projection` expects 1 column per record name. Currently rejected with a clear macro_error pointing the user to restructure (run the wrap-triggering op before `_group_by`, or split into separate `_sql` calls). Resolution options: (a) emit deterministic per-field aliases (`"col1" AS "<RecordName>_col1"`) under `force_aliases` and teach `apply_passthrough_projection` to reconstruct the row entry from those, or (b) keep the rejection and document the constraint. Same PR could lift the v1 single-key-only constraint on `first()` projections.
 
+## Shipped — chunk N+2: `_group_by` / `_having` / `_order_by` after `_join` via projection-alias resolution (branch `bbatkin/sqlite-linq-join-groupby-alias`)
+
+### Surface in this PR
+
+Closes 2 SQL bench cells from [`benchmarks/sql/sqlite_linq_gaps.md`](../../benchmarks/sql/sqlite_linq_gaps.md)'s "`_group_by` after `_join`" section. After this PR, every chain operator that references a column reads the join's `into`-projection alias through a single registry — fields named in the `into` lambda's named tuple (`(Brand = c.brand, Price = c.price)`) become first-class names for subsequent `_group_by` / `_having` / `_order_by` / aggregate / computed-key operations:
+
+- `_join(...) |> _group_by(_.Brand) |> _select((Brand=_._0, N=_._1|>count()))` lowers to `SELECT ("t0"."brand"), COUNT(*) FROM "Cars" AS "t0" INNER JOIN ... GROUP BY ("t0"."brand")`.
+- `_join(...) |> _group_by(_.Brand) |> _select((Brand=_._0, Total=_._1|>_select(_.Price)|>sum()))` lowers to `... SUM("t0"."price") ... GROUP BY ("t0"."brand")`.
+- `_join(...) |> _having(_._1 |> _select(_.Price) |> sum() > 200) |> _select(...)` resolves the alias inside HAVING.
+- `_join(...) |> _order_by(_.Brand)` resolves the alias inside ORDER BY.
+- `_join(...) |> _group_by(_.Price / 100) |> _select(...)` resolves the alias inside a computed group key.
+
+### Architecture
+
+Single load-bearing change: `pred_to_sql`'s column-reference branch consults a new `joinProjRecordNames` snapshot of the join's `into` projection (captured at the end of `process_join_call`, preserved across `analyze_grouped_projection`'s clear-and-repopulate of `projRecordNames`). New helpers `find_projection_alias(q, name)` and `render_projection_alias_sql(q, idx)` resolve aliases to qualified SQL fragments. Bare-`_.Field` fast paths in `push_group_key`, `collect_order_keys`, and `try_translate_group_aggregate` mirror the same lookup so they don't bypass `pred_to_sql`. v1 supports `t0` / `t1` aliases (the 2-source `_join` shape); other aliases (multi-source / nested joins) reject loudly.
+
+### Constraints (v1)
+
+- 2-source `_join` only (carries forward from chunks N / N+1).
+- The join's `into` lambda's named-tuple aliases are the field namespace post-join — base-table column names ARE NOT available unqualified. Users referring to base-table fields by name post-join get a `not a projection alias` error listing the valid alias names.
+- HAVING with alias-resolved aggregate (`_._1 |> _select(_.X) |> sum() > N`) has a known typer-ordering quirk: in compilation units with multiple `_sql` calls referencing the same chain shape, the typer pre-folds the predicate's aggregate side and the runtime `_sql` form fails to bind `_` for the row builder. The SQL emit itself is correct (verified via `_sql_text`), so chains that don't need to materialize the predicate body at runtime work. Investigating in chunk N+3.
+
+### Tests
+
+`tests/dasSQLITE/test_33_join_groupby.das` — 12 new tests covering Arm B (4: emit + runtime × 2 chain shapes), Arm C (4: emit + runtime + min/max/avg + multi-aggregate), and transitive coverage via HAVING / ORDER BY / computed-key (4: emit-shape + runtime mix). 3 new `failed_*.das` rejection probes:
+- `failed_join_groupby_unknown_alias.das` — `_group_by(_.NotAnAlias)` after join rejects with alias list
+- `failed_join_groupby_aggregate_unknown_alias.das` — `_._1 |> _select(_.NotAField) |> sum()` rejects similarly
+- `failed_join_order_by_unknown_alias.das` — `_order_by(_.NotAnAlias)` after join rejects similarly
+
+### Benches
+
+Both `benchmarks/sql/join_groupby_count.das` and `benchmarks/sql/join_groupby_to_array.das` got `run_m1` lanes. INTERP m1 beats array-fold m3f baselines (158 vs 184 ns/op for count; 191 vs 216 for to_array). `benchmarks/sql/results.md` refreshed. `sqlite_linq_gaps.md` "`_group_by` after `_join`" section struck.
+
+### Deferred to chunk N+3
+
+- **HAVING with alias-resolved aggregate in `_sql(...)` runtime form** — typer-ordering quirk noted above. `_sql_text(...)` emit is correct; only the row-binder in `_sql(...)` is affected. Workaround for now: split the chain into a separate `_sql_text` probe for verification, or restructure to use bare `count()` predicates.
+- Nested / multi-way joins (`_join |> _join |> ...`) — chunks N / N+1 already constrain to 2-source; `render_projection_alias_sql` rejects aliases beyond `t0`/`t1`. A future extension would generalize `source_rootType_for_alias` over an N-source join chain.
+- HAVING / ORDER BY / computed-key composition with `_distinct_by` (orthogonal to this chunk's _join surface; deferred from N+1's "where-then-distinct" follow-up).
+- Real window functions — still no bench needs them.
+
 ## Plan (to be written after all tutorials are reviewed)
 
 _TBD — this section is filled in once we have notes from every tutorial._