Added UNION / UNION ALL / INTERSECT / EXCEPT support with INTERSECT-precedence chaining and post-chain top-level ORDER BY.

Author: RyanLamansky

CLAUDE.md

@@ -77,6 +77,7 @@ Heavy-hitters someone might assume work but don't. Source and `git log` are the
 - `decimal` / `numeric` values are backed by .NET `decimal`, so values requiring more than 28 significant digits aren't modeled (the type declarations up through `decimal(38, *)` are accepted so storage byte-width still matches SQL Server). `float` text formatting uses .NET's `G15`/`G7` conventions rather than SQL Server's exact `1e+015`-style scientific layout.
 - `CONVERT` / `TRY_CONVERT` style-code coverage. Only styles `0`, `120`, and `121` are wired up for date-like sources targeting a character string (the EF Core code-generation defaults). Other style numbers raise Msg 281; money / float / binary style codes and `CONVERT(date, str, 103)`-style date-parsing styles aren't modeled.
 - Boolean combinators in WHERE / MERGE-ON / CHECK predicates: `AND` / `OR` / `NOT`, parenthesized groupings, `IS [NOT] NULL`, and `[NOT] IN (literal, literal, ...)` all parse with standard SQL precedence (AND > OR; NOT highest). The pattern `where (arith_expr) cmp rhs` (parens-around-arithmetic as the left side of a comparison) is the one shape the simulator's parser doesn't accept; SQL Server does. `BooleanExpression.Run` returns `bool?` (three-valued: true / false / UNKNOWN); WHERE / MERGE-ON treat UNKNOWN as exclude, CHECK treats UNKNOWN as pass — matching SQL Server. `IS NULL` definitively resolves UNKNOWN to true/false (it's the canonical way to test nullability without falling through tri-state).
+- Set operations: `UNION`, `UNION ALL`, `INTERSECT`, `EXCEPT` all parse and execute. UNION dedupes; UNION ALL preserves duplicates; INTERSECT and EXCEPT both dedupe their inputs. NULLs are equal during set-op dedup / matching (opposite of `=`'s tri-state behavior — matching SQL Server's documented behavior). Result column names come from the first branch; result types are promoted across branches via `SqlType.Promote` and each branch's values are coerced to the combined schema. **Precedence**: INTERSECT binds tighter than UNION/EXCEPT (which are at the same level, left-to-right). Mismatched column count → Msg 205. **ORDER BY rules**: a non-set-op SELECT keeps the existing branch-internal ORDER BY (which can reference non-projected source columns); when a set-op follows the first branch, per-branch ORDER BY is rejected via Msg 156 (matching SQL Server's wording). Top-level ORDER BY (after the chain) wraps the combined result via `ApplyTopLevelOrderBy` and references first-branch column names only — no source-column fallback. `Selection.HasOrderBy` is the parse-time signal that gates per-branch-ORDER-BY-then-set-op rejection in `CombineSetOps`.
 - JOINs: `INNER JOIN ... ON`, bare `JOIN ... ON` (treated as INNER), `LEFT [OUTER] JOIN ... ON`, and `CROSS JOIN` (no ON) all parse and execute. Multi-table chains compose left-to-right; self-joins via alias work; ON-predicate three-valued logic excludes UNKNOWN matches (matching SQL Server). Column resolution is qualifier-aware across all sources — a multi-part name like `t1.id` matches only the source whose qualifier (alias-or-table-name) equals `t1`; an unqualified name that resolves in more than one source raises **Msg 209** (`"Ambiguous column name 'X'."`). Aliases parse with or without the `AS` keyword. Row enumeration is a recursive cross-product over `FromSource[]` with each tuple represented as `byte[]?[]` (one byte[] per source, null for the unmatched right side of a LEFT JOIN). **Not modeled**: `RIGHT JOIN` (rewrite as LEFT with sources swapped) and `FULL OUTER JOIN` raise `NotSupportedException` at parse time; comma-separated FROM (legacy ANSI-89 join syntax) is not parsed; `CROSS APPLY` / `OUTER APPLY` (lateral) aren't supported.
 - `CASE` expressions: both searched (`CASE WHEN cond THEN ... [ELSE ...] END`) and simple (`CASE input WHEN val THEN ... [ELSE ...] END`) forms parse anywhere an expression is allowed. Branches evaluate in source order; first true predicate wins. UNKNOWN is treated as exclude (matching WHERE), so the simple form's NULL-vs-NULL `WHEN` falls through (`CASE NULL WHEN NULL` → no match). Result type is computed via `SqlType.Promote` across all THEN / ELSE branches and cached on the first `GetSqlType` call; `Run` then coerces matched values to that common type so projection schema stays consistent. No-match-no-ELSE → typed NULL. **Not enforced**: Msg 8133 (real SQL Server raises this when every branch is a bare `NULL` literal — the simulator returns NULL of `int`).
 - Subqueries: `EXISTS (SELECT ...)` / `[NOT] EXISTS` and `expr [NOT] IN (SELECT ...)` parse as boolean atoms in WHERE / HAVING / CHECK; scalar subqueries `(SELECT col FROM ...)` parse anywhere an expression is allowed (projection, WHERE comparison, arithmetic operand). All forms work both correlated and non-correlated, with arbitrary outer-scope nesting depth. EXISTS counts rows only (multi-column inner allowed); `IN (SELECT ...)` and scalar subqueries require exactly one inner column (Msg 116). Scalar subqueries also enforce single-row cardinality at runtime (Msg 512, fired per outer row for correlated cases); empty result → NULL of the inner's projected type. NULL semantics in `IN (SELECT ...)` mirror the literal-list IN (NULL row → UNKNOWN unless a non-NULL match wins first). Column resolution honors qualifiers (`alias.col` / `tableName.col`) so a correlated reference to an outer column with the same name as an inner column works correctly. The inner plan re-executes per outer row (no result caching yet — fidelity over performance for now). `Selection.Parse` returns a deferred plan; `Selection.Execute(outerResolver)` materializes results, so the same plan re-runs against different outer rows. **Not modeled**: `ANY` / `SOME` / `ALL` quantifiers, `UNION` / `UNION ALL` inside a subquery body, row-constructor `IN ((1,2), (3,4))`. Derived tables in FROM (already supported) don't see outer scope (no APPLY / lateral).

