feat(eqp): flatten a bare-LIMIT derived/CTE body under a narrower projection or single-term ORDER BY (B9c-flatten)

Completes B9c. A bare-LIMIT body (no OFFSET) now flattens, not just under a
pure-wildcard outer, but also:
- a narrower projection with no outer WHERE — the outer projection is substituted
  into the LIMIT body (`SELECT a FROM (SELECT * FROM t LIMIT 5)` -> `SCAN t USING
  COVERING INDEX`), via a relaxed `inner_scan_flatten_ok` gate on the unified
  merge branch;
- a single-term outer ORDER BY (no WHERE) — a dedicated branch pushes the
  projection + ORDER BY into the body and recurses (`(… LIMIT 5) ORDER BY b` ->
  `SCAN t USING INDEX tb`, or a full temp-b-tree when unindexed).

A multi-term outer ORDER BY still declines: SQLite full-sorts the materialized
LIMIT rows, whereas pushing it down would render a partial `LAST TERM` index walk
when the leading prefix is indexed. The merge branch now borrows `derived_map` so
it survives for the ORDER-BY branch. Existing flatten/co-routine taxonomy tests
green; new render cases added and the narrower-over-LIMIT decline replaced with
the multi-term-ORDER-BY decline.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: MagicalTux

ROADMAP.md

@@ -1192,16 +1192,18 @@ tie/representative order), so they are perf/EQP-fidelity work, not correctness:
   the windowed input; the `(subquery-N)` label is codegen-order-fragile (see the
   `schema-sql-canonicalization` note), so this needs a deterministic-numbering model
   before it can be byte-exact. Rows already correct.
