Locking phase 1b — row-level Shared / Update / Exclusive data locks with the full SQL Server 8-mode matrix (Sch-S / Sch-M / IS / IX / SIX / S / U / X), SET TRANSACTION ISOLATION LEVEL session-state with semantic effect, row-lock escalation at 5000 per-tx per-table, and the UPDLOCK / XLOCK / READPAST / TABLOCK / TABLOCKX hint surface. LockMode extended to 8 entries; LockManager.IsCompatible rewritten as the standard SQL Server matrix (IS × {IS, IX, SIX, S, U} compatible / IS × X conflict; IX × IX compatible / IX × {S, U, SIX} conflict; SIX × IS only; S × {S, U, IS} compatible / S × {U, X, IX, SIX} … wait the real matrix has S × U compatible). New HeapTable.RowLocks (ConcurrentDictionary<(int pageIndex, int slotIndex), LockResource>) holds lazily-interned per-row resources keyed by RID; new HeapTable.TableDataLock is the table-level data lock (IS/IX/SIX/S/U/X), distinct from the inherited SchemaObject.SchemaLock which still carries only Sch-S / Sch-M. New DataLockPlan struct (returned by the refactored BatchContext.AcquireDataLockIfApplicable) encodes the per-row strategy for the caller to execute during iteration / mutation: row mode (S / U / X / null-probe-only / null-skip-noLock), tx-scoping, READPAST flag. Heap.Insert API change from void to (int PageIndex, int SlotIndex) return so DML sites can attach row-X to the freshly-inserted row's RID; 11 call sites updated (4 DML write sites capture and acquire row-X tx-scoped; 7 internal / history-table / constraint-cascade / system-table-init / TVP-clone / SELECT-INTO sites discard with _ =). BatchContext.AcquireRowLockTxScoped(table, page, slot, mode) is the central row-level acquire that bumps SimulatedDbTransaction.RowLockCountsByTable and triggers escalation when the per-table count crosses RowLockEscalationThreshold (5000, matching real SQL Server's documented default) — EscalateToTableX acquires the table-X first (may throw on timeout / cycle, leaves partial state consistent), then releases every row-lock entry on the escalated table from tx.HeldLocks, then marks the table in tx.EscalatedTables so future per-row acquires short-circuit. BatchContext.TouchRowForRead(table, page, slot, plan) is the reader's per-row helper: NoLockReader = no probe; non-null RowMode = acquire that mode tx-scoped (for HOLDLOCK / RR / UPDLOCK / XLOCK); else probe-only (RC default — LockManager.HasIncompatibleHolderOtherThan + transient acquire-release row-S on conflict matching real SQL Server's "wait for committed row" pattern). BatchContext.WrapWithRowConflictChecks wraps Heap.EnumerateRowsWithAddress into the FromSource.Rows enumerable so each yielded row flows through the touch helper; READPAST returns false from TouchRowForRead so the wrapper skips the row instead of yielding it. Selection.TableHintInfo gains UpdLock / XLock / ReadPast / TabLock / TabLockX / Serializable / Repeatable flags (split from phase-1a's combined HoldLock — HOLDLOCK / SERIALIZABLE = Serializable, REPEATABLEREAD = Repeatable since they have different semantics: SER prevents phantoms via table-S, RR doesn't). SimulatedDbConnection.SessionIsolationLevel (default ReadCommitted) gets wired through SET TRANSACTION ISOLATION LEVEL { READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SNAPSHOT | SERIALIZABLE } in Simulation.Set.cs — RU promotes every read to dirty-read (NOLOCK-equivalent), RC default, RR retains row-S tx-scoped per read row, SER takes table-S tx-scoped at scan start for phantom prevention at table granularity (the simulator's approximation of SQL Server's key-range locks since no index range structure is modeled), SNAPSHOT parses-and-discards (MVCC is phase 3). The hint-driven AcquireDataLockIfApplicable dispatch table: TABLOCKX → table-X (skip row); TABLOCK reader → table-S (tx-scoped under HOLDLOCK / RR / SER / session RR / SER); TABLOCK writer → table-X; writer default → table-IX + per-row X tx-scoped; reader XLOCK → table-IX + per-row X tx-scoped; reader UPDLOCK → table-IX + per-row U tx-scoped; reader SER hint / session SER → table-S tx-scoped (no per-row); reader RC default → table-IS + per-row probe-only; reader RR hint / session RR → table-IS + per-row S tx-scoped; table variables / local temp tables / system tables bypass everything. **Practical effect**: the phase-1a "stronger than RC" quirk is gone — a SELECT no longer blocks on any X-locked row in the table, only on the specific row being touched. Two writers on disjoint rows of the same table now proceed in parallel through table-IX + disjoint row-X. The phase-1a HoldLockHint_KeepsSUntilCommit test (which expected the HOLDLOCK hint to block a phantom-creating INSERT) now passes for the right reason: HOLDLOCK takes table-S tx-scoped instead of row-S, matching real SQL Server's documented "HOLDLOCK = SERIALIZABLE" equivalence. 6 new internal LockResourceTests (U-mode compatibility, IS-orthogonality, IX-conflict, SIX-only-with-IS, escalation past threshold) plus 9 new user-facing LockingTests (row-level RC disjoint-row independence, READPAST skip-blocked-row, UPDLOCK U-U conflict, XLOCK reader-blocking, TABLOCKX blocking, SERIALIZABLE phantom-prevention, REPEATABLE READ row-S blocks UPDATE but allows INSERT, READ UNCOMMITTED dirty read, two-writer disjoint-row parallel proceed). Phase-1a TransactionScopedX_ReleasedAtCommit / _AtRollback internal tests updated to check TableDataLock (phase 1b's table-data lock) instead of SchemaLock (which only carries Sch-S / Sch-M now). docs/claude/locking.md rewritten as the unified phases-0+1a+1b doc with the 8-mode matrix, the granularity-dispatch tables, the row-lock storage / escalation / acquisition-site documentation, and a phase-1b gaps section calling out key-range locks (table-S approximation), page-level (PAGLOCK no-op), hint-conflict detection (Msg 1047 / 1065 / 1069), sys.dm_tran_locks (phase 2), @@LOCK_TIMEOUT scalar (phase 2), SNAPSHOT / RCSI (phase 3), alias-form UPDATE / DELETE row-X (deferred), ALTER PROCEDURE / ALTER TRIGGER / ALTER SEQUENCE Sch-M wiring (deferred), row-lock cleanup on DELETE (intentional leak matching heap slot-leak pattern), history-table / cascade-FK / OUTPUT-INTO row-X (deferred). CLAUDE.md transactions bullet rewritten to describe phase-1b row-level RC + isolation-level semantic effect; Feature-reference entry expanded with all the new lock APIs; "Not modeled" rewritten — the "stronger than RC" quirk is gone, phase 1b ships substantially more than phase 1a; SimulatedDbConnection session-state listing adds SessionIsolationLevel.

