Implemented PRIMARY KEY and UNIQUE constraints.

Author: RyanLamansky

CLAUDE.md

@@ -81,4 +81,6 @@ Heavy-hitters someone might assume work but don't. Source and `git log` are the
 - `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.
+- `PRIMARY KEY` / `UNIQUE` on a computed column. SQL Server allows it (silently persisting the values for the underlying index); the simulator throws `NotSupportedException` because the enforcement loop would need to evaluate the computed expression against every existing row at insert time. Auto-generated constraint names use a deterministic FNV-1a hash for the 16-hex suffix, not SQL Server's object-id-derived hex — same shape, stable across runs but won't byte-match a real-server reproduction. PK/UNIQUE enforcement is a linear scan over the heap (O(N) per insert); no B-tree backing yet.
+- `NOT NULL` enforcement at INSERT. The column-level flag exists and CREATE TABLE rejects misuse (e.g. `IDENTITY` on a nullable column, `PRIMARY KEY` on an explicitly nullable column), but a plain `insert into t (notnullcol) values (null)` doesn't raise Msg 515 today.
 - Heap allocation tracking (IAM/PFS): the page list is flat.

SqlServerSimulator.Tests.EFCore/EFCorePrimaryKey.cs

@@ -0,0 +1,59 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Exercises the simulator's PRIMARY KEY constraint enforcement through EF
+/// Core. The duplicate-key path surfaces as <see cref="DbUpdateException"/>
+/// whose inner is the simulator's Msg 2627 — the same shape EF Core's
+/// SqlServer provider produces against a real database.
+/// </summary>
+[TestClass]
+public class EFCorePrimaryKey
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    [TestMethod]
+    public void SaveChanges_FirstRow_RoundTripsThroughPrimaryKey()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateInventorySimulation());
+
+        _ = context.Inventory.Add(new Inventory { Sku = "WIDGET-A", Quantity = 7 });
+        _ = context.SaveChanges();
+
+        var fetched = context.Inventory.AsNoTracking().Single();
+        Assert.AreEqual("WIDGET-A", fetched.Sku);
+        Assert.AreEqual(7, fetched.Quantity);
+    }
+
+    [TestMethod]
+    public void SaveChanges_DuplicateKey_RaisesDbUpdateException()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateInventorySimulation());
+
+        _ = context.Inventory.Add(new Inventory { Sku = "WIDGET-A", Quantity = 1 });
+        _ = context.SaveChanges();
+
+        using var context2 = new TestDbContext(context.Simulation);
+        _ = context2.Inventory.Add(new Inventory { Sku = "WIDGET-A", Quantity = 99 });
+        var ex = Assert.Throws<DbUpdateException>(() => context2.SaveChanges());
+        Assert.IsNotNull(ex.InnerException);
+        Assert.Contains("PRIMARY KEY constraint 'pk_inventory'", ex.InnerException.Message);
+        Assert.Contains("WIDGET-A", ex.InnerException.Message);
+    }
+
+    [TestMethod]
+    public async Task SaveChangesAsync_DuplicateKey_RaisesDbUpdateException()
+    {
+        await using var context = new TestDbContext(TestDbContext.CreateInventorySimulation());
+
+        _ = context.Inventory.Add(new Inventory { Sku = "BOLT-7", Quantity = 1 });
+        _ = await context.SaveChangesAsync(this.TestContext.CancellationToken);
+
+        await using var context2 = new TestDbContext(context.Simulation);
+        _ = context2.Inventory.Add(new Inventory { Sku = "BOLT-7", Quantity = 2 });
+        var ex = await Assert.ThrowsAsync<DbUpdateException>(() => context2.SaveChangesAsync(this.TestContext.CancellationToken));
+        Assert.IsNotNull(ex.InnerException);
+        Assert.Contains("PRIMARY KEY constraint 'pk_inventory'", ex.InnerException.Message);
+    }
+}

SqlServerSimulator.Tests.EFCore/TestDbContext.cs

@@ -183,6 +183,21 @@ internal class Receipt
     public decimal Total { get; set; }
 }
 
+/// <summary>
+/// Exercises the simulator's PRIMARY KEY constraint through EF Core.
+/// <see cref="Sku"/> is the caller-supplied PK; SaveChanges round-trips
+/// through a normal INSERT. A duplicate-key insert surfaces as a wrapped
+/// <see cref="DbUpdateException"/> whose
+/// inner exception is the simulator's Msg 2627.
+/// </summary>
+internal class Inventory
+{
+    [Column(TypeName = "nvarchar(50)")]
+    public string Sku { get; set; } = null!;
+
+    public int Quantity { get; set; }
+}
+
 /// <summary>
 /// Counterpart to <see cref="Widget"/> with <see cref="DatabaseGeneratedOption.None"/>
 /// — EF Core treats <see cref="Id"/> as caller-supplied, so SaveChanges
@@ -230,6 +245,10 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
         _ = modelBuilder.Entity<Receipt>()
             .Property(r => r.Total)
             .HasComputedColumnSql("[Subtotal] + [Tax]", stored: false);
+
+        // Pin Inventory's caller-supplied string PK so EF Core doesn't try
+        // to generate values for it.
+        _ = modelBuilder.Entity<Inventory>().HasKey(i => i.Sku);
     }
 
     public DbSet<TestRow> Rows => Set<TestRow>();
@@ -252,6 +271,8 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
 
     public DbSet<Receipt> Receipts => Set<Receipt>();
 
+    public DbSet<Inventory> Inventory => Set<Inventory>();
+
     public static Simulation CreateDefaultSimulation(params ReadOnlySpan<int> values)
     {
         var simulation = new Simulation();
@@ -390,6 +411,21 @@ Total as Subtotal + Tax
         return simulation;
     }
 
+    public static Simulation CreateInventorySimulation()
+    {
+        var simulation = new Simulation();
+        _ = simulation
+            .CreateOpenConnection()
+            .CreateCommand("""
+                create table Inventory (
+                    Sku nvarchar(50) not null constraint pk_inventory primary key,
+                    Quantity int not null
+                )
+                """)
+            .ExecuteNonQuery();
+        return simulation;
+    }
+
     public static Simulation CreateStickersSimulation()
     {
         var simulation = new Simulation();