@quereus/quereus 4.20.1 → 4.20.2

package/test/logic/28.2-orderby-expression-extras.sqllogic

@@ -0,0 +1,698 @@
+-- adapted from SQLite test/select1.test, test/orderby1.test, test/orderby5.test,
+-- test/orderby8.test, test/orderby9.test, test/e_select.test
+-- ORDER BY targets that aren't bare column names: positional references,
+-- arithmetic / function expressions, mixed CASE, multi-column COLLATE, and
+-- expression-derived ORDER BY in the absence of GROUP BY.
+
+create table ob (id integer primary key, a integer, b integer null, c text);
+insert into ob values
+  (1, 10, null,  'p'),
+  (2, 20,    5,  'q'),
+  (3,  5,    3,  'r'),
+  (4, 15, null,  'p'),
+  (5, 30,   10,  'q'),
+  (6,  1,    7,  's');
+
+-- ORDER BY positional reference (1 → first SELECT column)
+select a from ob order by 1;
+→ [{"a":1},{"a":5},{"a":10},{"a":15},{"a":20},{"a":30}]
+
+-- ORDER BY positional, multi-column, mixed direction
+select c, a from ob order by 1, 2 desc;
+→ [{"c":"p","a":15},{"c":"p","a":10},{"c":"q","a":30},{"c":"q","a":20},{"c":"r","a":5},{"c":"s","a":1}]
+
+-- ORDER BY with DESC on the first key, and an expression alias second
+select a, b * 2 as bx from ob where b is not null order by a desc, bx;
+→ [{"a":30,"bx":20},{"a":20,"bx":10},{"a":5,"bx":6},{"a":1,"bx":14}]
+
+-- ORDER BY arithmetic expression on a non-projected column
+select id from ob where b is not null order by abs(b - 6), id;
+→ [{"id":2},{"id":6},{"id":3},{"id":5}]
+
+-- ORDER BY a CASE expression — null bucketed past real values
+select id, b from ob order by case when b is null then 999 else b end, id;
+→ [{"id":3,"b":3},{"id":2,"b":5},{"id":6,"b":7},{"id":5,"b":10},{"id":1,"b":null},{"id":4,"b":null}]
+
+-- ORDER BY a + b with null propagation; nulls land last via NULLS LAST
+select id, b from ob order by a + b nulls last, id;
+→ [{"id":3,"b":3},{"id":6,"b":7},{"id":2,"b":5},{"id":5,"b":10},{"id":1,"b":null},{"id":4,"b":null}]
+
+drop table ob;
+
+-- =============================================================================
+-- ORDER BY with per-column COLLATE directives in a multi-key sort
+-- =============================================================================
+
+create table cm (id integer primary key, a text, b text);
+insert into cm values
+  (1, 'Alice', 'bob'),
+  (2, 'bob',   'ALICE'),
+  (3, 'alice', 'Bob');
+
+-- a COLLATE binary, b COLLATE nocase: 'A'<'a' under binary
+select id from cm order by a collate binary, b collate nocase;
+→ [{"id":1},{"id":3},{"id":2}]
+
+-- Reverse roles: a NOCASE then b BINARY
+-- Under nocase, 'Alice'~'alice', tie broken by b binary: 'bob' (id=1) vs 'Bob' (id=3) → 'Bob' first.
+select id from cm order by a collate nocase, b collate binary;
+→ [{"id":3},{"id":1},{"id":2}]
+
+drop table cm;
+
+-- =============================================================================
+-- ORDER BY many computed columns — sort key precedence remains correct
+-- =============================================================================
+
+create table many (x integer);
+insert into many values (1), (5), (9), (7), (3), (2), (4), (6), (8);
+
+-- Several computed result columns alongside the sort key
+select x, x + 1 as p1, x + 2 as p2, x + 10 as p10, x + 100 as p100
+from many order by x;
+→ [{"x":1,"p1":2,"p2":3,"p10":11,"p100":101},{"x":2,"p1":3,"p2":4,"p10":12,"p100":102},{"x":3,"p1":4,"p2":5,"p10":13,"p100":103},{"x":4,"p1":5,"p2":6,"p10":14,"p100":104},{"x":5,"p1":6,"p2":7,"p10":15,"p100":105},{"x":6,"p1":7,"p2":8,"p10":16,"p100":106},{"x":7,"p1":8,"p2":9,"p10":17,"p100":107},{"x":8,"p1":9,"p2":10,"p10":18,"p100":108},{"x":9,"p1":10,"p2":11,"p10":19,"p100":109}]
+
+-- Alias and positional references resolve to the same expression
+select abs(x - 5) as dist from many order by dist;
+→ [{"dist":0},{"dist":1},{"dist":1},{"dist":2},{"dist":2},{"dist":3},{"dist":3},{"dist":4},{"dist":4}]
+
+-- ORDER BY positional ordinal resolves to the SELECT-list expression
+select abs(x - 5) as dist from many order by 1;
+→ [{"dist":0},{"dist":1},{"dist":1},{"dist":2},{"dist":2},{"dist":3},{"dist":3},{"dist":4},{"dist":4}]
+
+drop table many;
+
+-- =============================================================================
+-- ORDER BY / GROUP BY positional references bind to an OUTPUT POSITION, never
+-- to the name of the expression that produced it. Each case below is paired
+-- with a control query that must produce a DIFFERENT row order than a
+-- name-based resolution would, so a regression cannot pass by coincidence.
+-- =============================================================================
+
+create table nk (a text primary key, b text);
+insert into nk values ('x','1'), ('w','9');
+
+-- A SELECT-list alias shadows the column the ordinal points at.
+-- Position 2 is `z` (= nk.a), so the 'w' row sorts first. Resolving the ordinal
+-- through the name `a` would find the alias over nk.b and sort '1' before '9'.
+select b as a, a as z from nk order by 2;
+→ [{"a":"9","z":"w"},{"a":"1","z":"x"}]
+
+-- Control: the same sort spelled by alias
+select b as a, a as z from nk order by z;
+→ [{"a":"9","z":"w"},{"a":"1","z":"x"}]
+
+-- Discriminator: sorting by output position 1 gives the OPPOSITE order
+select b as a, a as z from nk order by 1;
+→ [{"a":"1","z":"x"},{"a":"9","z":"w"}]
+
+-- Same shadowing, with the target column arriving via a star
+select b as a, * from nk order by 2;
+→ [{"a":"9","a:1":"w","b":"9"},{"a":"1","a:1":"x","b":"1"}]
+
+-- Control: qualified name for the star-expanded column
+select b as a, * from nk order by nk.a;
+→ [{"a":"9","a:1":"w","b":"9"},{"a":"1","a:1":"x","b":"1"}]
+
+-- A pre-projection sort (second key is not a projected output column) keeps
+-- resolving the ordinal against the SELECT list, and still lands on `z`
+select b as a, a as z from nk order by 2, a;
+→ [{"a":"9","z":"w"},{"a":"1","z":"x"}]
+
+select b as a, a as z from nk order by z, a;
+→ [{"a":"9","z":"w"},{"a":"1","z":"x"}]
+
+-- Out-of-range ordinals still fail at prepare time
+select a from nk order by 3;
+-- error: ORDER BY position 3 is not in the SELECT list (1..1)
+
+drop table nk;
+
+-- -----------------------------------------------------------------------------
+-- Two joined tables expose the same column name under `*`
+-- -----------------------------------------------------------------------------
+
+create table ot1 (k integer primary key, v text);
+create table ot2 (k integer primary key, v text);
+insert into ot1 values (1,'a1'), (2,'b1');
+insert into ot2 values (1,'z2'), (2,'y2');
+
+-- Output column 4 is ot2.v, so the k=2 row ('y2') sorts first
+select * from ot1 join ot2 on ot1.k = ot2.k order by 4;
+→ [{"k":2,"v":"b1","k:1":2,"v:1":"y2"},{"k":1,"v":"a1","k:1":1,"v:1":"z2"}]
+
+-- Control: matches the qualified ot2.v spelling
+select * from ot1 join ot2 on ot1.k = ot2.k order by ot2.v;
+→ [{"k":2,"v":"b1","k:1":2,"v:1":"y2"},{"k":1,"v":"a1","k:1":1,"v:1":"z2"}]
+
+-- Discriminator: ot1.v produces the OPPOSITE order, so a name-based resolution
+-- (which picks the first `v` in scope) cannot pass the case above
+select * from ot1 join ot2 on ot1.k = ot2.k order by ot1.v;
+→ [{"k":1,"v":"a1","k:1":1,"v:1":"z2"},{"k":2,"v":"b1","k:1":2,"v:1":"y2"}]
+
+drop table ot2;
+drop table ot1;
+
+-- -----------------------------------------------------------------------------
+-- Ordinals pointing at computed output columns (window / aggregate)
+-- -----------------------------------------------------------------------------
+
+create table og (id integer primary key, a text, b text);
+insert into og values (1,'x','1'), (2,'w','9');
+
+-- DISTINCT takes the same path; position 2 is still `z`
+select distinct b as a, a as z from og order by 2;
+→ [{"a":"9","z":"w"},{"a":"1","z":"x"}]
+
+select distinct b as a, a as z from og order by z;
+→ [{"a":"9","z":"w"},{"a":"1","z":"x"}]
+
+-- The ordinal points at a window function: it must READ the computed column,
+-- not re-plan a fresh window expression inside the sort
+select b as a, row_number() over (order by a) as z from og order by 2;
+→ [{"a":"9","z":1},{"a":"1","z":2}]
+
+select b as a, row_number() over (order by a) as z from og order by z;
+→ [{"a":"9","z":1},{"a":"1","z":2}]
+
+-- The ordinal points at an aggregate in a query with no GROUP BY
+select count(*) as c from og order by 1;
+→ [{"c":2}]
+
+select count(*) as c from og order by count(*);
+→ [{"c":2}]
+
+select count(*) as c, max(a) as m from og order by 2;
+→ [{"c":2,"m":"x"}]
+
+-- GROUP BY ordinal binds to the aliased expression, not to the alias name
+select b as a, count(*) as c from og group by 1 order by 1;
+→ [{"a":"1","c":1},{"a":"9","c":1}]
+
+select b as a, count(*) as c from og group by b order by 1;
+→ [{"a":"1","c":1},{"a":"9","c":1}]
+
+-- Grouped query, ORDER BY ordinal on the aggregate output column
+select b as q, count(*) as c from og group by b order by 2 desc, 1;
+→ [{"q":"1","c":1},{"q":"9","c":1}]
+
+drop table og;
+
+-- -----------------------------------------------------------------------------
+-- GROUP BY ordinal onto a star-expanded column whose name is shared
+-- -----------------------------------------------------------------------------
+
+create table jt1 (id integer primary key, k integer, v text);
+create table jt2 (k integer primary key, v text);
+insert into jt1 values (1,1,'L'), (2,1,'L'), (3,2,'L');
+insert into jt2 values (1,'R1'), (2,'R2');
+
+-- Positions 1 and 2 are jt2.k / jt2.v (from `jt2.*`). Resolving them through
+-- the bare names `k` / `v` finds jt1's columns first, which leaves jt2.k and
+-- jt2.v ungrouped and fails the GROUP BY coverage check.
+select jt2.*, count(*) as n from jt1 join jt2 on jt1.k = jt2.k group by 1, 2 order by 1;
+→ [{"k":1,"v":"R1","n":2},{"k":2,"v":"R2","n":1}]
+
+select jt2.*, count(*) as n from jt1 join jt2 on jt1.k = jt2.k group by jt2.k, jt2.v order by 1;
+→ [{"k":1,"v":"R1","n":2},{"k":2,"v":"R2","n":1}]
+
+-- ORDER BY ordinal over that grouped output: position 3 is the count
+select jt2.*, count(*) as n from jt1 join jt2 on jt1.k = jt2.k group by 1, 2 order by 3 desc;
+→ [{"k":1,"v":"R1","n":2},{"k":2,"v":"R2","n":1}]
+
+-- An ORDER BY that names an aggregate the select list lacks sorts in the same
+-- place as every other aggregate ORDER BY: above the grouped query's final
+-- projection. A second ordinal key in the same clause therefore binds to that
+-- projection's output attributes. Position 2 is jt2.v either way -- binding to
+-- the output attribute and falling back to the select list agree here -- so
+-- these two pin the result, not the route.
+select jt2.*, count(*) as n from jt1 join jt2 on jt1.k = jt2.k group by 1, 2 order by count(*) desc, 2;
+→ [{"k":1,"v":"R1","n":2},{"k":2,"v":"R2","n":1}]
+
+select jt2.*, count(*) as n from jt1 join jt2 on jt1.k = jt2.k group by jt2.k, jt2.v order by count(*) desc, jt2.v;
+→ [{"k":1,"v":"R1","n":2},{"k":2,"v":"R2","n":1}]
+
+drop table jt2;
+drop table jt1;
+
+-- -----------------------------------------------------------------------------
+-- Qualified stars from more than two sources
+-- -----------------------------------------------------------------------------
+
+create table os1 (k integer primary key, v text);
+create table os2 (k integer primary key, v text);
+create table os3 (k integer primary key, v text);
+insert into os1 values (1,'a1'), (2,'b1');
+insert into os2 values (1,'z2'), (2,'y2');
+insert into os3 values (1,'m3'), (2,'n3');
+
+-- All three sources expose a `v`; position 6 is os3.v and position 4 is os2.v,
+-- and the two produce OPPOSITE row orders, so neither can pass by coincidence.
+select os1.*, os2.*, os3.* from os1 join os2 on os1.k = os2.k join os3 on os1.k = os3.k order by 6;
+→ [{"k":1,"v":"a1","k:1":1,"v:1":"z2","k:2":1,"v:2":"m3"},{"k":2,"v":"b1","k:1":2,"v:1":"y2","k:2":2,"v:2":"n3"}]
+
+select os1.*, os2.*, os3.* from os1 join os2 on os1.k = os2.k join os3 on os1.k = os3.k order by os3.v;
+→ [{"k":1,"v":"a1","k:1":1,"v:1":"z2","k:2":1,"v:2":"m3"},{"k":2,"v":"b1","k:1":2,"v:1":"y2","k:2":2,"v:2":"n3"}]
+
+select os1.*, os2.*, os3.* from os1 join os2 on os1.k = os2.k join os3 on os1.k = os3.k order by 4;
+→ [{"k":2,"v":"b1","k:1":2,"v:1":"y2","k:2":2,"v:2":"n3"},{"k":1,"v":"a1","k:1":1,"v:1":"z2","k:2":1,"v:2":"m3"}]
+
+select os1.*, os2.*, os3.* from os1 join os2 on os1.k = os2.k join os3 on os1.k = os3.k order by os2.v;
+→ [{"k":2,"v":"b1","k:1":2,"v:1":"y2","k:2":2,"v:2":"n3"},{"k":1,"v":"a1","k:1":1,"v:1":"z2","k:2":1,"v:2":"m3"}]
+
+drop table os3;
+drop table os2;
+drop table os1;
+
+-- -----------------------------------------------------------------------------
+-- Ordinals through the remaining ORDER BY shapes
+-- -----------------------------------------------------------------------------
+
+create table ow (id integer primary key, a text, b text);
+insert into ow values (1,'x','p'), (2,'w','q'), (3,'v','q');
+
+-- Ordinals compose with the rest of the clause: direction, a second key,
+-- LIMIT, and NULLS placement all still apply to the bound output column.
+select b as z, id from ow order by 1, 2;
+→ [{"z":"p","id":1},{"z":"q","id":2},{"z":"q","id":3}]
+
+select b as z, id from ow order by 1 desc, 2;
+→ [{"z":"q","id":2},{"z":"q","id":3},{"z":"p","id":1}]
+
+select b as z, id from ow order by 1, 2 limit 2;
+→ [{"z":"p","id":1},{"z":"q","id":2}]
+
+-- A star select list under GROUP BY: the ordinals name the grouped columns
+select * from ow group by 1, 2, 3 order by 2;
+→ [{"id":3,"a":"v","b":"q"},{"id":2,"a":"w","b":"q"},{"id":1,"a":"x","b":"p"}]
+
+select * from ow group by id, a, b order by a;
+→ [{"id":3,"a":"v","b":"q"},{"id":2,"a":"w","b":"q"},{"id":1,"a":"x","b":"p"}]
+
+-- Through a CTE and through a derived table: the outer `select *` publishes the
+-- inner names, and position 2 is still the inner `z`
+with cw as (select b as a, a as z from ow) select * from cw order by 2;
+→ [{"a":"q","z":"v"},{"a":"q","z":"w"},{"a":"p","z":"x"}]
+
+select * from (select b as a, a as z from ow) order by 2;
+→ [{"a":"q","z":"v"},{"a":"q","z":"w"},{"a":"p","z":"x"}]
+
+-- Zero is out of range, like a negative or too-large position
+select a from ow order by 0;
+-- error: ORDER BY position 0 is not in the SELECT list (1..1)
+
+-- A window query containing `*` publishes one output attribute per SELECT-list
+-- column, stars expanded, so an ordinal binds the window column directly:
+-- position 4 is `w`, after the three star columns.
+select *, row_number() over (order by a) as w from ow order by 4;
+→ [{"id":3,"a":"v","b":"q","w":1},{"id":2,"a":"w","b":"q","w":2},{"id":1,"a":"x","b":"p","w":3}]
+
+select *, row_number() over (order by a) as w from ow order by 4 desc;
+→ [{"id":1,"a":"x","b":"p","w":3},{"id":2,"a":"w","b":"q","w":2},{"id":3,"a":"v","b":"q","w":1}]
+
+-- ...and position 5 is out of range: the select list has 4 entries.
+select *, row_number() over (order by a) as w from ow order by 5;
+-- error: ORDER BY position 5 is not in the SELECT list (1..4)
+
+drop table ow;
+
+-- NULLS FIRST / LAST apply to the bound output column
+create table onul (id integer primary key, v text null);
+insert into onul values (1, null), (2, 'a');
+
+select v as z, id from onul order by 1 nulls first;
+→ [{"z":null,"id":1},{"z":"a","id":2}]
+
+select v as z, id from onul order by 1 nulls last;
+→ [{"z":"a","id":2},{"z":null,"id":1}]
+
+drop table onul;
+
+-- The bound output column carries its declared collation, so an ordinal sorts
+-- identically to the name form
+create table ocol (id integer primary key, v text collate nocase);
+insert into ocol values (1,'B'), (2,'a');
+
+select v as z from ocol order by 1;
+→ [{"z":"a"},{"z":"B"}]
+
+select v as z from ocol order by z;
+→ [{"z":"a"},{"z":"B"}]
+
+drop table ocol;
+
+-- =============================================================================
+-- An UNGROUPED aggregate query's ORDER BY can name the query's own output
+-- columns by SELECT-list alias. The alias only exists above the aggregation, so
+-- the sort has to run there rather than on the per-input rows.
+-- =============================================================================
+
+create table g (id integer primary key, a text, b text);
+insert into g values (1,'p','1'), (2,'p','2'), (3,'q','1');
+
+-- The whole query is one row; naming its own column just returns it
+select count(*) as c from g order by c;
+→ [{"c":3}]
+
+select count(*) as c from g order by c desc;
+→ [{"c":3}]
+
+-- The alias of the SECOND aggregate, not the first
+select count(*) as c, max(a) as m from g order by m;
+→ [{"c":3,"m":"q"}]
+
+-- A WRAPPED aggregate: the aggregate entry is aliased `count(*)`, so `c` names
+-- the final projection's output column, not the AggregateNode's
+select count(*) + 1 as c from g order by c;
+→ [{"c":4}]
+
+-- The alias inside a larger ORDER BY expression, and under COLLATE
+select count(*) as c from g order by c + 1;
+→ [{"c":3}]
+
+select max(a) as c from g order by c collate nocase;
+→ [{"c":"q"}]
+
+-- Alias matching is case-insensitive
+select count(*) as "C" from g order by c;
+→ [{"C":3}]
+
+-- Composes with a second sort key and with LIMIT
+select count(*) as c from g order by c, max(a);
+→ [{"c":3}]
+
+select count(*) as c from g order by c limit 1;
+→ [{"c":3}]
+
+-- ...but the second key must itself be legal above the aggregate. ORDER BY
+-- placement is decided for the WHOLE list, not per term: naming the alias `c`
+-- moves every term above the AggregateNode, and a bare source column up there is
+-- neither a grouping key (there are none) nor an aggregate.
+select count(*) as c from g order by c, id;
+-- error: Column 'id' must appear in the GROUP BY clause or be used in an aggregate function
+
+-- Same list, other order — the rejection is about the list, not about which term
+-- came first.
+select count(*) as c from g order by id, c;
+-- error: Column 'id' must appear in the GROUP BY clause or be used in an aggregate function
+
+-- Control: with NO alias and no aggregate in the list, the whole list stays below
+-- the aggregate and `id` is an ordinary pre-aggregate sort key.
+select count(*) as c from g order by id;
+→ [{"c":3}]
+
+-- ...and with HAVING
+select count(*) as c from g having count(*) > 0 order by c;
+→ [{"c":3}]
+
+-- A SELECT-list alias OUTRANKS a same-named source column, matching SQLite and
+-- the non-aggregate / grouped paths. Observable through an order-sensitive
+-- aggregate: `a` names the one-row output, so the sort is a no-op and the
+-- concatenation keeps insertion order.
+select group_concat(b) as a from g order by a desc;
+→ [{"a":"1,2,1"}]
+
+-- Control: with no alias to claim the name, `a` is still g.a and the
+-- pre-aggregate sort extension still orders the input before concatenating.
+-- The `, id` tiebreak keeps the two a='p' rows in a fixed order.
+select group_concat(b) as gc from g order by a desc, id;
+→ [{"gc":"1,1,2"}]
+
+select group_concat(b) as gc from g order by a, id;
+→ [{"gc":"1,2,1"}]
+
+-- Same control spelled with a table qualifier: `g.a` is never an alias, so the
+-- input sort survives even though a select-list alias `a` exists
+select group_concat(b) as a from g order by g.a desc, id;
+→ [{"a":"1,1,2"}]
+
+-- A scalar subquery's ProjectNode does not forward the aggregate's own output
+-- column, yet both spellings still resolve
+select (select count(*) + 1 as c from g order by c) as v;
+→ [{"v":4}]
+
+select (select count(*) + 1 as c from g order by count(*)) as v;
+→ [{"v":4}]
+
+-- A subquery in ORDER BY: the alias scan walks into it, so it must not trip over
+-- the subquery's own SELECT-list result columns
+select count(*) as zz from g order by (select 1);
+→ [{"zz":3}]
+
+-- Non-regressions: the spelled-out aggregate, the ordinal, and a qualified name
+select count(*) as c from g order by count(*);
+→ [{"c":3}]
+
+select count(*) as c from g order by 1;
+→ [{"c":3}]
+
+select count(*) as c from g order by g.a;
+→ [{"c":3}]
+
+-- Two select-list columns claiming the same alias: the routing predicate only asks
+-- whether the name is mentioned and leaves resolution to the scope, which rejects it.
+-- Deliberate divergence: SQLite binds the first match (returns `3|q`), and Quereus's
+-- own non-aggregate and grouped paths accept the duplicate too; only the aggregate
+-- output scope treats it as ambiguous. Erroring on a genuinely ambiguous name is the
+-- behaviour we want here — this pins it so a change is a decision, not an accident.
+select count(*) as c, max(a) as c from g order by c;
+-- error: ambiguous column name: c
+
+-- An alias that is neither a select-list alias nor a source column still fails
+select count(*) as c from g order by cc;
+-- error: Column not found: cc
+
+-- DISTINCT and a compound select take the same alias route
+select distinct count(*) as c from g order by c;
+→ [{"c":3}]
+
+select count(*) as c from g union all select count(*) from g order by c;
+→ [{"c":3},{"c":3}]
+
+-- Non-regressions: the grouped forms, which never took the pre-aggregate path
+select a, count(*) as c from g group by a order by c;
+→ [{"a":"q","c":1},{"a":"p","c":2}]
+
+select a, count(*) as c from g group by a order by c + 1;
+→ [{"a":"q","c":1},{"a":"p","c":2}]
+
+drop table g;
+
+-- =============================================================================
+-- ORDER BY that names BOTH an aggregate the SELECT list lacks AND a SELECT-list
+-- alias. The sort-only aggregate is computed by the AggregateNode but stripped
+-- by the final projection; the alias exists only ON that final projection. One
+-- sort placement -- above the final projection -- has to serve both names.
+-- Rows below are SQLite's.
+-- =============================================================================
+
+create table soa (id integer primary key, a text, b text);
+insert into soa values (1,'x','p'), (2,'y','q'), (3,'x','r');
+
+-- --- UNGROUPED: the whole table is one row, so only the key resolution is
+-- --- under test, not the ordering.
+
+-- bare-aggregate alias (`c` also names the AggregateNode's own output column)
+select count(*) as c from soa order by max(a), c;
+→ [{"c":3}]
+
+-- computed-aggregate alias: the aggregate entry is aliased `count(*)`, so `c`
+-- names ONLY the final projection's output column. This is the shape that used
+-- to fail with "Column not found: c".
+select count(*) + 1 as c from soa order by max(a), c;
+→ [{"c":4}]
+
+-- positional reference alongside the sort-only aggregate
+select count(*) + 1 as c from soa order by max(a), 1;
+→ [{"c":4}]
+
+-- the alias inside a larger ORDER BY expression
+select count(*) + 1 as c from soa order by max(a), c + 0;
+→ [{"c":4}]
+
+-- the sort-only aggregate need not be the same function as the selected one
+select length(max(a)) as c from soa order by min(b), c;
+→ [{"c":1}]
+
+-- the ungrouped counterpart of the grouped grouping-key-alias case below: an
+-- ungrouped aggregate query has no grouping key, so a column-free select-list
+-- item stands in for one. Its alias has to resolve on the final projection while
+-- `max(a)` resolves on the AggregateNode below it -- the same two-name split.
+select 'all' as k, count(*) as c from soa order by max(a), k;
+→ [{"k":"all","c":3}]
+
+-- --- GROUPED: group 'x' has max(b)='r' and 2 rows, group 'y' has max(b)='q'
+-- --- and 1 row, so ordering by max(b) puts 'y' first.
+
+-- bare-aggregate alias
+select a, count(*) as c from soa group by a order by max(b), c;
+→ [{"a":"y","c":1},{"a":"x","c":2}]
+
+-- computed-aggregate alias
+select a, count(*) + 1 as c from soa group by a order by max(b), c;
+→ [{"a":"y","c":2},{"a":"x","c":3}]
+
+-- grouping-key alias
+select a as k, count(*) as c from soa group by a order by max(b), k;
+→ [{"k":"y","c":1},{"k":"x","c":2}]
+
+-- positional reference (position 2 is the computed alias)
+select a, count(*) + 1 as c from soa group by a order by max(b), 2;
+→ [{"a":"y","c":2},{"a":"x","c":3}]
+
+-- the alias inside a larger ORDER BY expression
+select a, count(*) + 1 as c from soa group by a order by max(b), c + 0;
+→ [{"a":"y","c":2},{"a":"x","c":3}]
+
+-- --- The same pairing under each surrounding modifier. DISTINCT and LIMIT sit
+-- --- above this sort, HAVING below it.
+
+select distinct count(*) + 1 as c from soa order by max(a), c;
+→ [{"c":4}]
+
+select distinct a, count(*) + 1 as c from soa group by a order by max(b), c;
+→ [{"a":"y","c":2},{"a":"x","c":3}]
+
+select a, count(*) + 1 as c from soa group by a order by max(b), c limit 1;
+→ [{"a":"y","c":2}]
+
+select a, count(*) + 1 as c from soa group by a having count(*) >= 1 order by max(b), c;
+→ [{"a":"y","c":2},{"a":"x","c":3}]
+
+-- --- Nested spellings: a derived table and a scalar subquery each wrap the
+-- --- query in another ProjectNode above the sort.
+
+select * from (select count(*) + 1 as c from soa order by max(a), c);
+→ [{"c":4}]
+
+select (select count(*) + 1 as c from soa order by max(a), c) as v;
+→ [{"v":4}]
+
+drop table soa;
+
+-- =============================================================================
+-- Ordering correctness for the same pairing. The sort-only aggregate max(val)
+-- is deliberately anti-correlated with BOTH the group name and the group size,
+-- so a plan that silently sorted by either would produce a different order:
+--
+--   grp | rows | max(val)      by max(val) asc: a, c, d, e, b
+--   ----+------+---------      by grp asc:      a, b, c, d, e
+--    a  |  3   | m1            by size asc:     b, d, a, c, e
+--    b  |  1   | m4
+--    c  |  4   | m2          Groups d and e TIE on max(val)='m3'; the computed
+--    d  |  2   | m3          alias count(*)+1 (3 vs 6) breaks the tie, so the
+--    e  |  5   | m3          second key's own direction is observable too.
+-- =============================================================================
+
+create table sog (id integer primary key, grp text, val text);
+insert into sog values
+	(1,'a','m1'), (2,'a','l0'), (3,'a','k0'),
+	(4,'b','m4'),
+	(5,'c','m2'), (6,'c','l1'), (7,'c','l2'), (8,'c','k1'),
+	(9,'d','m3'), (10,'d','a0'),
+	(11,'e','m3'), (12,'e','b0'), (13,'e','b1'), (14,'e','b2'), (15,'e','b3');
+
+-- ascending: tie d/e broken ascending by the alias
+select grp, count(*) + 1 as c from sog group by grp order by max(val), c;
+→ [{"grp":"a","c":4},{"grp":"c","c":5},{"grp":"d","c":3},{"grp":"e","c":6},{"grp":"b","c":2}]
+
+-- descending first key, ascending tiebreak: whole order reverses, d still before e
+select grp, count(*) + 1 as c from sog group by grp order by max(val) desc, c;
+→ [{"grp":"b","c":2},{"grp":"d","c":3},{"grp":"e","c":6},{"grp":"c","c":5},{"grp":"a","c":4}]
+
+-- both descending: only the tied pair swaps
+select grp, count(*) + 1 as c from sog group by grp order by max(val) desc, c desc;
+→ [{"grp":"b","c":2},{"grp":"e","c":6},{"grp":"d","c":3},{"grp":"c","c":5},{"grp":"a","c":4}]
+
+-- LIMIT cuts the sorted prefix, and the tiebreak direction decides row 3
+select grp, count(*) + 1 as c from sog group by grp order by max(val), c limit 3;
+→ [{"grp":"a","c":4},{"grp":"c","c":5},{"grp":"d","c":3}]
+
+select grp, count(*) + 1 as c from sog group by grp order by max(val), c desc limit 3;
+→ [{"grp":"a","c":4},{"grp":"c","c":5},{"grp":"e","c":6}]
+
+-- a grouping-key alias as the tiebreak, over a different sort-only aggregate
+select grp as k, count(*) as n from sog group by grp order by min(val) desc, k;
+→ [{"k":"b","n":1},{"k":"c","n":4},{"k":"a","n":3},{"k":"e","n":5},{"k":"d","n":2}]
+
+drop table sog;
+
+-- =============================================================================
+-- DISTINCT actually collapsing rows, with a sort-only aggregate as the key. The
+-- DistinctNode sits BETWEEN the final projection and this sort, so these pin two
+-- things at once: DISTINCT dedupes before the sort (the direction of max(v) is
+-- observable in the surviving order), and the sort-only aggregate key still
+-- resolves through the DistinctNode -- it yields per source row rather than
+-- buffering, so the projection's source row context is still live.
+--
+--   g | rows | max(v)     by max(v) asc:  b(3), a(2), c(2)  -> distinct 3, 2
+--   --+------+-------     by max(v) desc: c(2), a(2), b(3)  -> distinct 2, 3
+--   a |  2   | m1
+--   b |  3   | a2
+--   c |  2   | z1
+-- Rows below are SQLite's.
+-- =============================================================================
+
+create table sod (id integer primary key, g text, v text);
+insert into sod values
+	(1,'b','a0'), (2,'b','a1'), (3,'b','a2'),
+	(4,'a','m0'), (5,'a','m1'),
+	(6,'c','z0'), (7,'c','z1');
+
+select distinct count(*) as c from sod group by g order by max(v);
+→ [{"c":3},{"c":2}]
+
+select distinct count(*) as c from sod group by g order by max(v) desc;
+→ [{"c":2},{"c":3}]
+
+-- same, with a computed alias the final projection alone publishes
+select distinct count(*) + 1 as c from sod group by g order by max(v);
+→ [{"c":4},{"c":3}]
+
+drop table sod;
+
+-- A SELECT-list alias that shadows a real column of the table, with the shadowed
+-- column inside the sort-only aggregate: `max(c)` must still read the table's c
+-- (group x has 'p','r' -> 'r'; group y has 'q'), while the bare `c` key is the
+-- alias on the final projection. One sort placement resolves both. Rows are
+-- SQLite's.
+create table sh (id integer primary key, a text, c text);
+insert into sh values (1,'x','p'), (2,'y','q'), (3,'x','r');
+
+select a, count(*) + 1 as c from sh group by a order by max(c), c;
+→ [{"a":"y","c":2},{"a":"x","c":3}]
+
+select a, count(*) + 1 as c from sh group by a order by max(c) desc, c;
+→ [{"a":"x","c":3},{"a":"y","c":2}]
+
+drop table sh;
+
+-- The same pairing where another builder wraps or re-plans the query: a CTE
+-- body, and the window path (whose ORDER BY was never routed through the
+-- retired early placement, so this pins that the two paths now agree).
+-- Rows are SQLite's.
+create table soa2 (id integer primary key, a text, b text);
+insert into soa2 values (1,'x','p'), (2,'y','q'), (3,'x','r');
+
+with w as (select a, count(*) + 1 as c from soa2 group by a order by max(b), c) select * from w;
+→ [{"a":"y","c":2},{"a":"x","c":3}]
+
+select a, count(*) over () as w, count(*) + 1 as c from soa2 group by a order by max(b), c;
+→ [{"a":"y","w":2,"c":2},{"a":"x","w":2,"c":3}]
+
+drop table soa2;
+
+-- The sort-only aggregate does NOT relax the grouped-plan boundary check for the
+-- keys beside it: `b` is neither grouped nor aggregated, and moving the sort above
+-- the final projection must still reject it at plan time with the user-facing GROUP
+-- BY message -- not ship a plan that dies at run time with "No row context found".
+-- (Deliberate divergence: SQLite accepts this and sorts by an arbitrary row of the
+-- group. See docs/runtime.md § "Corollary: a published source row reaches only the
+-- adjacent consumer".)
+create table sob (id integer primary key, a text, b text);
+insert into sob values (1,'x','p'), (2,'y','q'), (3,'x','r');
+
+select a, count(*) + 1 as c from sob group by a order by max(b), b;
+-- error: Column 'b' must appear in the GROUP BY clause or be used in an aggregate function
+
+drop table sob;