Rewrite comma-join / CROSS JOIN carrying a WHERE equi-predicate into an INNER JOIN at parse time, so FROM a, b WHERE a.k = b.k rides the equi-join seek/hash path instead of the O(L×R) nested loop.

Author: RyanLamansky

CLAUDE.md

@@ -137,7 +137,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **`SqlType.Promote` / `PromoteForArithmetic` / decimal precision-scale / int↔string promotion** → [`arithmetic.md`](docs/claude/arithmetic.md).
 - **`Cast` / coercion error paths** (CAST/CONVERT narrow targets, TRY_CAST/TRY_CONVERT swallow set, PARSE/TRY_PARSE culture-aware parsing) → [`casting.md`](docs/claude/casting.md).
 - **`Selection`, aggregates, window functions, set ops, CASE, OFFSET/FETCH** → [`query.md`](docs/claude/query.md).
-- **JOIN / APPLY** — INNER / LEFT / RIGHT / FULL / CROSS + CROSS/OUTER APPLY, ANSI-89 comma-FROM, EF `LeftJoin`/`RightJoin` routing (no LINQ `FullJoin`, so FULL is raw-SQL-only); `JoinDriver` equi-join hash fast path + `SqlValueKey` keying, nested-loop fallback, RIGHT/FULL materialization + derived-table-right, `JoinDiagnostics` strategy guard → [`joins.md`](docs/claude/joins.md).
+- **JOIN / APPLY** — INNER / LEFT / RIGHT / FULL / CROSS + CROSS/OUTER APPLY, ANSI-89 comma-FROM, EF `LeftJoin`/`RightJoin` routing (no LINQ `FullJoin`, so FULL is raw-SQL-only); `JoinDriver` equi-join hash fast path + `SqlValueKey` keying, nested-loop fallback, parse-time comma/`CROSS JOIN`+WHERE → equi-`INNER` rewrite, RIGHT/FULL materialization + derived-table-right, `JoinDiagnostics` strategy guard → [`joins.md`](docs/claude/joins.md).
 - **`PIVOT` / `UNPIVOT`** table operators — PIVOT desugars to grouped conditional aggregation (implicit grouping = all inner columns except FOR + aggregate-arg), UNPIVOT is a NULL-skipping unfold; both attach as a postfix FROM-source wrapper and ride the derived-table `LateralPlan` seam → [`pivot.md`](docs/claude/pivot.md).
 - **UPDATE / DELETE / INSERT…SELECT / SELECT…INTO / rowversion (incl. `@@DBTS` / `MIN_ACTIVE_ROWVERSION`) / identity helpers (`@@IDENTITY` / `SCOPE_IDENTITY` / `IDENT_CURRENT` / `IDENT_INCR` / `IDENT_SEED`) / `@@ROWCOUNT` / `ROWCOUNT_BIG` / OUTPUT / MERGE** → [`dml.md`](docs/claude/dml.md).
 - **Variables, control flow (IF/WHILE/BREAK/CONTINUE/RETURN), TRY/CATCH+THROW+ERROR_*, `@@ERROR` / `@@TRANCOUNT` / `XACT_STATE`, PRINT, WAITFOR** → [`control-flow.md`](docs/claude/control-flow.md).

SqlServerSimulator.Tests.Internal/JoinStrategyTests.cs

@@ -86,6 +86,55 @@ public void CrossJoin_UsesNestedLoops()
         => Contains("Cross:NestedLoops",
             CaptureStrategies("select a.id from a cross join b"));
 
