UNION / UNION ALL / INTERSECT / EXCEPT inside every subquery context (derived tables in FROM, EXISTS, IN, scalar, CTE bodies) already shipped via Selection.Parse → ParseQueryExpression; this commit adds the regression coverage that was missing: 12 SetOperationTests cases (TPC discriminator shape, UNION-joined-with-outer-table, nested UNION, scalar-subquery single-row vs Msg-512 multi-row) + 4 EFCoreInheritanceTpc cases exercising EF Core 10's UseTpcMappingStrategy end-to-end (base-set query, base-property filter, OfType<T>, Count across the union'd concrete tables). CLAUDE.md: removed the stale "Not modeled" line, expanded the Subqueries section to call out set-ops-anywhere + EF TPC coverage.

Author: RyanLamansky

CLAUDE.md

@@ -100,7 +100,7 @@ INNER / bare JOIN / LEFT [OUTER] / RIGHT [OUTER] / FULL [OUTER] / CROSS / CROSS
 `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.
+`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. `UNION` / `UNION ALL` / `INTERSECT` / `EXCEPT` are legal inside every subquery context — derived tables in FROM, EXISTS, IN, scalar `(SELECT ...)`, CTE bodies — because subquery parsers route through `Selection.Parse` → `ParseQueryExpression`, which already drives the set-op chain. EF Core 7+'s TPC inheritance emit shape (UNION ALL of selects from each concrete table wrapped in a derived table) ships end-to-end through this path.
 
 ### 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.