SqlServerSimulator.Tests.EFCore/EFCoreSetOperations.cs

@@ -0,0 +1,78 @@
+namespace SqlServerSimulator;
+
+/// <summary>
+/// End-to-end tests for the set-operation shapes EF Core's SqlServer
+/// provider emits — LINQ <c>Union</c>/<c>Concat</c>/<c>Intersect</c>/
+/// <c>Except</c> against another query translate to <c>UNION</c>/
+/// <c>UNION ALL</c>/<c>INTERSECT</c>/<c>EXCEPT</c>. Validates that the
+/// simulator's set-op pipeline handles EF Core's concrete emit shapes
+/// end-to-end.
+/// </summary>
+[TestClass]
+public class EFCoreSetOperations
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private static TestDbContext SeededContext()
+    {
+        var context = new TestDbContext(TestDbContext.CreateCustomersSimulation());
+        context.Customers.AddRange(
+            new Customer { Name = "alpha" },
+            new Customer { Name = "beta" },
+            new Customer { Name = "gamma" });
+        _ = context.SaveChanges();
+        context.CustomerOrders.AddRange(
+            new CustomerOrder { CustomerId = 1, Amount = 10m },
+            new CustomerOrder { CustomerId = 2, Amount = 30m });
+        _ = context.SaveChanges();
+        return context;
+    }
+
+    [TestMethod]
+    public void Concat_EmitsUnionAll()
+    {
+        // LINQ Concat preserves duplicates → UNION ALL.
+        using var context = SeededContext();
+        var ids = context.Customers.Select(c => c.Id)
+            .Concat(context.Customers.Select(c => c.Id))
+            .OrderBy(x => x)
+            .ToArray();
+        // Each id appears twice.
+        CollectionAssert.AreEqual(new[] { 1, 1, 2, 2, 3, 3 }, ids);
+    }
+
+    [TestMethod]
+    public void Union_EmitsUnionWithDedup()
+    {
+        // LINQ Union dedupes → UNION.
+        using var context = SeededContext();
+        var ids = context.Customers.Select(c => c.Id)
+            .Union(context.Customers.Select(c => c.Id))
+            .OrderBy(x => x)
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 1, 2, 3 }, ids);
+    }
+
+    [TestMethod]
+    public void Intersect_EmitsIntersect()
+    {
+        // Customers ids 1,2,3 INTERSECT Customer ids of those with orders (1,2) → {1,2}.
+        using var context = SeededContext();
+        var ids = context.Customers.Select(c => c.Id)
+            .Intersect(context.CustomerOrders.Select(o => o.CustomerId))
+            .OrderBy(x => x)
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 1, 2 }, ids);
+    }
+
+    [TestMethod]
+    public void Except_EmitsExcept()
+    {
+        // Customer ids minus customer ids with orders → {3}.
+        using var context = SeededContext();
+        var ids = context.Customers.Select(c => c.Id)
+            .Except(context.CustomerOrders.Select(o => o.CustomerId))
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 3 }, ids);
+    }
+}