+    /// <summary>
+    /// ANSI-89 comma join with an equi-predicate in WHERE: the parser rewrites
+    /// `FROM a, b WHERE a.id = b.a_id` into `a INNER JOIN b ON a.id = b.a_id`,
+    /// so it hashes instead of nested-looping the cross product.
+    /// </summary>
+    [TestMethod]
+    public void CommaJoin_WithEquiPredicate_TakesHashPath()
+        => Contains("Inner:HashMatch(keys=1,residual=0)",
+            CaptureStrategies("select a.id from a, b where a.id = b.a_id"));
+
+    /// <summary>
+    /// Explicit CROSS JOIN carrying an equi-predicate in WHERE is the same shape
+    /// post-parse (JoinKind.Cross, null ON) and rewrites identically.
+    /// </summary>
+    [TestMethod]
+    public void ExplicitCrossJoin_WithEquiPredicate_TakesHashPath()
+        => Contains("Inner:HashMatch(keys=1,residual=0)",
+            CaptureStrategies("select a.id from a cross join b where a.id = b.a_id"));
+
+    /// <summary>
+    /// A non-equi WHERE term alongside the equi-key isn't pulled into the
+    /// synthesized ON (only equi-keys are) — it stays a post-join WHERE filter,
+    /// so the join's residual count is 0, not 1.
+    /// </summary>
+    [TestMethod]
+    public void CommaJoin_NonEquiTermStaysInWhere_NotPulledToOn()
+        => Contains("Inner:HashMatch(keys=1,residual=0)",
+            CaptureStrategies("select a.id from a, b where a.id = b.a_id and b.id > 10"));
+
+    /// <summary>
+    /// No equi-key connects the two comma sources, so there's nothing to pull
+    /// into an ON — the join stays a Cross nested loop (the cross product is
+    /// genuinely required).
+    /// </summary>
+    [TestMethod]
+    public void CommaJoin_NoEquiPredicate_StaysNestedLoops()
+        => Contains("Cross:NestedLoops",
+            CaptureStrategies("select a.id from a, b where a.id <> b.a_id"));
+
+    /// <summary>
+    /// Comma join + WHERE filter on the small outer: after the Cross→Inner
+    /// rewrite the leftmost is seeked to one row and the indexed inner is seeked
+    /// per outer row — same acceleration the explicit-JOIN form already got.
+    /// </summary>
+    [TestMethod]
+    public void CommaJoin_SmallOuter_IndexedInner_SeeksPerOuter()
+        => Contains("Inner:NestedLoopIndexSeek(keys=1)",
+            CaptureStrategies(IndexedSetup, "select p.label, c.amt from p, c where c.pid = p.id and p.id = 5"));
+
     /// <summary>
     /// WHERE p.id = 5 pushes down to seek the leftmost to one row, then the
     /// inner (indexed on pid) is seeked per outer row instead of hash-built.

SqlServerSimulator.Tests/JoinTests.cs

@@ -491,6 +491,72 @@ insert c values (1, 'c1'), (3, 'c3'), (5, 'c5')
         CollectionAssert.AreEquivalent(new[] { ("a1", "b1", "c1") }, rows);
     }
 
