Added support for various IDENTITY features.

Author: RyanLamansky

CLAUDE.md

@@ -72,10 +72,11 @@ Heavy-hitters someone might assume work but don't. Source and `git log` are the
 - Transactions / locks / MVCC.
 - Row-overflow / LOB pages and the `varchar(MAX)` / `nvarchar(MAX)` / `varbinary(MAX)` types they enable.
 - `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. `money` / `smallmoney` are wired in raw SQL but unreachable through EF Core for the same `SqlParameter`-downcast reason as the date-only / time-only mappings — adding a money column to an EF entity breaks that entity's whole save path.
-- Identity columns.
 - `NEWSEQUENTIALID()` (deferred until `DEFAULT`-clause support exists in `CREATE TABLE`; the function is only valid in that context).
 - 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.
+- 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

@@ -0,0 +1,146 @@
+using Microsoft.EntityFrameworkCore;
+
+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>.
+/// </summary>
+[TestClass]
+public class EFCoreIdentity
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    [TestMethod]
+    public void Insert_IdentityKey_AwaitsOutputClauseSupport()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateWidgetsSimulation());
+
+        var widget = new Widget { Name = "First" };
+        _ = context.Widgets.Add(widget);
+
+        var ex = Assert.Throws<DbUpdateException>(() => context.SaveChanges());
+        StringAssert.Contains(ex.InnerException?.Message ?? "", "OUTPUT");
+    }
+
+    [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(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(simulation);
+        var name = context.Widgets.Where(w => w.Id == 2).Select(w => w.Name).Single();
+
+        Assert.AreEqual("B", name);
+    }
+
+    [TestMethod]
+    public void SqlQueryRaw_ScopeIdentity_ReturnsLastInsertedValue()
+    {
+        // SCOPE_IDENTITY/@@IDENTITY are simulation-wide here (not per-session) —
+        // see CLAUDE.md's "session-scoped state" gap. That collapse means the
+        // raw INSERT on a separate connection still updates the value EF reads.
+        var simulation = TestDbContext.CreateWidgetsSimulation();
+        _ = simulation
+            .CreateOpenConnection()
+            .CreateCommand("insert into Widgets (Name) values ('First'),('Second')")
+            .ExecuteNonQuery();
+
+        using var context = new TestDbContext(simulation);
+        var sid = context.Database.SqlQueryRaw<decimal>("select SCOPE_IDENTITY() as Value").AsEnumerable().Single();
+        var atid = context.Database.SqlQueryRaw<decimal>("select @@IDENTITY as Value").AsEnumerable().Single();
+
+        Assert.AreEqual(2m, sid);
+        Assert.AreEqual(2m, atid);
+    }
+
+    [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(simulation);
+        var ic = context.Database.SqlQueryRaw<decimal>("select IDENT_CURRENT('Widgets') as Value").AsEnumerable().Single();
+
+        Assert.AreEqual(3m, ic);
+    }
+
+    [TestMethod]
+    public void SqlQueryRaw_ScopeIdentity_BeforeAnyInsertIsNull()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateWidgetsSimulation());
+        var sid = context.Database.SqlQueryRaw<decimal?>("select SCOPE_IDENTITY() as Value").AsEnumerable().Single();
+
+        Assert.IsNull(sid);
+    }
+
+    [TestMethod]
+    public void SaveChanges_WithIdentityInsertOn_PersistsExplicitId()
+    {
+        var simulation = TestDbContext.CreateStickersSimulation();
+        _ = simulation
+            .CreateOpenConnection()
+            .CreateCommand("set identity_insert Stickers on")
+            .ExecuteNonQuery();
+
+        using var context = new TestDbContext(simulation);
+        _ = context.Stickers.Add(new Sticker { Id = 100, Tag = "explicit" });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual("explicit", context.Stickers.Where(s => s.Id == 100).Select(s => s.Tag).Single());
+    }
+
+    [TestMethod]
+    public void SaveChanges_WithIdentityInsertOn_AdvancesSeed()
+    {
+        // Inserting an explicit Id past the high-water mark via EF should
+        // reseed the same way raw SQL does.
+        var simulation = TestDbContext.CreateStickersSimulation();
+        _ = simulation
+            .CreateOpenConnection()
+            .CreateCommand("set identity_insert Stickers on")
+            .ExecuteNonQuery();
+
+        using (var context = new TestDbContext(simulation))
+        {
+            _ = context.Stickers.Add(new Sticker { Id = 50, Tag = "jump" });
+            _ = context.SaveChanges();
+        }
+
+        var ic = simulation
+            .CreateOpenConnection()
+            .CreateCommand("select IDENT_CURRENT('Stickers')")
+            .ExecuteScalar();
+        Assert.AreEqual(50m, ic);
+    }
+}

SqlServerSimulator.Tests.EFCore/TestDbContext.cs

@@ -111,6 +111,36 @@ internal class Product
     public decimal? Discount { get; set; }
 }
 
+/// <summary>
+/// Exercises the simulator's <c>IDENTITY</c> column support through EF Core.
+/// EF Core defaults int primary keys to <c>ValueGeneratedOnAdd</c>; with the
+/// SqlServer provider this means the column is created with <c>IDENTITY(1, 1)</c>
+/// and SaveChanges expects the database to generate the key on insert.
+/// </summary>
+internal class Widget
+{
+    public int Id { get; set; }
+
+    [Column(TypeName = "nvarchar(50)")]
+    public string Name { get; set; } = null!;
+}
+
+/// <summary>
+/// Counterpart to <see cref="Widget"/> with <see cref="DatabaseGeneratedOption.None"/>
+/// — EF Core treats <see cref="Id"/> as caller-supplied, so SaveChanges
+/// emits a plain INSERT (no <c>OUTPUT INSERTED</c>). Combined with
+/// <c>SET IDENTITY_INSERT Stickers ON</c>, the path exercises the
+/// simulator's identity-column INSERT through EF Core.
+/// </summary>
+internal class Sticker
+{
+    [DatabaseGenerated(DatabaseGeneratedOption.None)]
+    public int Id { get; set; }
+
+    [Column(TypeName = "nvarchar(20)")]
+    public string Tag { get; set; } = null!;
+}
+
 internal class TestDbContext(Simulation simulation) : DbContext
 {
     public Simulation Simulation { get; set; } = simulation;
@@ -135,6 +165,10 @@ protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
 
     public DbSet<Product> Products => Set<Product>();
 
+    public DbSet<Widget> Widgets => Set<Widget>();
+
+    public DbSet<Sticker> Stickers => Set<Sticker>();
+
     public static Simulation CreateDefaultSimulation(params ReadOnlySpan<int> values)
     {
         var simulation = new Simulation();
@@ -209,6 +243,36 @@ Discount decimal(5, 4) null
         return simulation;
     }
 
+    public static Simulation CreateWidgetsSimulation()
+    {
+        var simulation = new Simulation();
+        _ = simulation
+            .CreateOpenConnection()
+            .CreateCommand("""
+                create table Widgets (
+                    Id int identity(1, 1) not null,
+                    Name nvarchar(50) not null
+                )
+                """)
+            .ExecuteNonQuery();
+        return simulation;
+    }
+
+    public static Simulation CreateStickersSimulation()
+    {
+        var simulation = new Simulation();
+        _ = simulation
+            .CreateOpenConnection()
+            .CreateCommand("""
+                create table Stickers (
+                    Id int identity(1, 1) not null,
+                    Tag nvarchar(20) not null
+                )
+                """)
+            .ExecuteNonQuery();
+        return simulation;
+    }
+
     public static Simulation CreateEventsSimulation()
     {
         var simulation = new Simulation();