Extend ORDER BY elimination to multi-column leading-prefix sorts and equality-prefix-continued-by-order-columns, reusing one composite ordered view via a ragged-arity tuple comparer.

Author: RyanLamansky

CLAUDE.md

@@ -107,7 +107,7 @@ The `*.Tests` and `*.Tests.EFCore` suites are the authoritative behavior contrac
 
 ### Constraints
 - `CHECK`: inline single-column and table-level forms; Msg 547 per row on definitely-false predicate. Inline column-level CHECK predicates may only reference their owning column — peer references raise **Msg 8141** at CREATE TABLE (probe-confirmed verbatim wording). The walker is structural via `Expression.VisitColumnReferences` + `BooleanExpression.VisitOperandExpressions`; coverage is currently limited to common container subclasses (`Reference`, `Parenthesized`, `TwoSidedExpression`, `Cast`, `Length`) — peer refs buried in less-common containers (`DATEPART`, `SUBSTRING`, nested `CASE`, etc.) silently escape the CREATE-TABLE check and surface at INSERT instead. Table-level CHECK has no peer restriction.
-- `PRIMARY KEY` / `UNIQUE`: linear scan (O(N) per insert); no B-tree. Reads get **incrementally-maintained** per-`Heap` seek acceleration (no per-mutation warm-up): equality / IN on the longest leading prefix, range (`>`/`<`/`BETWEEN`) on a leading key column, and ORDER BY elimination for a single NOT-NULL leading-key-column sort. See [`indexes.md`](docs/claude/indexes.md) for the journal mechanics, decline rules, and the residual-WHERE correctness invariant.
+- `PRIMARY KEY` / `UNIQUE`: linear scan (O(N) per insert); no B-tree. Reads get **incrementally-maintained** per-`Heap` seek acceleration (no per-mutation warm-up): equality / IN on the longest leading prefix, range (`>`/`<`/`BETWEEN`) on a leading key column, and ORDER BY elimination — single or multi-column leading-prefix sort (all NOT NULL, all one direction), including an equality-prefix continued by the order columns (`WHERE a = @x ORDER BY b`). See [`indexes.md`](docs/claude/indexes.md) for the journal mechanics, decline rules, and the residual-WHERE correctness invariant.
 - `FOREIGN KEY`: inline / table-level / named forms; all four referential actions on `ON DELETE` / `ON UPDATE`; enforced at INSERT / UPDATE / DELETE / MERGE; full `sys.foreign_keys` / `sys.foreign_key_columns`. Referential-action, cascade-cycle, PK/UNIQUE-target, and NULL-skip rules + Msg numbers in [`foreign-keys.md`](docs/claude/foreign-keys.md).
 
 ### Transactions

SqlServerSimulator.Tests.Internal/IndexSeekTests.cs

@@ -1094,6 +1094,125 @@ insert t values (1, 30), (2, 10), (3, 20)
         AreEqual("10,20,30", Seq(rows));
     }
 