+    // A NULL join key never matches under `=` (NULL = x is UNKNOWN), so the
+    // comma-join's Cross→Inner rewrite must drop those rows — exactly as the
+    // pre-rewrite cross-product-then-WHERE did. b row (13, NULL) and a rows
+    // with no matching b are absent.
+    [TestMethod]
+    public void CommaFrom_NullJoinKey_ExcludedAfterRewrite()
+    {
+        using var connection = SeededAB();
+        _ = connection.CreateCommand("insert b values (13, null, 400)").ExecuteNonQuery();
+        var rows = ReadIntPairs(connection.CreateCommand("select a.id, b.val from a, b where a.id = b.a_id"));
+        CollectionAssert.AreEquivalent(new[] { (1, 100), (1, 200), (2, 300) }, rows);
+    }
+
+    // The comma source's equi-predicate references the NULL-extended side of a
+    // preceding LEFT JOIN. A null-extended b.id makes `b.id = c.id` UNKNOWN, so
+    // those rows drop — identical whether the predicate filters post-cross
+    // (pre-rewrite) or anchors the synthesized INNER JOIN ON (post-rewrite),
+    // because the predicate stays in WHERE as the residual.
+    [TestMethod]
+    public void CommaFrom_AfterLeftJoin_NullExtendedKeyDropsRow()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table a (id int, av varchar(10));
+            create table b (id int, bv varchar(10));
+            create table c (id int, cv varchar(10));
+            insert a values (1, 'a1'), (2, 'a2');
+            insert b values (1, 'b1');
+            insert c values (1, 'c1'), (2, 'c2')
+            """);
+
+        using var connection = simulation.CreateOpenConnection();
+        using var reader = connection.CreateCommand(
+            "select a.av, b.bv, c.cv from a left join b on a.id = b.id, c where b.id = c.id").ExecuteReader();
+        var rows = new List<(string, string, string)>();
+        while (reader.Read())
+            rows.Add((reader.GetString(0), reader.GetString(1), reader.GetString(2)));
+        // a2's b is null-extended → b.id = c.id is UNKNOWN → only a1's row survives.
+        CollectionAssert.AreEquivalent(new[] { ("a1", "b1", "c1") }, rows);
+    }
+
+    // A comma source feeding a later LEFT JOIN must still null-extend: the
+    // rewrite only flips the Cross (a,b) level to INNER, leaving the explicit
+    // LEFT JOIN to c untouched, so an a/b pair with no c match keeps its row.
+    [TestMethod]
+    public void CommaFrom_FeedingLeftJoin_StillNullExtends()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table a (id int, av varchar(10));
+            create table b (id int, j int, bv varchar(10));
+            create table c (k int, cv varchar(10));
+            insert a values (1, 'a1'), (2, 'a2');
+            insert b values (1, 9, 'b1'), (2, 8, 'b2');
+            insert c values (9, 'c9')
+            """);
+
+        using var connection = simulation.CreateOpenConnection();
+        using var reader = connection.CreateCommand(
+            "select a.av, b.bv, c.cv from a, b left join c on b.j = c.k where a.id = b.id order by a.av").ExecuteReader();
+        var rows = new List<(string, string, string?)>();
+        while (reader.Read())
+            rows.Add((reader.GetString(0), reader.GetString(1), reader.IsDBNull(2) ? null : reader.GetString(2)));
+        CollectionAssert.AreEqual(new[] { ("a1", "b1", (string?)"c9"), ("a2", "b2", null) }, rows);
+    }
+
     [TestMethod]
     public void CommaFrom_TrailingComma_RaisesSyntaxError()
         => _ = new Simulation().AssertSqlError("""

SqlServerSimulator/Parser/BooleanExpression.cs

@@ -592,6 +592,15 @@ private static BetweenExpression ParseBetween(Expression left, ParserContext con
     /// </summary>
     internal virtual void CollectConjuncts(List<BooleanExpression> sink) => sink.Add(this);
 
+    /// <summary>
+    /// Combines two predicates with a three-valued <c>AND</c>. Used to
+    /// synthesize an <c>ON</c> predicate from the WHERE conjuncts when a
+    /// comma / <c>CROSS JOIN</c> is rewritten into an equi-join — the result
+    /// re-splits cleanly through <see cref="CollectConjuncts"/>, so the join
+    /// planner recovers the individual key equalities.
+    /// </summary>
+    internal static BooleanExpression And(BooleanExpression left, BooleanExpression right) => new AndExpression(left, right);
+
     /// <summary>
     /// Flattens a top-level <c>OR</c> chain into its individual disjunct terms,
     /// appending each to <paramref name="sink"/>. A non-<c>OR</c> predicate

SqlServerSimulator/Parser/Selection.Execution.Joins.cs

@@ -454,6 +454,66 @@ private static int SourceSide(Reference reference, FromSource[] sources, int lev
 
     private static readonly JoinSpec[] NoJoins = [];
 
+    /// <summary>
+    /// Rewrites a comma-join / explicit <c>CROSS JOIN</c> whose WHERE carries an
+    /// equi-join predicate into an <c>INNER JOIN</c> with that predicate as its
+    /// <c>ON</c>, so the equi-join hash / per-outer-seek machinery (which only
+    /// fires for INNER / LEFT / RIGHT / FULL — a <see cref="JoinKind.Cross"/>
+    /// always falls to the O(L×R) nested loop) accelerates it.
+    /// <c>FROM a, b WHERE a.k = b.k</c> is the textbook equivalent of
+    /// <c>a INNER JOIN b ON a.k = b.k</c>.
+    /// <para>
+    /// Run once at parse time (the join shape is value-independent), so the
+    /// rewritten array is captured in the cached plan. Every pulled conjunct
+    /// <b>stays</b> in <paramref name="excluders"/> as a residual filter — never
+    /// removed — so flipping a Cross level to Inner can only drop rows the WHERE
+    /// would drop anyway: the post-WHERE result is provably unchanged whatever
+    /// outer joins sit elsewhere in the chain. Only Cross levels with no existing
+    /// <c>ON</c> and a re-enumerable (non-lateral) right side are touched; a level
+    /// that already carries an <c>ON</c> is left alone. Returns the same array
+    /// when nothing rewrites — the common single-source / explicit-join case.
+    /// </para>
+    /// </summary>
+    internal static JoinSpec[] RewriteCommaJoinsToEquiJoins(
+        FromSource[] sources, JoinSpec[] joins, List<BooleanExpression> excluders)
+    {
+        if (sources.Length < 2 || excluders.Count == 0)
+            return joins;
+
+        List<BooleanExpression>? conjuncts = null;
+        JoinSpec[]? rewritten = null;
+        for (var level = 1; level < sources.Length; level++)
+        {
+            var join = joins[level - 1];
+            // Only a Cross join with no ON is a candidate; a lateral / derived
+            // right side has no re-enumerable Rows to hash or seek, so leave it
+            // on the nested-loop path.
+            if (join.Kind != JoinKind.Cross || join.OnPredicate is not null || sources[level].LateralPlan is not null)
+                continue;
+
+            if (conjuncts is null)
+            {
+                conjuncts = [];
+                foreach (var excluder in excluders)
+                    excluder.CollectConjuncts(conjuncts);
+            }
+
+            BooleanExpression? on = null;
+            foreach (var conjunct in conjuncts)
+            {
+                if (TryExtractEquiKey(conjunct, sources, level, out _))
+                    on = on is null ? conjunct : BooleanExpression.And(on, conjunct);
+            }
+
+            if (on is null)
+                continue;
+            rewritten ??= (JoinSpec[])joins.Clone();
+            rewritten[level - 1] = new JoinSpec(JoinKind.Inner, on);
+        }
+
+        return rewritten ?? joins;
+    }
+
     /// <summary>
     /// Outer-row cap for choosing the per-outer index-seek strategy. A small
     /// outer set joined to an indexed inner wins big from seeking the inner per

SqlServerSimulator/Parser/Selection.Execution.cs

@@ -112,6 +112,13 @@ private static Selection BuildSqlProjection(
     {
         if (windows.Count > 0 && (aggregates.Count > 0 || fromClause.GroupingSets.Count > 0 || fromClause.Having is not null))
             throw new NotSupportedException("Combining window functions with GROUP BY / HAVING / aggregates in the same SELECT isn't modeled. EF Core 10 doesn't emit this shape.");
+
+        // Convert a comma-join / CROSS JOIN carrying an equi-join predicate in
+        // WHERE into an INNER JOIN, so it rides the equi-join seek / hash path
+        // instead of the O(L×R) nested loop. Value-independent, so it's done
+        // once here and the rewritten array is captured in the cached plan.
+        joins = RewriteCommaJoinsToEquiJoins(sources, joins, fromClause.Excluders);
+
         var orderBy = fromClause.OrderBy;
         var outputSchema = new SqlType[expressions.Count];
         var outputColumnNames = new string[expressions.Count];

docs/claude/joins.md

@@ -8,6 +8,12 @@ INNER / bare `JOIN` (= INNER) / LEFT [OUTER] / RIGHT [OUTER] / FULL [OUTER] / CR
 
 **Quirk — back-reference across a comma silently succeeds** (e.g. `FROM a, b JOIN c ON c.id = a.id`): real SQL Server binds `b JOIN c ON …` as its own scope and raises Msg 4104 because `a` isn't visible there; the simulator doesn't do parse-time scope-checking on ON predicates (column refs resolve at runtime through `ResolveAcrossTuple` across all FROM sources in the tuple), so the query runs and returns the Cartesian-filtered rowset. The common shapes — basic `FROM a, b WHERE …`, multi-comma chains, comma + derived table, explicit JOIN followed by comma — all match real SQL Server byte-for-byte; only this rare back-reference-across-comma case diverges, toward "more permissive" rather than wrong rowset.
 
+### Cross→Inner equi-join rewrite
+
+A bare `JoinKind.Cross` (from either a comma or an explicit `CROSS JOIN`) carries no ON predicate, so `ApplyJoin` never computes an equi-plan for it — it would always fall to the O(L×R) nested loop, even when WHERE carries a clean `a.k = b.k`. `RewriteCommaJoinsToEquiJoins` (run once at parse time, inside `BuildSqlProjection`, so the rewritten `joins[]` is captured in the cached plan) closes that gap: for each Cross level with no ON and a re-enumerable (non-lateral) right side, it scans the WHERE conjuncts for equi-keys connecting a prior source to that level (the same `TryExtractEquiKey` classifier the explicit-JOIN equi-plan uses), synthesizes them into an ON via `BooleanExpression.And`, and flips the level to `JoinKind.Inner`. It then rides `EquiJoinSeekOrHash` / `HashEquiJoin` exactly like an explicitly-written `INNER JOIN … ON`.
+
+`FROM a, b WHERE a.k = b.k` ≡ `a INNER JOIN b ON a.k = b.k` — the textbook inner-join ON/WHERE identity. **Correctness is anchored by the residual invariant**: every pulled conjunct *stays* in the WHERE excluders (never removed), so flipping Cross→Inner can only drop rows the WHERE would drop anyway. The post-WHERE result is therefore provably unchanged regardless of outer joins elsewhere in the chain — converting a `Cross` level mixed with a preceding LEFT JOIN's null-extended side, or feeding a later LEFT JOIN, leaves the surrounding outer-join semantics intact (the rewrite only ever touches Cross levels, never one that already has an ON). Only equi-keys are pulled; a non-equi WHERE term (`b.id > 10`) stays a post-join filter, so the synthesized ON's residual count is 0. A derived-table right side after a comma keeps its `LateralPlan`, so it's skipped (can't be seeked/hashed anyway) and stays on the nested loop.
+
 ## JoinDriver
 
 `JoinDriver` is a fold over `joins[]`: the leftmost rowset is wrapped with each join's operator in turn to produce the final enumerator. `ApplyJoin` picks the operator per join level — and is the single point where the strategy (hash vs nested loop) is decided.