Implemented minimum INSERT ... OUTPUT INSERTED and MERGE INTO target USING (VALUES) to unblock EF Core features.

Author: RyanLamansky

CLAUDE.md

@@ -76,7 +76,7 @@ Heavy-hitters someone might assume work but don't. Source and `git log` are the
 - Pattern matching (`LIKE`) and `CONVERT`.
 - Cross-category `Promote` for integer ↔ string. Only CAST works for that pair.
 - EF Core compatibility: the SqlServer provider downcasts `DbParameter` to `SqlParameter` for some mappings — `DateTime → date`, `DateTime → smalldatetime`, `DateOnly`, `TimeOnly`, `TimeSpan`, and `decimal → money` / `decimal → smallmoney` (via `SqlServerDecimalTypeMapping`) all break at SaveChanges. See `SimulatedDbParameter` for the matrix; a `SqlServerSimulator.EFCore` adapter package is planned to close the gap.
-- `IDENTITY` columns work end-to-end in raw SQL (auto-generation, `SET IDENTITY_INSERT`, `SCOPE_IDENTITY()` / `@@IDENTITY` / `IDENT_CURRENT()`), but EF Core SaveChanges with an identity entity emits `INSERT ... OUTPUT INSERTED.Id` for single rows and `MERGE INTO ... OUTPUT` for multi-row writes — neither statement form is parsed yet, so EF Core identity inserts fail. `EFCoreIdentity` pins the gap as a regression test until OUTPUT/MERGE land.
+- `OUTPUT` and `MERGE` are scoped to the EF Core SaveChanges shape: `INSERT ... OUTPUT INSERTED.<col>` (single-row) and `MERGE INTO target USING (VALUES ...) AS alias (cols) ON predicate WHEN NOT MATCHED THEN INSERT ... [OUTPUT ...]` (multi-row batch). `OUTPUT INTO @table_var`, `OUTPUT DELETED.*`, OUTPUT on UPDATE/DELETE, `INSERTED.*` star expansion, MERGE source subqueries, MERGE target with column refs in `ON`, the `WHEN MATCHED` UPDATE/DELETE branches, and `$action` aren't supported. The `WHEN MATCHED` branch parses syntactically but throws `NotSupportedException` if the per-row predicate ever evaluates true.
 - Session-scoped state. `SCOPE_IDENTITY()` / `@@IDENTITY`, `SET IDENTITY_INSERT`'s active table, and `DBCC TRACEON(N)` flags all live on `Simulation` rather than per-connection. The simulator collapses session vs global scope until a real connection-scoped state model exists; revisit when transactions/locks/MVCC bring the per-session shape with them.
 - CAST to a smaller `varchar`/`nvarchar` than the value renders: SQL Server silently truncates; the simulator returns the full string.
 - Heap allocation tracking (IAM/PFS): the page list is flat.

SqlServerSimulator.Tests.EFCore/EFCoreIdentity.cs

@@ -3,60 +3,88 @@
 namespace SqlServerSimulator;
 
 /// <summary>