Author: RyanLamansky

CLAUDE.md

@@ -204,18 +204,21 @@ public void CycleDetection_DetectorPicksRequester()
     [TestMethod]
     public void TransactionScopedX_ReleasedAtCommit()
     {
-        // Once the simulator runs a tx-scoped X acquire (via
-        // BatchContext.AcquireTransactionLock), Commit releases every
-        // entry in the tx's HeldLocks list.
+        // Once the simulator runs a tx-scoped IX-then-row-X acquire (via
+        // BatchContext.AcquireTransactionLock + AcquireRowLockTxScoped),
+        // Commit releases every entry in the tx's HeldLocks list — both
+        // the table-IX and every row-X.
         var sim = new Simulation();
         ExecuteNonQuery(sim, "create table t (id int)");
         using var conn = sim.CreateDbConnection();
         conn.Open();
-        var schemaLock = ((SimulatedDbConnection)conn).CurrentDatabase.Schemas["dbo"].HeapTables["t"].SchemaLock;
+        var table = ((SimulatedDbConnection)conn).CurrentDatabase.Schemas["dbo"].HeapTables["t"];
         ExecuteNonQuery(conn, "begin tran; insert t values (1)");
-        IsNotEmpty(schemaLock.Holders);
+        IsNotEmpty(table.TableDataLock.Holders);
         ExecuteNonQuery(conn, "commit tran");
-        IsEmpty(schemaLock.Holders);
+        IsEmpty(table.TableDataLock.Holders);
+        foreach (var (_, resource) in table.RowLocks)
+            IsEmpty(resource.Holders);
     }
 
     [TestMethod]
@@ -225,9 +228,11 @@ public void TransactionScopedX_ReleasedAtRollback()
         ExecuteNonQuery(sim, "create table t (id int)");
         using var conn = sim.CreateDbConnection();
         conn.Open();
-        var schemaLock = ((SimulatedDbConnection)conn).CurrentDatabase.Schemas["dbo"].HeapTables["t"].SchemaLock;
+        var table = ((SimulatedDbConnection)conn).CurrentDatabase.Schemas["dbo"].HeapTables["t"];
         ExecuteNonQuery(conn, "begin tran; insert t values (1); rollback tran");
-        IsEmpty(schemaLock.Holders);
+        IsEmpty(table.TableDataLock.Holders);
+        foreach (var (_, resource) in table.RowLocks)
+            IsEmpty(resource.Holders);
     }
 
     private static void ExecuteNonQuery(Simulation sim, string sql)
