Added CROSS APPLY / OUTER APPLY support: lateral derived tables re-execute per outer row through a new FromSource.LateralPlan, unlocking EF Core 10's SelectMany-over-filtered-navigation shape.

Author: RyanLamansky

CLAUDE.md

@@ -154,7 +154,9 @@ Precedence: INTERSECT > UNION/EXCEPT (which are co-equal, left-to-right). Mismat
 ORDER BY: a non-set-op SELECT keeps branch-internal ORDER BY (which can reference non-projected source columns); when a set-op follows the first branch, per-branch ORDER BY → Msg 156. Top-level ORDER BY (after the chain) wraps via `ApplyTopLevelOrderBy` and references first-branch column names only — no source-column fallback. `Selection.HasOrderBy` is the parse-time signal that gates Msg 156 in `CombineSetOps`.
 
 ### JOINs
-`INNER JOIN ... ON`, bare `JOIN` (= INNER), `LEFT [OUTER] JOIN ... ON`, `CROSS JOIN`. Multi-table chains compose left-to-right. Self-joins via alias work. ON-predicate UNKNOWN excludes. Aliases parse with or without `AS`.
+`INNER JOIN ... ON`, bare `JOIN` (= INNER), `LEFT [OUTER] JOIN ... ON`, `CROSS JOIN`, `CROSS APPLY (...) [AS alias]`, `OUTER APPLY (...) [AS alias]`. Multi-table chains compose left-to-right. Self-joins via alias work. ON-predicate UNKNOWN excludes. Aliases parse with or without `AS`.
+
+APPLY is the lateral form: the right side is a derived-table SELECT re-executed per outer row, with the outer tuple's columns visible inside its WHERE / projection. CROSS APPLY drops outer rows whose plan yields zero rows (INNER-style); OUTER APPLY null-fills the right side (LEFT-style). No `ON` clause — correlation lives inside the inner WHERE. The lateral plan stays deferred (`FromSource.LateralPlan`) and re-executes via `Selection.Execute(currentTupleResolver)` per outer tuple in `JoinDriver`. EF Core 10 emits `CROSS APPLY` for `SelectMany(a => a.Books.Where(...))` over a collection navigation; older EF Core's top-N projection shapes that used `OUTER APPLY` now go through `ROW_NUMBER() OVER` + `LEFT JOIN` instead.
 
 ### CASE
 Searched (`CASE WHEN cond THEN ... [ELSE ...] END`) and simple (`CASE input WHEN val ...`). Branches evaluate in order; first true predicate wins. UNKNOWN excludes (matches WHERE); simple-form `CASE NULL WHEN NULL` falls through. Result type computed via `SqlType.Promote` across all THEN/ELSE, cached on first `GetSqlType`; `Run` coerces matched values to the common type. No-match-no-ELSE → typed NULL.