+    [TestMethod]
+    public void EqualityPrefixThenOrderBySuffix_Eliminates()
+    {
+        // WHERE a = 1 ORDER BY b on PK (a, b): the seek positions on a = 1 and
+        // the trailing key column emerges already ordered — no buffered sort, and
+        // only the a = 1 group is touched (a = 2 rows are interleaved in heap
+        // order to prove the scan doesn't drag them in).
+        var (trace, rows) = Run("""
+            create table t (a int not null, b int not null, primary key (a, b));
+            insert t values (2, 5), (1, 30), (1, 10), (2, 1), (1, 20)
+            """, "select b from t where a = 1 order by b");
+        Contains("OrderedScan(t)", trace);
+        AreEqual("10,20,30", Seq(rows));
+    }
+
+    [TestMethod]
+    public void EqualityPrefixThenOrderBySuffixDescending_Eliminates()
+    {
+        var (trace, rows) = Run("""
+            create table t (a int not null, b int not null, primary key (a, b));
+            insert t values (2, 5), (1, 30), (1, 10), (1, 20)
+            """, "select b from t where a = 1 order by b desc");
+        Contains("OrderedScan(t)", trace);
+        AreEqual("30,20,10", Seq(rows));
+    }
+
+    [TestMethod]
+    public void EqualityPrefixWithRedundantOrderColumn_Eliminates()
+    {
+        // ORDER BY a, b with a pinned to a constant ≡ ORDER BY b: a is stripped as
+        // a constant, leaving b as the effective order column.
+        var (trace, rows) = Run("""
+            create table t (a int not null, b int not null, primary key (a, b));
+            insert t values (1, 30), (1, 10), (2, 99), (1, 20)
+            """, "select b from t where a = 1 order by a, b");
+        Contains("OrderedScan(t)", trace);
+        AreEqual("10,20,30", Seq(rows));
+    }
+
+    [TestMethod]
+    public void EqualityPrefixAndRangeOnOrderColumn_EliminatesAndNarrows()
+    {
+        // WHERE a = 1 AND b >= 20 AND b < 40 ORDER BY b: the pinned a = 1 prefix
+        // plus a folded range on b stream the matching slice already ordered.
+        var (trace, rows) = Run("""
+            create table t (a int not null, b int not null, primary key (a, b));
+            insert t values (1, 10), (1, 20), (1, 30), (1, 40), (2, 25)
+            """, "select b from t where a = 1 and b >= 20 and b < 40 order by b");
+        Contains("OrderedScan(t)", trace);
+        AreEqual("20,30", Seq(rows));
+    }
+
+    [TestMethod]
+    public void MultiColumnOrderByDescending_Eliminates_Reversed()
+    {
+        // ORDER BY a DESC, b DESC reverses the ascending composite view.
+        var (trace, rows) = Run("""
+            create table t (a int not null, b int not null, primary key (a, b));
+            insert t values (2, 1), (1, 2), (1, 1), (2, 2)
+            """, "select 10 * a + b from t order by a desc, b desc");
+        Contains("OrderedScan(t)", trace);
+        AreEqual("22,21,12,11", Seq(rows));
+    }
+
+    [TestMethod]
+    public void EqualityPrefixNullProbe_ReturnsEmpty()
+    {
+        // a = NULL matches nothing; the ordered seek resolves to an empty stream.
+        // (a is a nullable leading index column, not a PK column.)
+        var (_, rows) = Run("""
+            create table t (a int null, b int not null);
+            create index ix on t (a, b);
+            insert t values (1, 10), (1, 20)
+            """, "select b from t where a = null order by b");
+        IsEmpty(rows);
+    }
+
+    [TestMethod]
+    public void EqualityPrefixOrderedScanCorrectAfterMutations()
+    {
+        // The composite ordered view feeding an equality-prefix scan must stay
+        // current under the incremental journal: warm, mutate, then a later
+        // WHERE a = 1 ORDER BY b reflects the changes in order.
+        var c = new Simulation().CreateDbConnection();
+        c.Open();
+        Exec(c, "create table t (a int not null, b int not null, primary key (a, b))");
+        Exec(c, "insert t values (1, 30), (1, 10), (2, 5), (1, 20)");
+        _ = ReadRows(c, "select b from t where a = 1 order by b");
+        Exec(c, "insert t values (1, 5), (2, 1)");
+        Exec(c, "delete from t where a = 1 and b = 20");
+        Exec(c, "update t set b = 15 where a = 1 and b = 30");
+        var rows = ReadRows(c, "select b from t where a = 1 order by b");
+        AreEqual("5,10,15", Seq(rows));
+    }
+
+    [TestMethod]
+    public void MultiColumnOrderByDifferential_MatchesIndependentSort()
+    {
+        // Cross-check an eliminated composite ORDER BY against a C# sort over a
+        // no-WHERE read (which doesn't eliminate). 1000 * a + b fully encodes the
+        // (a, b) order (b < 1000), so sorting the integer equals ORDER BY a, b.
+        var c = new Simulation().CreateDbConnection();
+        c.Open();
+        Exec(c, "create table t (id int not null primary key, a int not null, b int not null)");
+        Exec(c, "create index ix on t (a, b)");
+        Exec(c, "insert t (id, a, b) select value, (value * 7919) % 17, (value * 104729) % 97 from generate_series(1, 300)");
+
+        var expected = new List<int>();
+        foreach (var o in ReadRows(c, "select 1000 * a + b from t"))
+            expected.Add(Convert.ToInt32(o));
+        expected.Sort();
+
+        var actual = new List<int>();
+        foreach (var o in ReadRows(c, "select 1000 * a + b from t order by a, b"))
+            actual.Add(Convert.ToInt32(o));
+
+        AreEqual(string.Join(",", expected), string.Join(",", actual));
+    }
+
     // ---- declines (keeps the buffered sort), still correct order ----
 
     [TestMethod]