-- **B9c — remaining derived/CTE `LIMIT`-body EQP paths.** The bare-`LIMIT` /
-  pure-wildcard flatten and the *non-flattenable* co-routine cases are now done: an
-  `OFFSET` body, an outer `WHERE`, or an outer aggregate over a `LIMIT` body
-  materializes as `CO-ROUTINE <name>` (body plan recursed) + the outer
-  `{SCAN|SEARCH} <name>`, via the same wrapper as an aggregate body. *Still open:* the
-  *flatten* variants SQLite applies — a **narrower projection** or an **outer
-  `ORDER BY`** over a bare-`LIMIT` body (`SELECT a FROM (SELECT * FROM t LIMIT 5)` →
-  `SCAN t USING COVERING INDEX`) — which need the projection / ordering merged into the
-  `LIMIT` body; those still decline. Boundary rules in the `eqp-derived-coroutine`
-  memory.
+- **B9c — remaining derived/CTE `LIMIT`-body EQP paths. ✅ Done.** The bare-`LIMIT`
+  pure-wildcard flatten, the *non-flattenable* co-routine cases (an `OFFSET` body, an
+  outer `WHERE`, or an outer aggregate over a `LIMIT` body → `CO-ROUTINE <name>` + the
+  outer `{SCAN|SEARCH} <name>`), AND the *flatten* variants are all done now: a
+  **narrower projection** over a bare-`LIMIT` body with no outer `WHERE` substitutes the
+  outer projection into the body (`SELECT a FROM (SELECT * FROM t LIMIT 5)` → `SCAN t
+  USING COVERING INDEX`), and a **single-term outer `ORDER BY`** pushes the projection +
+  ORDER BY into the body and recurses (`(… LIMIT 5) ORDER BY b` → `SCAN t USING INDEX
+  tb` / a full temp-b-tree if unindexed). *Residual:* a **multi-term** outer `ORDER BY`
+  over a `LIMIT` body still declines — SQLite full-sorts the materialized `LIMIT` rows,
+  whereas pushing the ORDER BY down would render a partial `LAST TERM` index walk when
+  the leading prefix is indexed. Boundary rules in the `eqp-derived-coroutine` memory.
 - **B9d — `SEARCH` + `GROUP BY`/`DISTINCT` temp-b-tree node.** graphite emits the
   grouping b-tree only over a bare `SCAN`; under a `WHERE` seek it omits the node.
   Entangled with B9h (SQLite often picks a *different* index whose walk serves the

src/exec/mod.rs

@@ -13861,6 +13861,16 @@ impl Connection {
                     && !sub.where_clause.as_ref().is_some_and(expr_has_subquery);
                 let inner_is_base_table_scan =
                     inner_base_scan_no_limit && sub.limit.is_none() && sub.offset.is_none();
+                // A bare `LIMIT` body (no `OFFSET`) also flattens under a *narrower*
+                // projection — SQLite substitutes the outer projection into the `LIMIT`
+                // body (`SELECT a FROM (SELECT * FROM t LIMIT 5)` → `SCAN t USING
+                // COVERING INDEX`). Only when the outer carries no `WHERE`: a predicate
+                // over a `LIMIT` body is filter-after-limit, which SQLite materializes
+                // as a `CO-ROUTINE` (handled below) rather than folding into the scan.
+                let inner_scan_flatten_ok = inner_is_base_table_scan
+                    || (inner_base_scan_no_limit
+                        && sub.offset.is_none()
+                        && sel.where_clause.is_none());
                 // A pure-wildcard outer over a single base-table body recurses into the
                 // body's own plan. A bare `LIMIT` body (no `OFFSET`) flattens the same
                 // way — SQLite renders just the body's `SCAN`/index walk, the `LIMIT`
@@ -13969,24 +13979,24 @@ impl Connection {
                     .is_none_or(|p| all_qualifiers_match(p, co_label));
                 if let (true, true, true, Some(rename)) = (
                     outer_general_flatten,
-                    inner_is_base_table_scan,
+                    inner_scan_flatten_ok,
                     outer_where_qualifiers_ok && !(outer_is_wildcard && sel.where_clause.is_none()),
-                    derived_map,
+                    derived_map.as_ref(),
                 ) {
-                    if outer_refs_resolve(&rename) {
+                    if outer_refs_resolve(rename) {
                         let mut merged = sub.clone();
                         if !outer_is_wildcard {
                             let mut cols = sel.columns.clone();
                             for c in &mut cols {
                                 if let ResultColumn::Expr { expr, .. } = c {
-                                    rewrite_flattened_column(expr, co_label, &rename);
+                                    rewrite_flattened_column(expr, co_label, rename);
                                 }
                             }
                             merged.columns = cols;
                         }
                         if let Some(pred) = &sel.where_clause {
                             let mut pred = pred.clone();
-                            rewrite_flattened_column(&mut pred, co_label, &rename);
+                            rewrite_flattened_column(&mut pred, co_label, rename);
                             merged.where_clause = Some(match merged.where_clause.take() {
                                 Some(inner) => Expr::Binary {
                                     op: BinaryOp::And,
@@ -13999,6 +14009,67 @@ impl Connection {
                         return self.eqp_select(&merged, parent, next_id, out, params);
                     }
                 }
+                // A bare-`LIMIT` body (no `OFFSET`) under an outer `ORDER BY` (and no
+                // `WHERE`) flattens: SQLite pushes the outer projection + `ORDER BY` into
+                // the flattened scan (`SELECT * FROM (SELECT * FROM t LIMIT 5) ORDER BY b`
+                // → `SCAN t USING INDEX tb`). We merge the outer projection + `ORDER BY`
+                // into the `LIMIT` body and recurse — the body's own `eqp_select` renders
+                // the ORDER-BY index walk / temp-b-tree. Same name-soundness gate as the
+                // projection merge, plus every `ORDER BY` column must name a source output
+                // (a positional term needs no rename).
+                // Restricted to a *single* ORDER BY term: a lone term is either fully
+                // served by an index walk (`SCAN … USING INDEX`) or fully unsorted
+                // (`SCAN … + USE TEMP B-TREE FOR ORDER BY`), both matching SQLite's outer
+                // plan; a multi-term ORDER BY whose leading prefix is indexed but tail is
+                // not would render a partial-sort `LAST TERM` here while SQLite full-sorts
+                // the materialized `LIMIT` rows — so multi-term declines.
+                if outer_flattenable_proj
+                    && sel.order_by.len() == 1
+                    && sel.where_clause.is_none()
+                    && sel.group_by.is_empty()
+                    && sel.having.is_none()
+                    && !sel.distinct
+                    && sel.compound.is_empty()
+                    && (from_cte || sel.ctes.is_empty())
+                    && inner_base_scan_no_limit
+                    && sub.limit.is_some()
+                    && sub.offset.is_none()
+                    && !sel.columns.iter().any(|c| match c {
+                        ResultColumn::Expr { expr, .. } => expr_has_subquery(expr),
+                        ResultColumn::Wildcard | ResultColumn::TableWildcard(_) => false,
+                    })
+                    && !sel.order_by.iter().any(|t| expr_has_subquery(&t.expr))
+                    && sel
+                        .order_by
+                        .iter()
+                        .all(|t| all_qualifiers_match(&t.expr, co_label))
+                {
+                    if let Some(rename) = derived_map.as_ref() {
+                        let names: Vec<String> = rename.iter().map(|(o, _)| o.clone()).collect();
+                        let order_refs_ok = sel
+                            .order_by
+                            .iter()
+                            .all(|t| all_column_names_in(&t.expr, &names));
+                        if outer_refs_resolve(rename) && order_refs_ok {
+                            let mut merged = sub.clone();
+                            if !outer_is_wildcard {
+                                let mut cols = sel.columns.clone();
+                                for c in &mut cols {
+                                    if let ResultColumn::Expr { expr, .. } = c {
+                                        rewrite_flattened_column(expr, co_label, rename);
+                                    }
+                                }
+                                merged.columns = cols;
+                            }
+                            let mut order_by = sel.order_by.clone();
+                            for t in &mut order_by {
+                                rewrite_flattened_column(&mut t.expr, co_label, rename);
+                            }
+                            merged.order_by = order_by;
+                            return self.eqp_select(&merged, parent, next_id, out, params);
+                        }
+                    }
+                }
                 // A *compound* CTE/derived body that carries at least one dedup set
                 // operator (`UNION` / `INTERSECT` / `EXCEPT`) cannot flatten into the
                 // outer plan: SQLite materializes it as a `CO-ROUTINE <name>` whose

tests/eqp_derived_coroutine.rs

@@ -157,6 +157,14 @@ fn flattenable_wildcard_over_base_table_matches_sqlite() {
         "SELECT aa FROM (SELECT a AS aa FROM t) AS s WHERE aa<5",
         "SELECT * FROM (SELECT a AS aa FROM t) AS s WHERE aa>0",
         "SELECT s.aa FROM (SELECT a AS aa FROM t) AS s WHERE s.aa<5",
+        // A bare-`LIMIT` body (no OFFSET) also flattens under a narrower projection
+        // (no outer WHERE) and under a single-term outer ORDER BY (B9c-flatten).
+        "SELECT a FROM (SELECT * FROM t LIMIT 5) AS s",
+        "SELECT s.a FROM (SELECT * FROM t LIMIT 5) AS s",
+        "WITH c AS (SELECT * FROM t LIMIT 5) SELECT a FROM c",
+        "SELECT * FROM (SELECT * FROM t LIMIT 5) AS s ORDER BY a",
+        "SELECT a FROM (SELECT * FROM t LIMIT 5) AS s ORDER BY a",
+        "SELECT * FROM (SELECT * FROM t LIMIT 5) AS s ORDER BY b",
     ] {
         let sql = format!("{base} EXPLAIN QUERY PLAN {q}");
         assert_eq!(run("sqlite3", &sql), run(g, &sql), "for {q}");
@@ -187,8 +195,11 @@ fn non_flattenable_outer_shapes_decline() {
         "SELECT b FROM (SELECT a AS aa FROM t) AS s", // outer ref not an output of the source
         "SELECT * FROM (SELECT * FROM t JOIN u ON t.a=u.x) AS s", // inner join
         "SELECT * FROM (SELECT * FROM v) AS s",       // inner view
-        "SELECT a FROM (SELECT * FROM t LIMIT 5) AS s", // narrower over a bare-LIMIT body (flatten TODO)
-        "SELECT a FROM (SELECT * FROM t LIMIT 5) AS s", // narrower outer over a LIMIT body
+        // A *multi-term* ORDER BY over a bare-LIMIT body still declines: SQLite
+        // full-sorts the materialized LIMIT rows, but pushing the ORDER BY into the
+        // body would render a partial index walk. (Single-term ORDER BY and a narrower
+        // projection over a bare-LIMIT body DO flatten — see the render test.)
+        "SELECT * FROM (SELECT * FROM t LIMIT 5) AS s ORDER BY a, b",
     ] {
         let sql = format!("{base} EXPLAIN QUERY PLAN {q}");
         let got = run(g, &sql);