@@ -240,7 +242,7 @@ Type-metadata accessors (`GetDataTypeName` / `GetFieldType`) read from `Simulate
 - Transactions / locks / MVCC.
 - `RIGHT JOIN` (rewrite as LEFT with sources swapped); `FULL OUTER JOIN`. Both raise `NotSupportedException` at parse.
 - Comma-separated FROM (legacy ANSI-89 join syntax).
-- `CROSS APPLY` / `OUTER APPLY` (lateral). Derived tables in FROM don't see outer scope.
+- Plain derived tables in FROM (without APPLY) don't see outer scope — they execute eagerly at parse time. Lateral access requires `CROSS APPLY` / `OUTER APPLY`. SQL Server actually allows derived-table-sees-outer in any FROM subquery; the gap shows up in compound shapes like `(SELECT … FROM (SELECT TOP(N) … WHERE outer.col = …) AS t)` where the inner correlation isn't expressed via APPLY.
 - `ANY` / `SOME` / `ALL` quantifiers.
 - `UNION` / `UNION ALL` inside a subquery body.
 - Row-constructor `IN ((1,2), (3,4))`.

SqlServerSimulator.Tests.EFCore/EFCoreApply.cs

@@ -0,0 +1,82 @@
+namespace SqlServerSimulator;
+
+/// <summary>
+/// End-to-end tests for the LINQ shapes EF Core 10 translates to
+/// <c>CROSS APPLY</c> / <c>OUTER APPLY</c>: <c>SelectMany</c> over a filtered
+/// collection navigation, and the same shape with <c>DefaultIfEmpty</c> for
+/// the OUTER variant. EF Core 10's emission for top-N projections moved to
+/// <c>ROW_NUMBER() OVER</c> + <c>LEFT JOIN</c>, so APPLY only emerges
+/// here — when the inner correlates by something more than top-level
+/// equality.
+/// </summary>
+[TestClass]
+public class EFCoreApply
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private static TestDbContext SeededContext()
+    {
+        var context = new TestDbContext(TestDbContext.CreateAuthorsSimulation());
+        context.Authors.AddRange(
+            new Author { Name = "alice" },
+            new Author { Name = "bob" },
+            new Author { Name = "carol" });
+        _ = context.SaveChanges();
+        // alice=1: 3 books with scores 10/20/30. bob=2: 1 book with score 5. carol=3: no books.
+        context.Books.AddRange(
+            new Book { AuthorId = 1, Title = "B1", Score = 10 },
+            new Book { AuthorId = 1, Title = "B2", Score = 20 },
+            new Book { AuthorId = 1, Title = "B3", Score = 30 },
+            new Book { AuthorId = 2, Title = "B4", Score = 5 });
+        _ = context.SaveChanges();
+        return context;
+    }
+
+    [TestMethod]
+    public void SelectMany_FilteredNavigation_EmitsCrossApply()
+    {
+        // EF Core 10 emits CROSS APPLY for SelectMany over a filtered
+        // collection navigation. Verifies end-to-end correctness against
+        // the shape probe-confirmed against real SQL Server 2025.
+        using var context = SeededContext();
+        var pairs = context.Authors
+            .SelectMany(a => a.Books.Where(b => b.Score > 10),
+                        (a, b) => new { Author = a.Name, b.Title, b.Score })
+            .OrderBy(x => x.Author).ThenBy(x => x.Score)
+            .ToArray();
+        Assert.HasCount(2, pairs);
+        Assert.AreEqual(("alice", "B2", 20), (pairs[0].Author, pairs[0].Title, pairs[0].Score));
+        Assert.AreEqual(("alice", "B3", 30), (pairs[1].Author, pairs[1].Title, pairs[1].Score));
+    }
+
+    [TestMethod]
+    public void SelectMany_FilterReferencesOuter_EmitsCrossApply()
+    {
+        // Inner WHERE references both outer and inner columns —
+        // can't lift to a JOIN, must be APPLY.
+        using var context = SeededContext();
+        var pairs = context.Authors
+            .SelectMany(a => a.Books.Where(b => b.Score >= a.Id * 5),
+                        (a, b) => new { Author = a.Name, b.Score })
+            .OrderBy(x => x.Author).ThenBy(x => x.Score)
+            .ToArray();
+        // alice (id=1, threshold=5): all 3 books match. bob (id=2, threshold=10): 5 fails.
+        Assert.HasCount(3, pairs);
+        Assert.AreEqual("alice", pairs[0].Author);
+        Assert.AreEqual("alice", pairs[1].Author);
+        Assert.AreEqual("alice", pairs[2].Author);
+    }
+
+    [TestMethod]
+    public void SelectMany_NoMatches_DropsOuterRow()
+    {
+        // carol has no books → CROSS APPLY drops the row entirely.
+        using var context = SeededContext();
+        var names = context.Authors
+            .SelectMany(a => a.Books, (a, b) => a.Name)
+            .Distinct()
+            .OrderBy(n => n)
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { "alice", "bob" }, names);
+    }
+}

SqlServerSimulator.Tests.EFCore/TestDbContext.cs

@@ -284,6 +284,34 @@ internal class CustomerOrder
     public decimal Amount { get; set; }
 }
 
+/// <summary>
+/// Parent of <see cref="Book"/> with an explicit collection navigation
+/// (<see cref="Books"/>). EF Core emits <c>CROSS APPLY</c> for
+/// <c>SelectMany(a =&gt; a.Books.Where(...))</c> against this shape — the
+/// fidelity oracle for the simulator's APPLY support.
+/// </summary>
+internal class Author
+{
+    public int Id { get; set; }
+
+    [Column(TypeName = "nvarchar(50)")]
+    public string Name { get; set; } = "";
+
+    public List<Book> Books { get; set; } = [];
+}
+
+internal class Book
+{
+    public int Id { get; set; }
+
+    public int AuthorId { get; set; }
+
+    [Column(TypeName = "nvarchar(50)")]
+    public string Title { get; set; } = "";
+
+    public int Score { get; set; }
+}
+
 internal class TestDbContext(Simulation simulation) : DbContext
 {
     public Simulation Simulation { get; set; } = simulation;
@@ -351,6 +379,10 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
 
     public DbSet<CustomerOrder> CustomerOrders => Set<CustomerOrder>();
 
+    public DbSet<Author> Authors => Set<Author>();
+
+    public DbSet<Book> Books => Set<Book>();
+
     public static Simulation CreateDefaultSimulation(params ReadOnlySpan<int> values)
     {
         var simulation = new Simulation();
@@ -523,6 +555,27 @@ Status nvarchar(20) null
         return simulation;
     }
 
+    public static Simulation CreateAuthorsSimulation()
+    {
+        var simulation = new Simulation();
+        _ = simulation
+            .CreateOpenConnection()
+            .CreateCommand("""
+                create table Authors (
+                    Id int identity(1, 1) not null primary key,
+                    Name nvarchar(50) not null
+                );
+                create table Books (
+                    Id int identity(1, 1) not null primary key,
+                    AuthorId int not null,
+                    Title nvarchar(50) not null,
+                    Score int not null
+                )
+                """)
+            .ExecuteNonQuery();
+        return simulation;
+    }
+
     public static Simulation CreateCustomersSimulation()
     {
         var simulation = new Simulation();

SqlServerSimulator.Tests/ApplyTests.cs

@@ -0,0 +1,190 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Behavioral tests for <c>CROSS APPLY</c> and <c>OUTER APPLY</c>: the right
+/// side is a correlated derived table re-executed per left-side row, with
+/// the outer row's columns visible inside the inner SELECT's WHERE /
+/// projection. CROSS APPLY drops outer rows whose lateral plan yields zero
+/// rows; OUTER APPLY null-fills the right side. The shape EF Core 10 emits
+/// for <c>SelectMany</c> over a filtered correlated child collection.
+/// </summary>
+[TestClass]
+public sealed class ApplyTests
+{
+    private static DbConnection SeededBlogsPosts()
+    {
+        var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table blogs (id int, title varchar(20))").ExecuteNonQuery();
+        _ = connection.CreateCommand("create table posts (id int, blog_id int, title varchar(20), score int)").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert into blogs values (1, 'A'), (2, 'B'), (3, 'C')").ExecuteNonQuery();
+        // Blog 1: 3 posts. Blog 2: 1 low-score post. Blog 3: no posts.
+        _ = connection.CreateCommand(
+            "insert into posts values " +
+            "(1, 1, 'P1', 10), (2, 1, 'P2', 20), (3, 1, 'P3', 30), " +
+            "(4, 2, 'P4', 5)").ExecuteNonQuery();
+        return connection;
+    }
+
+    // === CROSS APPLY ===
+
+    [TestMethod]
+    public void CrossApply_FilteredChild_EmitsMatchingPairs()
+    {
+        // The shape EF Core 10 emits for SelectMany of a filtered nav.
+        using var connection = SeededBlogsPosts();
+        using var reader = connection.CreateCommand(
+            "select p0.bt, p0.pt from blogs as b " +
+            "cross apply (select b.title as bt, p.title as pt from posts as p " +
+            "             where b.id = p.blog_id and p.score > 10) as p0").ExecuteReader();
+        var rows = new List<(string, string)>();
+        while (reader.Read())
+            rows.Add((reader.GetString(0), reader.GetString(1)));
+        CollectionAssert.AreEquivalent(new[] { ("A", "P2"), ("A", "P3") }, rows);
+    }
+
+    [TestMethod]
+    public void CrossApply_ZeroMatches_DropsOuterRow()
+    {
+        // Blog 3 has no posts; CROSS APPLY drops it (INNER-style).
+        using var connection = SeededBlogsPosts();
+        var ids = new List<int>();
+        using var reader = connection.CreateCommand(
+            "select b.id from blogs as b " +
+            "cross apply (select 1 as marker from posts as p where p.blog_id = b.id) as p0").ExecuteReader();
+        while (reader.Read()) ids.Add(reader.GetInt32(0));
+        CollectionAssert.AreEquivalent(new[] { 1, 1, 1, 2 }, ids);
+    }
+
+    [TestMethod]
+    public void CrossApply_ExpressionOverOuterColumn()
+    {
+        // Probe #9 shape: lateral WHERE references outer column in arithmetic.
+        using var connection = SeededBlogsPosts();
+        var rows = new List<(string, int)>();
+        using var reader = connection.CreateCommand(
+            "select b.title, p0.score from blogs as b " +
+            "cross apply (select p.score from posts as p " +
+            "             where b.id = p.blog_id and p.score >= b.id * 5) as p0").ExecuteReader();
+        while (reader.Read())
+            rows.Add((reader.GetString(0), reader.GetInt32(1)));
+        // Blog 1 (id=1, threshold=5): 10, 20, 30. Blog 2 (id=2, threshold=10): 5 fails.
+        CollectionAssert.AreEquivalent(new[] { ("A", 10), ("A", 20), ("A", 30) }, rows);
+    }
+
+    [TestMethod]
+    public void CrossApply_TopN_PerOuterRow()
+    {
+        // Top-2 posts by score per blog.
+        using var connection = SeededBlogsPosts();
+        var rows = new List<(int, string)>();
+        using var reader = connection.CreateCommand(
+            "select b.id, p0.title from blogs as b " +
+            "cross apply (select top(2) p.title, p.score from posts as p " +
+            "             where p.blog_id = b.id order by p.score desc) as p0").ExecuteReader();
+        while (reader.Read())
+            rows.Add((reader.GetInt32(0), reader.GetString(1)));
+        CollectionAssert.AreEquivalent(new[] { (1, "P3"), (1, "P2"), (2, "P4") }, rows);
+    }
+
+    [TestMethod]
+    public void CrossApply_NoOnPredicateAccepted()
+    {
+        // APPLY explicitly forbids ON; the inner WHERE provides correlation.
+        // This test just confirms that APPLY without ON parses and runs.
+        using var connection = SeededBlogsPosts();
+        using var reader = connection.CreateCommand(
+            "select b.id, p0.score from blogs as b " +
+            "cross apply (select p.score from posts as p where p.blog_id = b.id) as p0 " +
+            "order by b.id, p0.score").ExecuteReader();
+        var rows = new List<(int, int)>();
+        while (reader.Read()) rows.Add((reader.GetInt32(0), reader.GetInt32(1)));
+        CollectionAssert.AreEqual(new[] { (1, 10), (1, 20), (1, 30), (2, 5) }, rows);
+    }
+
+    // === OUTER APPLY ===
+
+    [TestMethod]
+    public void OuterApply_ZeroMatches_NullFillsRight()
+    {
+        // Blog 3 has no posts; OUTER APPLY emits one NULL row for it.
+        using var connection = SeededBlogsPosts();
+        var rows = new List<(int Id, int? Score)>();
+        using var reader = connection.CreateCommand(
+            "select b.id, p0.score from blogs as b " +
+            "outer apply (select p.score from posts as p where p.blog_id = b.id) as p0 " +
+            "order by b.id, p0.score").ExecuteReader();
+        while (reader.Read())
+            rows.Add((reader.GetInt32(0), reader.IsDBNull(1) ? null : reader.GetInt32(1)));
+        var expected = new List<(int Id, int? Score)> { (1, 10), (1, 20), (1, 30), (2, 5), (3, null) };
+        CollectionAssert.AreEqual(expected, rows);
+    }
+
+    [TestMethod]
+    public void OuterApply_AllOuterRowsAppearAtLeastOnce()
+    {
+        using var connection = SeededBlogsPosts();
+        var ids = new HashSet<int>();
+        using var reader = connection.CreateCommand(
+            "select b.id from blogs as b " +
+            "outer apply (select p.id from posts as p where p.blog_id = b.id and p.score > 999) as p0").ExecuteReader();
+        while (reader.Read()) _ = ids.Add(reader.GetInt32(0));
+        CollectionAssert.AreEquivalent(new[] { 1, 2, 3 }, ids.ToArray());
+    }
+
+    // === Chained APPLY ===
+
+    [TestMethod]
+    public void CrossApply_MultipleChained_CorrelateLeftToRight()
+    {
+        // Two APPLYs in a row: the second references both b and p0.
+        // Blog 1 (scores 10, 20, 30): p0=10 → p1∈{10,20,30}; p0=20 → p1∈{20,30}; p0=30 → p1∈{30}.
+        // Blog 2 (score 5): p0=5 → p1∈{5}. Blog 3 has no posts → no rows.
+        using var connection = SeededBlogsPosts();
+        var triples = new List<(int, int, int)>();
+        using var reader = connection.CreateCommand(
+            "select b.id, p0.score, p1.score from blogs as b " +
+            "cross apply (select p.score from posts as p where p.blog_id = b.id) as p0 " +
+            "cross apply (select q.score from posts as q where q.blog_id = b.id and q.score >= p0.score) as p1").ExecuteReader();
+        while (reader.Read())
+            triples.Add((reader.GetInt32(0), reader.GetInt32(1), reader.GetInt32(2)));
+        CollectionAssert.AreEquivalent(
+            new[] { (1, 10, 10), (1, 10, 20), (1, 10, 30), (1, 20, 20), (1, 20, 30), (1, 30, 30), (2, 5, 5) },
+            triples);
+    }
+
+    // === Parser rejections ===
+
+    [TestMethod]
+    public void Apply_RejectsOnClause()
+    {
+        // CROSS APPLY ... ON ... is not valid syntax (no ON for APPLY).
+        using var connection = SeededBlogsPosts();
+        _ = Throws<DbException>(() =>
+            _ = connection.CreateCommand(
+                "select 1 from blogs as b " +
+                "cross apply (select 1 from posts as p where p.blog_id = b.id) as p0 " +
+                "on b.id = p0.id").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void Apply_RequiresParenthesizedSelect()
+    {
+        using var connection = SeededBlogsPosts();
+        _ = Throws<DbException>(() =>
+            _ = connection.CreateCommand(
+                "select 1 from blogs as b cross apply posts as p").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void OuterApply_AsLeadingKeyword_RequiresApply()
+    {
+        // OUTER alone (without LEFT/RIGHT/FULL preceding) only forms OUTER APPLY.
+        using var connection = SeededBlogsPosts();
+        _ = Throws<DbException>(() =>
+            _ = connection.CreateCommand(
+                "select 1 from blogs as b outer join posts as p on b.id = p.blog_id").ExecuteScalar());
+    }
+}

SqlServerSimulator/Parser/ContextualKeyword.cs

@@ -20,6 +20,7 @@ namespace SqlServerSimulator.Parser;
 enum ContextualKeyword
 {
     _ = 0, // Default — current token isn't a contextual keyword.
+    Apply,
     Compatibility_Level,
     Configuration,
     First,