@@ -285,4 +290,126 @@ public void SetLockTimeout_Zero_UpdatesConnectionState()
         _ = cmd.ExecuteNonQuery();
         AreEqual(0, ((SimulatedDbConnection)conn).LockTimeoutMillis);
     }
+
+    [TestMethod]
+    public void U_CompatibleWith_S_IS()
+    {
+        // U × S: compatible (read-with-intent-to-upgrade coexists with
+        // plain readers). U × IS: compatible (the IS holder might be
+        // a different child of the same parent).
+        var sim = new Simulation();
+        var resource = new LockResource();
+        var a = (SimulatedDbConnection)sim.CreateDbConnection();
+        var b = (SimulatedDbConnection)sim.CreateDbConnection();
+        sim.LockManager.Acquire(resource, LockMode.Shared, a, 0);
+        sim.LockManager.Acquire(resource, LockMode.Update, b, 0);
+        sim.LockManager.Release(resource, LockMode.Update, b);
+        sim.LockManager.Release(resource, LockMode.Shared, a);
+        sim.LockManager.Acquire(resource, LockMode.IntentShared, a, 0);
+        sim.LockManager.Acquire(resource, LockMode.Update, b, 0);
+        sim.LockManager.Release(resource, LockMode.Update, b);
+        sim.LockManager.Release(resource, LockMode.IntentShared, a);
+    }
+
+    [TestMethod]
+    public void U_ConflictsWith_U_X_IX_SIX()
+    {
+        var sim = new Simulation();
+        var a = (SimulatedDbConnection)sim.CreateDbConnection();
+        var b = (SimulatedDbConnection)sim.CreateDbConnection();
+        a.CurrentExecutingThreadId = -1;
+        foreach (var conflict in new[] { LockMode.Update, LockMode.Exclusive, LockMode.IntentExclusive, LockMode.SharedIntentExclusive })
+        {
+            var resource = new LockResource();
+            sim.LockManager.Acquire(resource, LockMode.Update, a, 0);
+            _ = Throws<DbException>(() => sim.LockManager.Acquire(resource, conflict, b, 0));
+            sim.LockManager.Release(resource, LockMode.Update, a);
+        }
+    }
+
+    [TestMethod]
+    public void IS_CompatibleWithEverythingExceptX()
+    {
+        var sim = new Simulation();
+        var a = (SimulatedDbConnection)sim.CreateDbConnection();
+        var b = (SimulatedDbConnection)sim.CreateDbConnection();
+        a.CurrentExecutingThreadId = -1;
+        foreach (var ok in new[] { LockMode.IntentShared, LockMode.IntentExclusive, LockMode.SharedIntentExclusive, LockMode.Shared, LockMode.Update })
+        {
+            var resource = new LockResource();
+            sim.LockManager.Acquire(resource, LockMode.IntentShared, a, 0);
+            sim.LockManager.Acquire(resource, ok, b, 0);
+            sim.LockManager.Release(resource, ok, b);
+            sim.LockManager.Release(resource, LockMode.IntentShared, a);
+        }
+        // IS × X: conflict.
+        var rx = new LockResource();
+        sim.LockManager.Acquire(rx, LockMode.IntentShared, a, 0);
+        _ = Throws<DbException>(() => sim.LockManager.Acquire(rx, LockMode.Exclusive, b, 0));
+        sim.LockManager.Release(rx, LockMode.IntentShared, a);
+    }
+
+    [TestMethod]
+    public void IX_ConflictsWith_S_U_SIX_X()
+    {
+        var sim = new Simulation();
+        var a = (SimulatedDbConnection)sim.CreateDbConnection();
+        var b = (SimulatedDbConnection)sim.CreateDbConnection();
+        a.CurrentExecutingThreadId = -1;
+        foreach (var conflict in new[] { LockMode.Shared, LockMode.Update, LockMode.SharedIntentExclusive, LockMode.Exclusive })
+        {
+            var resource = new LockResource();
+            sim.LockManager.Acquire(resource, LockMode.IntentExclusive, a, 0);
+            _ = Throws<DbException>(() => sim.LockManager.Acquire(resource, conflict, b, 0));
+            sim.LockManager.Release(resource, LockMode.IntentExclusive, a);
+        }
+    }
+
+    [TestMethod]
+    public void SIX_OnlyCompatibleWith_IS()
+    {
+        var sim = new Simulation();
+        var a = (SimulatedDbConnection)sim.CreateDbConnection();
+        var b = (SimulatedDbConnection)sim.CreateDbConnection();
+        a.CurrentExecutingThreadId = -1;
+        // SIX × IS: compatible.
+        var r1 = new LockResource();
+        sim.LockManager.Acquire(r1, LockMode.SharedIntentExclusive, a, 0);
+        sim.LockManager.Acquire(r1, LockMode.IntentShared, b, 0);
+        sim.LockManager.Release(r1, LockMode.IntentShared, b);
+        sim.LockManager.Release(r1, LockMode.SharedIntentExclusive, a);
+        // SIX × everything else: conflict.
+        foreach (var conflict in new[] { LockMode.IntentExclusive, LockMode.SharedIntentExclusive, LockMode.Shared, LockMode.Update, LockMode.Exclusive })
+        {
+            var resource = new LockResource();
+            sim.LockManager.Acquire(resource, LockMode.SharedIntentExclusive, a, 0);
+            _ = Throws<DbException>(() => sim.LockManager.Acquire(resource, conflict, b, 0));
+            sim.LockManager.Release(resource, LockMode.SharedIntentExclusive, a);
+        }
+    }
+
+    [TestMethod]
+    public void RowLockEscalation_Above5000_PromotesToTableX()
+    {
+        // Insert >5000 rows in one transaction; the per-row X acquisitions
+        // bump the per-tx per-table count past the threshold, triggering
+        // promotion to a single table-X. After commit, the table-X is
+        // released and the per-row dict entries are no longer tracked
+        // against any tx.
+        var sim = new Simulation();
+        ExecuteNonQuery(sim, "create table t (id int)");
+        using var conn = sim.CreateDbConnection();
+        conn.Open();
+        var table = ((SimulatedDbConnection)conn).CurrentDatabase.Schemas["dbo"].HeapTables["t"];
+        ExecuteNonQuery(conn, "begin tran");
+        for (var i = 0; i < SimulatedDbTransaction.RowLockEscalationThreshold + 2; i++)
+            ExecuteNonQuery(conn, $"insert t values ({i})");
+        // After escalation, the active transaction holds table-X on this
+        // table; row-lock count is zeroed.
+        var tx = ((SimulatedDbConnection)conn).CurrentTransaction;
+        IsNotNull(tx);
+        Contains(table, tx.EscalatedTables);
+        ExecuteNonQuery(conn, "commit tran");
+        IsEmpty(table.TableDataLock.Holders);
+    }
 }