-/// Exercises the simulator's <c>IDENTITY</c> column support through EF Core.
-/// SaveChanges on an EF-managed identity entity emits
-/// <c>INSERT ... OUTPUT INSERTED.Id</c> (single row) or <c>MERGE INTO ... OUTPUT</c>
-/// (multi-row) — neither is parsed yet, so that path is pinned as a gap by
-/// <see cref="Insert_IdentityKey_AwaitsOutputClauseSupport"/>. The other
-/// tests exercise three EF Core paths that <i>don't</i> require
-/// <c>OUTPUT</c>: read-only LINQ, <c>SqlQueryRaw</c> against the identity
-/// scalars, and <c>SaveChanges</c> with <c>DatabaseGenerated.None</c> + <c>SET IDENTITY_INSERT ON</c>.
+/// Exercises the simulator's <c>IDENTITY</c> column support through EF Core's
+/// SaveChanges path. EF emits <c>INSERT ... OUTPUT INSERTED.Id</c> for a
+/// single new entity and <c>MERGE INTO ... USING (VALUES ...) ... OUTPUT</c>
+/// for a multi-entity batch; both forms now round-trip end-to-end. Coverage
+/// also includes raw <c>SqlQueryRaw</c> against the identity scalars and the
+/// <c>DatabaseGenerated.None</c> + <c>SET IDENTITY_INSERT</c> escape hatch.
 /// </summary>
 [TestClass]
 public class EFCoreIdentity
 {
     public TestContext TestContext { get; set; } = null!;
 
     [TestMethod]
-    public void Insert_IdentityKey_AwaitsOutputClauseSupport()
+    public void SaveChanges_SingleEntity_AssignsGeneratedIdentity()
     {
         using var context = new TestDbContext(TestDbContext.CreateWidgetsSimulation());
 
         var widget = new Widget { Name = "First" };
         _ = context.Widgets.Add(widget);
+        _ = context.SaveChanges();
+
+        Assert.AreEqual(1, widget.Id);
+        Assert.AreEqual("First", context.Widgets.Where(w => w.Id == 1).Select(w => w.Name).Single());
+    }
+
+    [TestMethod]
+    public void SaveChanges_MultipleEntities_AssignsContiguousIdentities()
+    {
+        // EF emits MERGE for >1 row inserts; the OUTPUT clause carries the
+        // generated Ids back through a positional source column so EF can
+        // rehydrate the in-memory entities.
+        using var context = new TestDbContext(TestDbContext.CreateWidgetsSimulation());
+
+        var a = new Widget { Name = "A" };
+        var b = new Widget { Name = "B" };
+        var c = new Widget { Name = "C" };
+        context.Widgets.AddRange(a, b, c);
+        _ = context.SaveChanges();
+
+        Assert.AreEqual(1, a.Id);
+        Assert.AreEqual(2, b.Id);
+        Assert.AreEqual(3, c.Id);
+    }
 
-        var ex = Assert.Throws<DbUpdateException>(() => context.SaveChanges());
-        StringAssert.Contains(ex.InnerException?.Message ?? "", "OUTPUT");
+    [TestMethod]
+    public void SaveChanges_AcrossBatches_ReseedsThroughHighWaterMark()
+    {
+        // Each SaveChanges produces a fresh INSERT/MERGE. Identity continues
+        // counting from the table's high-water mark across calls.
+        using var context = new TestDbContext(TestDbContext.CreateWidgetsSimulation());
+
+        _ = context.Widgets.Add(new Widget { Name = "first" });
+        _ = context.SaveChanges();
+
+        var pair = new[] { new Widget { Name = "second" }, new Widget { Name = "third" } };
+        context.Widgets.AddRange(pair);
+        _ = context.SaveChanges();
+
+        Assert.AreEqual(2, pair[0].Id);
+        Assert.AreEqual(3, pair[1].Id);
     }
 
     [TestMethod]
     public void Query_IdentityRows_ReturnsAutoGeneratedIds()
     {
-        var simulation = TestDbContext.CreateWidgetsSimulation();
-        _ = simulation
-            .CreateOpenConnection()
-            .CreateCommand("insert into Widgets (Name) values ('A'),('B'),('C')")
-            .ExecuteNonQuery();
+        using var context = new TestDbContext(TestDbContext.CreateWidgetsSimulation());
+        context.Widgets.AddRange(new Widget { Name = "A" }, new Widget { Name = "B" }, new Widget { Name = "C" });
+        _ = context.SaveChanges();
 
-        using var context = new TestDbContext(simulation);
         var rows = context.Widgets.OrderBy(w => w.Id).ToArray();
-
         CollectionAssert.AreEqual(new[] { 1, 2, 3 }, rows.Select(w => w.Id).ToArray());
         CollectionAssert.AreEqual(new[] { "A", "B", "C" }, rows.Select(w => w.Name).ToArray());
     }
 
     [TestMethod]
     public void Where_FiltersByAutoGeneratedId()
     {
-        var simulation = TestDbContext.CreateWidgetsSimulation();
-        _ = simulation
-            .CreateOpenConnection()
-            .CreateCommand("insert into Widgets (Name) values ('A'),('B'),('C')")
-            .ExecuteNonQuery();
+        using var context = new TestDbContext(TestDbContext.CreateWidgetsSimulation());
+        context.Widgets.AddRange(new Widget { Name = "A" }, new Widget { Name = "B" }, new Widget { Name = "C" });
+        _ = context.SaveChanges();
 
-        using var context = new TestDbContext(simulation);
         var name = context.Widgets.Where(w => w.Id == 2).Select(w => w.Name).Single();
-
         Assert.AreEqual("B", name);
     }
 
@@ -83,15 +111,11 @@ public void SqlQueryRaw_ScopeIdentity_ReturnsLastInsertedValue()
     [TestMethod]
     public void SqlQueryRaw_IdentCurrent_ReturnsHighWaterMark()
     {
-        var simulation = TestDbContext.CreateWidgetsSimulation();
-        _ = simulation
-            .CreateOpenConnection()
-            .CreateCommand("insert into Widgets (Name) values ('A'),('B'),('C')")
-            .ExecuteNonQuery();
+        using var context = new TestDbContext(TestDbContext.CreateWidgetsSimulation());
+        context.Widgets.AddRange(new Widget { Name = "A" }, new Widget { Name = "B" }, new Widget { Name = "C" });
+        _ = context.SaveChanges();
 
-        using var context = new TestDbContext(simulation);
         var ic = context.Database.SqlQueryRaw<decimal>("select IDENT_CURRENT('Widgets') as Value").AsEnumerable().Single();
-
         Assert.AreEqual(3m, ic);
     }