@@ -1119,13 +1238,15 @@ public void OrderByExpression_Declines()
     }
 
     [TestMethod]
-    public void MultiColumnOrderBy_Declines()
+    public void MultiColumnOrderBy_OnCompositeKey_Eliminates()
     {
+        // ORDER BY a, b matches the (a, b) PK leading prefix, both NOT NULL, so
+        // the composite ordered view streams in key order — no buffered sort.
         var (trace, rows) = Run("""
             create table t (a int not null, b int not null, primary key (a, b));
             insert t values (2, 1), (1, 2), (1, 1)
             """, "select a from t order by a, b");
-        DoesNotContain("OrderedScan(t)", trace);
+        Contains("OrderedScan(t)", trace);
         AreEqual("1,1,2", Seq(rows));
     }
 
@@ -1137,6 +1258,46 @@ public void DistinctOrderBy_Declines()
         AreEqual("1,2,3,4,5", Seq(rows));
     }
 
+    [TestMethod]
+    public void MixedDirectionMultiColumnOrderBy_Declines()
+    {
+        // a ASC, b DESC can't be served by the single ascending-by-value
+        // composite view (only all-ASC or all-DESC), so elimination declines.
+        var (trace, rows) = Run("""
+            create table t (a int not null, b int not null, primary key (a, b));
+            insert t values (1, 2), (1, 1), (2, 1)
+            """, "select 10 * a + b from t order by a asc, b desc");
+        DoesNotContain("OrderedScan(t)", trace);
+        AreEqual("12,11,21", Seq(rows));
+    }
+
+    [TestMethod]
+    public void MultiColumnOrderByNullableSuffix_Declines()
+    {
+        // b is nullable, so its NULL-key rows aren't in the composite view —
+        // elimination declines and the sort puts the NULL first.
+        var (trace, rows) = Run("""
+            create table t (a int not null, b int null);
+            create index ix on t (a, b);
+            insert t values (1, 30), (1, null), (1, 10)
+            """, "select b from t where a = 1 order by b");
+        DoesNotContain("OrderedScan(t)", trace);
+        AreEqual(",10,30", Seq(rows));
+    }
+
+    [TestMethod]
+    public void OrderByColumnsNotMatchingKeyOrder_Declines()
+    {
+        // ORDER BY b, a doesn't match the (a, b) key order, so no ordered view
+        // serves it.
+        var (trace, rows) = Run("""
+            create table t (a int not null, b int not null, primary key (a, b));
+            insert t values (1, 2), (2, 1), (1, 1)
+            """, "select 10 * a + b from t order by b, a");
+        DoesNotContain("OrderedScan(t)", trace);
+        AreEqual("11,21,12", Seq(rows));
+    }
+
     [TestMethod]
     public void EqualityOnOtherIndexedColumn_DeclinesOrderElimination_PrefersSeek()
     {