SqlServerSimulator.Tests/SetOperationTests.cs

@@ -0,0 +1,248 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Behavioral tests for SQL Server's set operators: <c>UNION</c> /
+/// <c>UNION ALL</c> / <c>INTERSECT</c> / <c>EXCEPT</c>. Covers dedup
+/// semantics (NULL-equals-NULL, opposite of <c>=</c>'s tri-state
+/// behavior), type promotion across branches, the precedence rule
+/// (INTERSECT binds tighter than UNION/EXCEPT), Msg 205 on column-count
+/// mismatch, Msg 156 on per-branch ORDER BY, and the top-level ORDER BY
+/// that applies post-chain. Sourced from probes against SQL Server 2025.
+/// </summary>
+[TestClass]
+public sealed class SetOperationTests
+{
+    private static List<int> ReadInts(DbCommand command)
+    {
+        using var reader = command.ExecuteReader();
+        var values = new List<int>();
+        while (reader.Read())
+            values.Add(reader.GetInt32(0));
+        return values;
+    }
+
+    // === UNION / UNION ALL ===
+
+    [TestMethod]
+    public void Union_Dedupes()
+    {
+        var values = ReadInts(new Simulation().CreateCommand("select 1 union select 2 union select 1"));
+        CollectionAssert.AreEquivalent(new[] { 1, 2 }, values);
+    }
+
+    [TestMethod]
+    public void UnionAll_PreservesDuplicates()
+    {
+        var values = ReadInts(new Simulation().CreateCommand("select 1 union all select 2 union all select 1"));
+        CollectionAssert.AreEqual(new[] { 1, 2, 1 }, values);
+    }
+
+    [TestMethod]
+    public void Union_NullsCompareEqual_DedupedToSingleRow()
+    {
+        // SET ops treat NULLs as equal — opposite of `=` operator's UNKNOWN.
+        using var connection = new Simulation().CreateOpenConnection();
+        using var reader = connection.CreateCommand(
+            "select cast(null as int) union select cast(null as int)").ExecuteReader();
+        var rows = 0;
+        while (reader.Read())
+            rows++;
+        AreEqual(1, rows);
+    }
+
+    // === INTERSECT ===
+
+    [TestMethod]
+    public void Intersect_KeepsCommonRows()
+    {
+        var values = ReadInts(new Simulation().CreateCommand("select 1 intersect select 1"));
+        CollectionAssert.AreEqual(new[] { 1 }, values);
+    }
+
+    [TestMethod]
+    public void Intersect_NoOverlap_Empty()
+    {
+        var values = ReadInts(new Simulation().CreateCommand("select 1 intersect select 2"));
+        IsEmpty(values);
+    }
+
+    [TestMethod]
+    public void Intersect_NullsMatch()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        using var reader = connection.CreateCommand(
+            "select cast(null as int) intersect select cast(null as int)").ExecuteReader();
+        var rows = 0;
+        while (reader.Read()) rows++;
+        AreEqual(1, rows);
+    }
+
+    // === EXCEPT ===
+
+    [TestMethod]
+    public void Except_RemovesRightSide()
+    {
+        var values = ReadInts(new Simulation().CreateCommand("select 1 except select 2"));
+        CollectionAssert.AreEqual(new[] { 1 }, values);
+    }
+
+    [TestMethod]
+    public void Except_AllRemoved_Empty()
+    {
+        var values = ReadInts(new Simulation().CreateCommand("select 1 except select 1"));
+        IsEmpty(values);
+    }
+
+    [TestMethod]
+    public void Except_DedupesLeftBeforeFiltering()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (v int)");
+        _ = simulation.ExecuteNonQuery("insert into t values (1), (1), (2)");
+
+        using var connection = simulation.CreateOpenConnection();
+        var values = ReadInts(connection.CreateCommand("select v from t except select 99"));
+        // INTERSECT/EXCEPT both dedupe their left side (probe-confirmed).
+        CollectionAssert.AreEquivalent(new[] { 1, 2 }, values);
+    }
+
+    // === Type promotion / column count ===
+
+    [TestMethod]
+    public void TypePromotion_IntPlusDecimal_ProducesDecimal()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        using var reader = connection.CreateCommand("select 1 union select 2.5").ExecuteReader();
+        var values = new List<decimal>();
+        while (reader.Read())
+            values.Add(reader.GetDecimal(0));
+        CollectionAssert.AreEquivalent(new[] { 1m, 2.5m }, values);
+    }
+
+    [TestMethod]
+    public void MismatchedColumnCount_RaisesMsg205()
+    {
+        var ex = Throws<DbException>(() =>
+            _ = new Simulation().ExecuteScalar("select 1, 2 union select 3"));
+        AreEqual("205", ex.Data["HelpLink.EvtID"]);
+        AreEqual("All queries combined using a UNION, INTERSECT or EXCEPT operator must have an equal number of expressions in their target lists.", ex.Message);
+    }
+
+    // === Precedence / chaining ===
+
+    [TestMethod]
+    public void Intersect_BindsTighterThanUnion()
+    {
+        // `1 union 2 intersect 2` should parse as `1 union (2 intersect 2)` = {1, 2}.
+        var values = ReadInts(new Simulation().CreateCommand("select 1 union select 2 intersect select 2"));
+        CollectionAssert.AreEquivalent(new[] { 1, 2 }, values);
+    }
+
+    [TestMethod]
+    public void ThreeBranchUnion_LeftAssociative()
+    {
+        var values = ReadInts(new Simulation().CreateCommand("select 1 union select 2 union select 3"));
+        CollectionAssert.AreEquivalent(new[] { 1, 2, 3 }, values);
+    }
+
+    [TestMethod]
+    public void UnionAllAfterUnion_PreservesDupAtEnd()
+    {
+        // `(1 union 2) union all 1` = {1, 2} ++ {1} = {1, 2, 1}.
+        var values = ReadInts(new Simulation().CreateCommand("select 1 union select 2 union all select 1"));
+        CollectionAssert.AreEqual(new[] { 1, 2, 1 }, values);
+    }
+
+    // === ORDER BY interaction ===
+
+    [TestMethod]
+    public void TopLevelOrderBy_AppliesToCombinedResult()
+    {
+        // ORDER BY at the very end applies to the combined result and
+        // can reference the first branch's column name.
+        using var connection = new Simulation().CreateOpenConnection();
+        using var reader = connection.CreateCommand(
+            "select 1 as v union select 2 union select 3 order by v desc").ExecuteReader();
+        var values = new List<int>();
+        while (reader.Read())
+            values.Add(reader.GetInt32(0));
+        CollectionAssert.AreEqual(new[] { 3, 2, 1 }, values);
+    }
+
+    [TestMethod]
+    public void PerBranchOrderBy_RaisesMsg156()
+    {
+        var ex = Throws<DbException>(() =>
+            _ = new Simulation().ExecuteScalar("select 1 order by 1 union select 2"));
+        AreEqual("156", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void SingleSelect_OrderByNonProjectedSource_StillWorks()
+    {
+        // The set-op refactor must not break the existing branch-internal
+        // ORDER BY path: a non-set-op SELECT can still ORDER BY a source
+        // column that's not in the projection list.
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (a int, b int)");
+        _ = simulation.ExecuteNonQuery("insert into t values (3, 30), (1, 10), (2, 20)");
+
+        using var connection = simulation.CreateOpenConnection();
+        using var reader = connection.CreateCommand("select b from t order by a").ExecuteReader();
+        var values = new List<int>();
+        while (reader.Read())
+            values.Add(reader.GetInt32(0));
+        // a=1,2,3 → b=10,20,30 in that order.
+        CollectionAssert.AreEqual(new[] { 10, 20, 30 }, values);
+    }
+
+    // === Tabled-source set ops ===
+
+    [TestMethod]
+    public void Union_AcrossTwoTables_Dedupes()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table left_t (v int)");
+        _ = simulation.ExecuteNonQuery("create table right_t (v int)");
+        _ = simulation.ExecuteNonQuery("insert into left_t values (1), (2), (3)");
+        _ = simulation.ExecuteNonQuery("insert into right_t values (3), (4), (5)");
+
+        using var connection = simulation.CreateOpenConnection();
+        var values = ReadInts(connection.CreateCommand(
+            "select v from left_t union select v from right_t"));
+        CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5 }, values);
+    }
+
+    [TestMethod]
+    public void Intersect_AcrossTwoTables_Common()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table left_t (v int)");
+        _ = simulation.ExecuteNonQuery("create table right_t (v int)");
+        _ = simulation.ExecuteNonQuery("insert into left_t values (1), (2), (3)");
+        _ = simulation.ExecuteNonQuery("insert into right_t values (3), (4), (5)");
+
+        using var connection = simulation.CreateOpenConnection();
+        var values = ReadInts(connection.CreateCommand(
+            "select v from left_t intersect select v from right_t"));
+        CollectionAssert.AreEqual(new[] { 3 }, values);
+    }
+
+    [TestMethod]
+    public void Except_AcrossTwoTables_LeftMinusRight()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table left_t (v int)");
+        _ = simulation.ExecuteNonQuery("create table right_t (v int)");
+        _ = simulation.ExecuteNonQuery("insert into left_t values (1), (2), (3)");
+        _ = simulation.ExecuteNonQuery("insert into right_t values (3), (4), (5)");
+
+        using var connection = simulation.CreateOpenConnection();
+        var values = ReadInts(connection.CreateCommand(
+            "select v from left_t except select v from right_t"));
+        CollectionAssert.AreEquivalent(new[] { 1, 2 }, values);
+    }
+}

SqlServerSimulator/Parser/FromSource.cs

@@ -43,6 +43,22 @@ internal sealed class FromSource(
     public readonly IEnumerable<byte[]> Rows = rows;
 }
 
+/// <summary>
+/// The four set-operation variants the simulator parses. <c>Union</c>
+/// dedupes; <c>UnionAll</c> preserves duplicates; <c>Intersect</c> keeps
+/// rows present in both branches (dedupes); <c>Except</c> keeps left-side
+/// rows not in the right (dedupes). NULLs are equal during dedup /
+/// matching — opposite of the <c>=</c> operator's three-valued behavior,
+/// matching SQL Server's documented set-op semantics.
+/// </summary>
+internal enum SetOpKind
+{
+    Union,
+    UnionAll,
+    Intersect,
+    Except,
+}
+
 /// <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