SqlServerSimulator.Tests.Internal/LockResourceTests.cs

@@ -23,7 +23,7 @@ public void NewHeap_HasNoPagesUntilFirstInsert()
     public void Insert_SingleRow_AllocatesFirstPage()
     {
         var heap = new Heap();
-        heap.Insert([1, 2, 3]);
+        _ = heap.Insert([1, 2, 3]);
         HasCount(1, heap.Pages);
         AreEqual(1, heap.RowCount);
     }
@@ -33,8 +33,8 @@ public void Insert_RowsExceedingPageCapacity_AllocatesSecondPageAndLinks()
     {
         var heap = new Heap();
         var big = new byte[Heap.MaxRowSize];
-        heap.Insert(big);                 // page 0 holds one max-sized row
-        heap.Insert(big);                 // forces a new page
+        _ = heap.Insert(big);                 // page 0 holds one max-sized row
+        _ = heap.Insert(big);                 // forces a new page
 
         HasCount(2, heap.Pages);
         AreEqual(1, heap.Pages[0].NextPageIndex);
@@ -57,7 +57,7 @@ public void EnumerateRows_WalksAllPagesInOrder()
             var row = new byte[512];
             row[0] = (byte)i;
             rowsInserted.Add(row);
-            heap.Insert(row);
+            _ = heap.Insert(row);
         }
 
         IsGreaterThanOrEqualTo(2, heap.Pages.Count, "Expected the heap to span at least two pages.");
@@ -84,7 +84,7 @@ public void Insert_RowAtMaxRowSize_Succeeds()
     {
         var heap = new Heap();
         var row = new byte[Heap.MaxRowSize];
-        heap.Insert(row);
+        _ = heap.Insert(row);
         AreEqual(1, heap.RowCount);
     }
 
@@ -94,9 +94,9 @@ public void RowCount_AggregatesAcrossPages()
         var heap = new Heap();
         var halfish = new byte[HeapPage.MaxRowPayload / 3];
 
-        heap.Insert(halfish);     // fits in page 0
-        heap.Insert(halfish);     // fits in page 0
-        heap.Insert(halfish);     // page 0 may or may not fit a third copy; either way row count is correct
+        _ = heap.Insert(halfish);     // fits in page 0
+        _ = heap.Insert(halfish);     // fits in page 0
+        _ = heap.Insert(halfish);     // page 0 may or may not fit a third copy; either way row count is correct
 
         AreEqual(3, heap.RowCount);