RIGHT [OUTER] JOIN and FULL [OUTER] JOIN against base / view / system-table right sides (parser cases for both keyword spellings; lateral / derived-table right raises NotSupportedException since real SQL Server's Msg 4104 rejection of correlated-right can't be statically distinguished from non-correlated). JoinDriver refactored from level-recursive to an operator-pipeline fold over joins[]: INNER/CROSS/LEFT/CROSS-APPLY/OUTER-APPLY stream, RIGHT/FULL materialize right rows + track a matched bitmap across the upstream iteration, then emit unmatched-right rows with NULL-filled left slots after upstream exhausts. EF Core 10 LINQ LeftJoin/RightJoin operators covered end-to-end; FullJoin has no .NET 10 LINQ counterpart so FULL OUTER stays raw-SQL-only.

Author: RyanLamansky

CLAUDE.md

@@ -46,7 +46,7 @@ Layout: `Storage/` (pages, types, row encoder/decoder, heap, constraints), `Pars
 `Selection.cs` + `Selection.Execution.cs` are a partial-class pair. `Parse → Selection`, `Execute → SimulatedSqlResultSet`. Correlated subqueries re-run the same plan per outer row via `outerResolver: Func<MultiPartName, SqlValue>?` (execute) and `outerTypeResolver: Func<MultiPartName, SqlType>?` (parse). Both walk arbitrary nesting depth via `ParserContext.OuterTypeResolver` + the runtime arg. **Derived tables in FROM are always deferred** (`FromSource.LateralPlan` is re-executed per outer row), matching SQL Server's "any FROM derived table can correlate" rule — required because outer references in WHERE/ON resolve through `Run`, not `GetSqlType`.
 
 ### Multi-source rows
-`FromSource[]`; rows during enumeration are `byte[]?[]`, one slot per source, null = unmatched LEFT JOIN right side. Column resolution is qualifier-aware via `FindSourceColumn` / `ResolveAcrossTuple`; ambiguous unqualified name → Msg 209.
+`FromSource[]`; rows during enumeration are `byte[]?[]`, one slot per source, null = NULL-filled outer-join side (LEFT/RIGHT/FULL/OUTER APPLY). Column resolution is qualifier-aware via `FindSourceColumn` / `ResolveAcrossTuple`; ambiguous unqualified name → Msg 209.
 
 ### `MultiPartName`
 Readonly struct, up to 4 inline slots (SQL Server's grammar limit). API: `Leaf`, `ImmediateQualifier` (null when unqualified — pair with `Collation.Default.Equals(name.ImmediateQualifier, "INSERTED")`, the equality folds null into `false`), `Count`, `ToString()`. 5th segment → Msg 4104.
@@ -95,7 +95,9 @@ Five scopes, one home each. **Add new state to whichever class matches its true
 The `*.Tests` and `*.Tests.EFCore` suites are the authoritative behavior contract. Notes below cover only probe-confirmed quirks, deviations from SQL Server, and non-obvious implementation rules. Per-feature deep-dives live under `docs/claude/` (see [Feature reference](#feature-reference) for the trigger-phrased index); short cross-cutting sections stay inline below.
 
 ### JOINs / APPLY
-INNER / bare JOIN / LEFT [OUTER] / CROSS / CROSS APPLY / OUTER APPLY. Multi-table chains compose left-to-right. ON-predicate UNKNOWN excludes. APPLY = lateral form (right side re-executed per outer row, no ON clause).
+INNER / bare JOIN / LEFT [OUTER] / RIGHT [OUTER] / FULL [OUTER] / CROSS / CROSS APPLY / OUTER APPLY. Multi-table chains compose left-to-right. ON-predicate UNKNOWN excludes. APPLY = lateral form (right side re-executed per outer row, no ON clause).
+
+`JoinDriver` is a fold over `joins[]`: leftmost rowset → wrap with each join's operator → final enumerator (`Selection.Execution.Joins.cs`). INNER / CROSS / LEFT / CROSS APPLY / OUTER APPLY stream one upstream tuple at a time; RIGHT / FULL materialize `sources[level].Rows` into a list and track a `matched[]` bitmap across the entire upstream iteration so unmatched right rows can be emitted (with all prior slots NULL-filled) after upstream is exhausted. **RIGHT / FULL with a derived-table or lateral right side raise `NotSupportedException`** — every derived table is deferred regardless of actual correlation, and real SQL Server rejects correlated subqueries on the right of RIGHT/FULL with Msg 4104. EF Core 10's LINQ `LeftJoin` / `RightJoin` operators translate to LEFT / RIGHT JOIN respectively and route through this pipeline; .NET 10 LINQ doesn't expose a `FullJoin` operator, so FULL OUTER JOIN is reachable only via raw SQL.
 
 ### Subqueries
 `EXISTS` / `NOT EXISTS` (multi-column inner allowed); `expr [NOT] IN (SELECT ...)` (single inner column, Msg 116); scalar `(SELECT col FROM ...)` (single column, single-row Msg 512 per outer row, empty → typed NULL). All forms work correlated and non-correlated, arbitrary nesting depth.
@@ -151,7 +153,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 ## Not modeled
 
 - Locks / MVCC / isolation levels (single-Simulation, single-thread-at-a-time). `BEGIN DISTRIBUTED TRANSACTION`, `BEGIN TRANSACTION ... WITH MARK`, `XACT_ABORT`, `SET TRANSACTION ISOLATION LEVEL` not parsed.
-- `RIGHT JOIN` (rewrite as LEFT with sources swapped) and `FULL OUTER JOIN` — both raise `NotSupportedException` at parse.
+- `RIGHT JOIN` / `FULL OUTER JOIN` with a derived-table or lateral right side — base tables / views / system tables on the right ship (see JOINs / APPLY); a derived-table right (always-deferred in this simulator) raises `NotSupportedException` since real SQL Server's Msg 4104 rejection of correlated subqueries on the right of RIGHT/FULL can't be statically distinguished from non-correlated ones.
 - Comma-separated FROM (legacy ANSI-89 join syntax).
 - `ANY` / `SOME` / `ALL` quantifiers.
 - `UNION` / `UNION ALL` inside a subquery body.

SqlServerSimulator.Tests.EFCore/EFCoreJoin.cs

@@ -2,10 +2,15 @@ namespace SqlServerSimulator;
 
 /// <summary>
 /// End-to-end tests for the JOIN shapes EF Core's SqlServer provider
-/// emits — explicit LINQ <c>Join</c> (translates to <c>INNER JOIN</c>)
-/// and the navigation / projection patterns that translate to
-/// <c>LEFT JOIN</c>. Validates that the simulator's multi-source row
-/// pipeline matches EF Core's expectations end-to-end.
+/// emits — explicit LINQ <c>Join</c> (translates to <c>INNER JOIN</c>),
+/// the navigation / projection patterns that translate to <c>LEFT JOIN</c>,
+/// and the .NET 10 / EF Core 10 <c>LeftJoin</c> / <c>RightJoin</c> LINQ
+/// operators that translate to <c>LEFT JOIN</c> / <c>RIGHT JOIN</c>.
+/// Validates that the simulator's multi-source row pipeline matches EF
+/// Core's expectations end-to-end. <c>FULL OUTER JOIN</c> isn't covered
+/// here because .NET 10 LINQ doesn't expose a <c>FullJoin</c> operator
+/// (the only way to reach it is raw SQL, which belongs in the parser
+/// tests, not <c>*.Tests.EFCore</c>).
 /// </summary>
 [TestClass]
 public class EFCoreJoin
@@ -47,6 +52,50 @@ public void Join_ExplicitInnerJoin_PairsMatching()
         Assert.AreEqual("beta", pairs[2].Name); Assert.AreEqual(30m, pairs[2].Amount);
     }
 
+    [TestMethod]
+    public void RightJoin_EmitsRightJoinAndIncludesUnmatchedRight()
+    {
+        // EF Core 10's RightJoin LINQ operator translates to RIGHT JOIN.
+        // Seed an orphan order (CustomerId = 99 references no Customer) so the
+        // unmatched-right path emits with a NULL customer name.
+        using var context = SeededContext();
+        _ = context.CustomerOrders.Add(new CustomerOrder { CustomerId = 99, Amount = 99m });
+        _ = context.SaveChanges();
+
+        var pairs = context.Customers
+            .RightJoin(context.CustomerOrders,
+                c => c.Id,
+                o => o.CustomerId,
+                (c, o) => new { CustomerName = c == null ? null : c.Name, o.Amount })
+            .OrderBy(x => x.Amount)
+            .ToArray();
+        Assert.HasCount(4, pairs);
+        Assert.AreEqual("alpha", pairs[0].CustomerName); Assert.AreEqual(10m, pairs[0].Amount);
+        Assert.AreEqual("alpha", pairs[1].CustomerName); Assert.AreEqual(20m, pairs[1].Amount);
+        Assert.AreEqual("beta", pairs[2].CustomerName); Assert.AreEqual(30m, pairs[2].Amount);
+        Assert.IsNull(pairs[3].CustomerName); Assert.AreEqual(99m, pairs[3].Amount);
+    }
+
+    [TestMethod]
+    public void LeftJoin_EmitsLeftJoinAndIncludesUnmatchedLeft()
+    {
+        // EF Core 10's LeftJoin LINQ operator translates to LEFT JOIN. The
+        // GroupJoin/DefaultIfEmpty pattern below covers the same shape; this
+        // exercises the explicit operator path through the join pipeline.
+        using var context = SeededContext();
+        var pairs = context.Customers
+            .LeftJoin(context.CustomerOrders,
+                c => c.Id,
+                o => o.CustomerId,
+                (c, o) => new { c.Name, Amount = o == null ? (decimal?)null : o.Amount })
+            .OrderBy(x => x.Name).ThenBy(x => x.Amount)
+            .ToArray();
+        // gamma has no orders → null Amount.
+        Assert.HasCount(4, pairs);
+        Assert.AreEqual("gamma", pairs[3].Name);
+        Assert.IsNull(pairs[3].Amount);
+    }
+
     [TestMethod]
     public void GroupJoin_DefaultIfEmpty_EmitsLeftJoin()
     {

SqlServerSimulator.Tests/JoinTests.cs

@@ -5,9 +5,9 @@ namespace SqlServerSimulator;
 
 /// <summary>
 /// Behavioral tests for SQL Server's JOIN forms: INNER / bare JOIN / LEFT [OUTER] /
-/// CROSS, multi-table chains, self-joins via alias. Shared rules: qualifier-aware
-/// resolution (Msg 209 on ambiguity), ON-predicate 3VL semantics, parser rejections.
-/// RIGHT JOIN intentionally not modeled.
+/// RIGHT [OUTER] / FULL [OUTER] / CROSS, multi-table chains, self-joins via alias.
+/// Shared rules: qualifier-aware resolution (Msg 209 on ambiguity), ON-predicate 3VL
+/// semantics, parser rejections. RIGHT / FULL reject a derived-table right side.
 /// </summary>
 [TestClass]
 public sealed class JoinTests
@@ -29,7 +29,10 @@ insert b values (10, 1, 100), (11, 1, 200), (12, 2, 300)
         using var reader = command.ExecuteReader();
         var rows = new List<(int, int)>();
         while (reader.Read())
-            rows.Add((reader.GetInt32(0), reader.IsDBNull(1) ? -1 : reader.GetInt32(1)));
+        {
+            rows.Add((reader.IsDBNull(0) ? -1 : reader.GetInt32(0),
+                      reader.IsDBNull(1) ? -1 : reader.GetInt32(1)));
+        }
         return rows;
     }
 
@@ -184,11 +187,173 @@ insert y values (1), (null)
         CollectionAssert.AreEqual(new[] { (1, 1) }, rows);
     }
 
+    /// <summary>
+    /// Seed asymmetric x/y tables where left has an unmatched row (x=3 → no y) and
+    /// right has an unmatched row (y=4 → no x). Shared by all RIGHT / FULL tests so the
+    /// asymmetric paths actually exercise the unmatched-side NULL fill.
+    /// </summary>
+    private static DbConnection SeededXY()
+    {
+        var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("""
+            create table x (id int);
+            create table y (x_id int);
+            insert x values (1), (2), (3);
+            insert y values (1), (2), (4)
+            """).ExecuteNonQuery();
+        return connection;
+    }
+
+    [TestMethod]
+    public void RightJoin_BasicMatchAndOrphanRight()
+    {
+        using var connection = SeededXY();
+        var rows = ReadIntPairs(connection.CreateCommand("select x.id, y.x_id from x right join y on x.id = y.x_id"));
+        CollectionAssert.AreEquivalent(new[] { (1, 1), (2, 2), (-1, 4) }, rows);
+    }
+
+    [TestMethod]
+    public void RightOuterJoin_KeywordSpelling_Equivalent()
+    {
+        using var connection = SeededXY();
+        var rows = ReadIntPairs(connection.CreateCommand("select x.id, y.x_id from x right outer join y on x.id = y.x_id"));
+        CollectionAssert.AreEquivalent(new[] { (1, 1), (2, 2), (-1, 4) }, rows);
+    }
+
+    [TestMethod]
+    public void FullJoin_EmitsBothUnmatchedSides()
+    {
+        using var connection = SeededXY();
+        var rows = ReadIntPairs(connection.CreateCommand("select x.id, y.x_id from x full join y on x.id = y.x_id"));
+        CollectionAssert.AreEquivalent(new[] { (1, 1), (2, 2), (3, -1), (-1, 4) }, rows);
+    }
+
+    [TestMethod]
+    public void FullOuterJoin_KeywordSpelling_Equivalent()
+    {
+        using var connection = SeededXY();
+        var rows = ReadIntPairs(connection.CreateCommand("select x.id, y.x_id from x full outer join y on x.id = y.x_id"));
+        CollectionAssert.AreEquivalent(new[] { (1, 1), (2, 2), (3, -1), (-1, 4) }, rows);
+    }
+
+    [TestMethod]
+    public void RightJoin_NullKey_DoesNotMatch()
+    {
+        var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("""
+            create table a (id int);
+            create table b (a_id int);
+            insert a values (1), (null);
+            insert b values (1), (null)
+            """).ExecuteNonQuery();
+
+        // ON uses three-valued equality: NULL = NULL is UNKNOWN, so the NULL rows
+        // never match and both pair as their respective outer-side row.
+        var rows = ReadIntPairs(connection.CreateCommand("select a.id, b.a_id from a right join b on a.id = b.a_id"));
+        CollectionAssert.AreEquivalent(new[] { (1, 1), (-1, -1) }, rows);
+    }
+
+    [TestMethod]
+    public void RightJoin_NoLeftRows_AllRightEmittedNullLeft()
+    {
+        var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("""
+            create table a (id int);
+            create table b (id int);
+            insert b values (10), (20)
+            """).ExecuteNonQuery();
+
+        var rows = ReadIntPairs(connection.CreateCommand("select a.id, b.id from a right join b on a.id = b.id"));
+        CollectionAssert.AreEquivalent(new[] { (-1, 10), (-1, 20) }, rows);
+    }
+
+    [TestMethod]
+    public void RightJoin_NoRightRows_EmitsNothing()
+    {
+        var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("""
+            create table a (id int);
+            create table b (id int);
+            insert a values (1), (2)
+            """).ExecuteNonQuery();
+
+        using var reader = connection.CreateCommand("select a.id, b.id from a right join b on a.id = b.id").ExecuteReader();
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void RightJoin_ChainedAfterInnerJoin()
+    {
+        // Three-table chain: (x INNER JOIN z) RIGHT JOIN y. The RIGHT JOIN's
+        // left side is the materialized (x,z) rowset; unmatched y rows emit
+        // with both x and z slots NULL-filled.
+        var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("""
+            create table x (id int);
+            create table y (x_id int);
+            create table z (id int);
+            insert x values (1), (2);
+            insert y values (1), (2), (4);
+            insert z values (1), (2)
+            """).ExecuteNonQuery();
+
+        var rows = new List<(int, int, int)>();
+        using var reader = connection.CreateCommand(
+            "select x.id, z.id, y.x_id from x inner join z on x.id = z.id right join y on x.id = y.x_id").ExecuteReader();
+        while (reader.Read())
+        {
+            rows.Add((reader.IsDBNull(0) ? -1 : reader.GetInt32(0),
+                      reader.IsDBNull(1) ? -1 : reader.GetInt32(1),
+                      reader.GetInt32(2)));
+        }
+        CollectionAssert.AreEquivalent(new[] { (1, 1, 1), (2, 2, 2), (-1, -1, 4) }, rows);
+    }
+
+    [TestMethod]
+    public void FullJoin_ChainedAfterLeftJoin()
+    {
+        // (a LEFT JOIN b) FULL JOIN c: tests that left-side NULL slots from
+        // the upstream LEFT JOIN don't poison the FULL JOIN's matched-bitmap
+        // tracking, and that FULL's unmatched-right phase clears all prior slots.
+        var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("""
+            create table a (id int);
+            create table b (a_id int);
+            create table c (id int);
+            insert a values (1), (2);
+            insert b values (1);
+            insert c values (1), (3)
+            """).ExecuteNonQuery();
+
+        var rows = new List<(int, int, int)>();
+        using var reader = connection.CreateCommand(
+            "select a.id, b.a_id, c.id from a left join b on a.id = b.a_id full join c on a.id = c.id").ExecuteReader();
+        while (reader.Read())
+        {
+            rows.Add((reader.IsDBNull(0) ? -1 : reader.GetInt32(0),
+                      reader.IsDBNull(1) ? -1 : reader.GetInt32(1),
+                      reader.IsDBNull(2) ? -1 : reader.GetInt32(2)));
+        }
+        // a=1 LEFT b → (1,1); a=2 LEFT b → (2,NULL). FULL c on a.id=c.id:
+        //   (1,1) matches c=1 → (1,1,1);
+        //   (2,NULL) no c match → (2,NULL,NULL);
+        //   c=3 unmatched → (NULL,NULL,3).
+        CollectionAssert.AreEquivalent(new[] { (1, 1, 1), (2, -1, -1), (-1, -1, 3) }, rows);
+    }
+
+    [TestMethod]
+    public void RightJoin_DerivedTableRightSide_NotSupported()
+        => _ = Throws<NotSupportedException>(() => _ = new Simulation().ExecuteScalar("""
+            create table a (id int);
+            create table b (id int);
+            select 1 from a right join (select id from b) bx on a.id = bx.id
+            """));
+
     [TestMethod]
-    public void RightJoin_NotSupported()
+    public void FullJoin_DerivedTableRightSide_NotSupported()
         => _ = Throws<NotSupportedException>(() => _ = new Simulation().ExecuteScalar("""
             create table a (id int);
             create table b (id int);
-            select 1 from a right join b on a.id = b.id
+            select 1 from a full join (select id from b) bx on a.id = bx.id
             """));
 }

SqlServerSimulator/Parser/FromSource.cs

@@ -95,16 +95,34 @@ internal enum SetOpKind
 /// <summary>
 /// The variants of JOIN the simulator parses. <c>Inner</c> includes the
 /// bare <c>JOIN</c> keyword (which SQL Server treats as INNER) and the
-/// explicit <c>INNER JOIN</c>. <c>Left</c> covers <c>LEFT [OUTER] JOIN</c>.
-/// <c>Cross</c> is the unconditional Cartesian product (and rejects ON).
-/// <c>RIGHT JOIN</c> and <c>FULL OUTER JOIN</c> aren't modeled — the
-/// parser raises <see cref="NotSupportedException"/>; rewrite RIGHT as
-/// LEFT with sources reversed.
+/// explicit <c>INNER JOIN</c>. <c>Left</c> covers <c>LEFT [OUTER] JOIN</c>,
+/// <c>Right</c> covers <c>RIGHT [OUTER] JOIN</c>, <c>Full</c> covers
+/// <c>FULL [OUTER] JOIN</c>. <c>Cross</c> is the unconditional Cartesian
+/// product (and rejects ON).
 /// </summary>
 internal enum JoinKind
 {
     Inner,
     Left,
+
+    /// <summary>
+    /// <c>RIGHT [OUTER] JOIN</c>: right rows missing a left match emit
+    /// with the left side null-filled; left rows missing a right match
+    /// are dropped. Executed by materializing the right source and
+    /// tracking a matched bitmap across the entire left iteration —
+    /// requires a non-lateral right side (probe-confirmed: real SQL
+    /// Server rejects correlated derived tables on the right of
+    /// RIGHT / FULL with Msg 4104).
+    /// </summary>
+    Right,
+
+    /// <summary>
+    /// <c>FULL [OUTER] JOIN</c>: matched pairs emit normally; unmatched
+    /// left rows emit with the right side null-filled; unmatched right
+    /// rows emit with the left side null-filled. Same lateral-right
+    /// restriction as <see cref="Right"/>.
+    /// </summary>
+    Full,
     Cross,
 
     /// <summary>