@@ -156,7 +156,6 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - `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.
 - Row-constructor `IN ((1,2), (3,4))`.
 - Window functions other than `ROW_NUMBER` and the aggregate-OVER family.
 - Recursive-part feature restrictions (Msg 460 DISTINCT / 461 TOP / 462 OUTER JOIN / 467 aggregate-or-GROUP-BY / 465 ref-in-subquery) — silently accepted with possibly-incorrect semantics rather than raising. Apps that exercise these in real SQL Server hit rejection there too.

SqlServerSimulator.Tests.EFCore/EFCoreInheritanceTpc.cs

@@ -0,0 +1,137 @@
+using Microsoft.EntityFrameworkCore;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// End-to-end tests for EF Core's Table-Per-Concrete-type (TPC) inheritance
+/// mapping. TPC stores each concrete entity in its own table and EF Core
+/// queries the base set by emitting <c>UNION ALL</c> across all concrete
+/// tables, wrapped in a derived table that's filtered / projected by the
+/// outer query. Exercises the simulator's UNION-inside-subquery support
+/// against the concrete shape EF Core 7+'s headline inheritance strategy
+/// emits.
+/// </summary>
+[TestClass]
+public class EFCoreInheritanceTpc
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private abstract class Pet
+    {
+        public int Id { get; set; }
+
+        [Column(TypeName = "nvarchar(50)")]
+        public string Name { get; set; } = "";
+    }
+
+    private sealed class Dog : Pet
+    {
+        public int BarkVolume { get; set; }
+    }
+
+    private sealed class Cat : Pet
+    {
+        public bool Purrs { get; set; }
+    }
+
+    private sealed class PetContext(Simulation simulation) : DbContext
+    {
+        public Simulation Simulation { get; } = simulation;
+
+        public DbSet<Pet> Pets => Set<Pet>();
+        public DbSet<Dog> Dogs => Set<Dog>();
+        public DbSet<Cat> Cats => Set<Cat>();
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        {
+            _ = optionsBuilder.UseSqlServer(this.Simulation.CreateDbConnection());
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            // Caller-supplied PKs keep the test off the sequence path the
+            // simulator doesn't model (EF Core's TPC default is HiLo via a
+            // shared sequence, which would need a sequence object).
+            _ = modelBuilder.Entity<Pet>()
+                .UseTpcMappingStrategy()
+                .Property(p => p.Id)
+                .ValueGeneratedNever();
+            _ = modelBuilder.Entity<Dog>().ToTable("Dogs");
+            _ = modelBuilder.Entity<Cat>().ToTable("Cats");
+        }
+    }
+
+    private static Simulation CreatePetsSimulation()
+    {
+        var simulation = new Simulation();
+        _ = simulation
+            .CreateOpenConnection()
+            .CreateCommand("""
+                create table Dogs (
+                    Id int not null primary key,
+                    Name nvarchar(50) not null,
+                    BarkVolume int not null
+                );
+                create table Cats (
+                    Id int not null primary key,
+                    Name nvarchar(50) not null,
+                    Purrs bit not null
+                )
+                """)
+            .ExecuteNonQuery();
+        return simulation;
+    }
+
+    private static PetContext SeededContext()
+    {
+        var context = new PetContext(CreatePetsSimulation());
+        context.Dogs.AddRange(
+            new Dog { Id = 1, Name = "Rex", BarkVolume = 5 },
+            new Dog { Id = 2, Name = "Buddy", BarkVolume = 7 });
+        _ = context.Cats.Add(new Cat { Id = 3, Name = "Whiskers", Purrs = true });
+        _ = context.SaveChanges();
+        return context;
+    }
+
+    [TestMethod]
+    public void Pets_QueryBaseSet_UnionsAllConcreteTables()
+    {
+        // Querying the base set under TPC translates to a UNION ALL of selects
+        // from each concrete table, wrapped in a derived table for downstream
+        // operations.
+        using var context = SeededContext();
+        var names = context.Pets.OrderBy(p => p.Id).Select(p => p.Name).ToArray();
+        CollectionAssert.AreEqual(new[] { "Rex", "Buddy", "Whiskers" }, names);
+    }
+
+    [TestMethod]
+    public void Pets_FilterOnBaseProperty_PushesThroughUnion()
+    {
+        // Outer WHERE on a base property filters the union'd rowset.
+        using var context = SeededContext();
+        var names = context.Pets.Where(p => p.Name.StartsWith("R") || p.Name.StartsWith("W"))
+            .OrderBy(p => p.Id)
+            .Select(p => p.Name)
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { "Rex", "Whiskers" }, names);
+    }
+
+    [TestMethod]
+    public void Pets_OfTypeDog_QueriesDogsTableOnly()
+    {
+        // OfType<Dog>() narrows the query to the concrete table without UNION.
+        using var context = SeededContext();
+        var dogs = context.Pets.OfType<Dog>().OrderBy(d => d.Id).ToArray();
+        Assert.HasCount(2, dogs);
+        Assert.AreEqual("Rex", dogs[0].Name); Assert.AreEqual(5, dogs[0].BarkVolume);
+        Assert.AreEqual("Buddy", dogs[1].Name); Assert.AreEqual(7, dogs[1].BarkVolume);
+    }
+
+    [TestMethod]
+    public void Pets_CountAcrossUnion_ReturnsTotalAcrossAllConcretes()
+    {
+        using var context = SeededContext();
+        Assert.AreEqual(3, context.Pets.Count());
+    }
+}

SqlServerSimulator.Tests/SetOperationTests.cs

@@ -182,4 +182,156 @@ public void Intersect_AcrossTwoTables_Common()
     public void Except_AcrossTwoTables_LeftMinusRight()
         => CollectionAssert.AreEquivalent(new[] { 1, 2 },
             ReadInts(SeededTwoTables().CreateCommand("select v from left_t except select v from right_t")));
+
+    // Set-ops inside a subquery body. The simulator's subquery parsers
+    // (Expression.cs / BooleanExpression.cs) all route through Selection.Parse,
+    // which already drives the set-op chain — exercised here as a regression so
+    // refactors of that surface don't silently break TPC-shaped queries.
+
+    [TestMethod]
+    public void Union_InsideFromDerivedTable()
+        => CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5 },
+            ReadInts(SeededTwoTables().CreateCommand(
+                "select x.v from (select v from left_t union select v from right_t) x")));
+
+    [TestMethod]
+    public void UnionAll_InsideFromDerivedTable_PreservesDuplicates()
+        => CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 3, 4, 5 },
+            ReadInts(SeededTwoTables().CreateCommand(
+                "select x.v from (select v from left_t union all select v from right_t) x")));
+
+    [TestMethod]
+    public void Union_InsideExistsSubquery_AnyBranchSatisfies()
+    {
+        using var connection = SeededTwoTables().CreateOpenConnection();
+        using var reader = connection.CreateCommand(
+            "select v from left_t where exists (select 1 from right_t where v = left_t.v union select 1 from right_t where v = left_t.v)").ExecuteReader();
+        var values = new List<int>();
+        while (reader.Read())
+            values.Add(reader.GetInt32(0));
+        CollectionAssert.AreEquivalent(new[] { 3 }, values);
+    }
+
+    [TestMethod]
+    public void Union_InsideInSubquery_MembershipMatchesEitherBranch()
+        => CollectionAssert.AreEquivalent(new[] { 1, 3 },
+            ReadInts(SeededTwoTables().CreateCommand(
+                "select v from left_t where v in (select 1 union select 3)")));
+
+    [TestMethod]
+    public void Union_InsideScalarSubquery_SingleColumnSingleRowOk()
+    {
+        // Scalar subquery + UNION: both branches project a single column AND the
+        // UNION dedups to a single row (max(v) = 3 in both branches), so the scalar
+        // value resolves to 3.
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (v int); insert t values (1), (2), (3)");
+        using var reader = simulation.CreateCommand(
+            "select (select max(v) from t union select max(v) from t) as m").ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(3, reader.GetInt32(0));
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void Union_InsideScalarSubquery_MultiRowResultRaises512()
+        => SeededTwoTables().AssertSqlError(
+            "select (select max(v) from left_t union select max(v) from right_t) as m",
+            512);
+
+    [TestMethod]
+    public void Union_InsideCteBody_RecursiveAndAnchorBranches()
+    {
+        // Non-recursive CTE body that's itself a UNION: a common EF Core 7 TPC shape
+        // wrapped inside WITH for downstream filtering.
+        using var connection = SeededTwoTables().CreateOpenConnection();
+        var values = ReadInts(connection.CreateCommand(
+            "with combined as (select v from left_t union select v from right_t) select v from combined"));
+        CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5 }, values);
+    }
+
+    [TestMethod]
+    public void TpcDiscriminator_Shape_OuterFiltersRoundTrip()
+    {
+        // Mimics EF Core 7+'s TPC inheritance emit shape: each concrete table contributes
+        // a SELECT with a constant discriminator column, the branches UNION ALL inside
+        // a derived table, and the outer query filters / projects through that table.
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table dogs (Id int, Name nvarchar(50), BarkVolume int);
+            create table cats (Id int, Name nvarchar(50), Purrs bit);
+            insert dogs values (1, 'Rex', 5), (2, 'Buddy', 7);
+            insert cats values (3, 'Whiskers', 1)
+            """);
+
+        using var reader = simulation.CreateCommand("""
+            select t.Id, t.Name from (
+                select Id, Name, 'Dog' as TypeTag from dogs
+                union all
+                select Id, Name, 'Cat' as TypeTag from cats
+            ) t
+            where t.TypeTag = 'Cat'
+            """).ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(3, reader.GetInt32(0));
+        AreEqual("Whiskers", reader.GetString(1));
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void Union_DerivedTable_LeftJoinedWithOuterTable()
+    {
+        // TPC variant: union'd derived table is joined to another table.
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table dogs (Id int, Name nvarchar(50));
+            create table cats (Id int, Name nvarchar(50));
+            create table owners (PetId int, OwnerName nvarchar(50));
+            insert dogs values (1, 'Rex');
+            insert cats values (2, 'Whiskers');
+            insert owners values (1, 'alice'), (2, 'bob')
+            """);
+
+        using var reader = simulation.CreateCommand("""
+            select t.Id, o.OwnerName from (
+                select Id, Name from dogs
+                union all
+                select Id, Name from cats
+            ) t
+            left join owners o on t.Id = o.PetId
+            order by t.Id
+            """).ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(1, reader.GetInt32(0));
+        AreEqual("alice", reader.GetString(1));
+        IsTrue(reader.Read());
+        AreEqual(2, reader.GetInt32(0));
+        AreEqual("bob", reader.GetString(1));
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void NestedUnion_InsideUnionInsideFrom()
+    {
+        // Tests the parser's depth bookkeeping: a UNION-bearing derived table inside
+        // another UNION-bearing derived table.
+        using var reader = new Simulation().CreateCommand(
+            "select y.a from (select a from (select 1 as a union select 2) x union select 3) y order by y.a").ExecuteReader();
+        var values = new List<int>();
+        while (reader.Read())
+            values.Add(reader.GetInt32(0));
+        CollectionAssert.AreEqual(new[] { 1, 2, 3 }, values);
+    }
+
+    [TestMethod]
+    public void Except_InsideFromDerivedTable()
+        => CollectionAssert.AreEquivalent(new[] { 1, 2 },
+            ReadInts(SeededTwoTables().CreateCommand(
+                "select x.v from (select v from left_t except select v from right_t) x")));
+
+    [TestMethod]
+    public void Intersect_InsideFromDerivedTable()
+        => CollectionAssert.AreEquivalent(new[] { 3 },
+            ReadInts(SeededTwoTables().CreateCommand(
+                "select x.v from (select v from left_t intersect select v from right_t) x")));
 }