Added explicit-transaction support (Bundle 2 of the transactions arc): DbConnection.BeginTransaction() now spans statements with real Commit / Rollback / dispose-rollback semantics, plus SAVE TRANSACTION / ROLLBACK TRANSACTION <name> SQL parsing for EF Core 10's per-SaveChanges savepoint pattern.

Author: RyanLamansky

CLAUDE.md

@@ -196,14 +196,18 @@ Per-type keyword compatibility mirrors SQL Server (verified against Kardax7 2026
 - `CHECK`: inline single-column and table-level forms; Msg 547 per row on definitely-false predicate.
 - `PRIMARY KEY` / `UNIQUE`: linear scan (O(N) per insert); no B-tree backing.
 
-### Transactions (statement-level atomicity, Bundle 1)
-Auto-commit-mode statement atomicity: a single INSERT / UPDATE / DELETE / MERGE that throws mid-execution rolls back its partial writes. A multi-row INSERT whose third row violates a constraint leaves zero rows behind, not two. Probe-confirmed against SQL Server 2025 (2026-05-08).
+### Transactions
+Three layers, each landed in its own bundle:
 
-`Storage/UndoLog.cs` records heap mutations as a row-level LIFO list (`(Heap, UndoKind, pageIdx, slotIdx)` tuples). `Heap.Insert` / `Heap.DeleteAt` take an optional log; on success they append. `Simulation.RunMutation` wraps each mutation statement: install a fresh log on `ParserContext.CurrentUndoLog`, run the body, on exception walk the log backwards (insert → tombstone slot, delete → clear tombstone) before re-raising.
+**Bundle 1 — statement-level atomicity** (auto-commit). A single INSERT / UPDATE / DELETE / MERGE that throws mid-execution rolls back its partial writes. A multi-row INSERT whose third row violates a constraint leaves zero rows behind, not two. Probe-confirmed against SQL Server 2025 (2026-05-08).
 
-Identity counters and the database-scoped rowversion counter intentionally bypass the log — probe-confirmed: both keep advancing even when their consuming inserts are rolled back. LOB chains allocated for rolled-back inserts also bypass the log; they leak the same way committed deletes leak (existing quirk).
+**Bundle 2 — explicit transactions via SqlClient API** + savepoints. `DbConnection.BeginTransaction()` returns a `SimulatedDbTransaction` with a real cross-statement undo log. `Commit()` discards the log; `Rollback()` walks it backwards. Disposing the transaction without an explicit Commit / Rollback auto-rolls-back (mirrors `SqlTransaction`). Parallel transactions on the same connection raise `InvalidOperationException` ("SqlConnection does not support parallel transactions.") matching SqlClient. `SAVE TRAN[SACTION] <name>` / `ROLLBACK TRAN[SACTION] <name>` SQL is parsed (the EF Core 10 SaveChanges-inside-tx path emits these around each save). Names are case-insensitive identifiers; re-saving a name overwrites the prior marker.
 
-Explicit transactions (`Database.BeginTransaction()`, `BEGIN TRANSACTION` / `COMMIT` / `ROLLBACK` SQL) aren't yet wired through. `BeginTransaction` returns a `SimulatedDbTransaction` whose `Commit()` is a no-op and whose `Rollback()` still throws `NotImplementedException`. Bundle 2 will lift the log to a per-connection lifetime spanning multiple statements; Bundle 3 will add SQL-text BEGIN / COMMIT / ROLLBACK and TRANCOUNT semantics.
+`Storage/UndoLog.cs` is a row-level LIFO list (`(Heap, UndoKind, pageIdx, slotIdx)` tuples) with a `Position` / `RollbackTo(position)` marker pattern. Statement-level rollback uses position-at-statement-start as the marker; an explicit transaction's full rollback uses position 0; a savepoint rollback uses the position recorded when SAVE TRANSACTION ran. `Heap.Insert` / `Heap.DeleteAt` take an optional log; on success they append. `Simulation.RunMutation` wraps each mutation statement: route to the connection's active-transaction log when one exists (Bundle 2 path) or create a fresh per-statement log (Bundle 1 path), capture marker, on exception `RollbackTo(marker)` before re-raising.
+
+A failed statement inside an explicit transaction leaves the surrounding tx alive — only the failed statement's own writes are unwound (probe-confirmed, EF Core 10 relies on this for its mid-batch SaveChanges-failure recovery path).
+
+Identity counters and the database-scoped rowversion counter intentionally bypass the log — both keep advancing even when their consuming inserts are rolled back. LOB chains allocated for rolled-back inserts also bypass the log; they leak the same way committed deletes leak.
 
 ### UPDATE / DELETE
 - `UPDATE table SET col = expr [, col = expr]* [WHERE pred]` and `DELETE [FROM] table [WHERE pred]`.
@@ -255,7 +259,7 @@ Type-metadata accessors (`GetDataTypeName` / `GetFieldType`) read from `Simulate
 
 ## Not modeled
 
-- Explicit transactions across statements (Bundle 2): `Database.BeginTransaction()` returns a `SimulatedDbTransaction` whose `Commit()` is a no-op and whose `Rollback()` throws `NotImplementedException`. SQL-text `BEGIN TRANSACTION` / `COMMIT` / `ROLLBACK` (Bundle 3) and TRANCOUNT semantics. Savepoints (`SAVE TRANSACTION` / `ROLLBACK TRANSACTION sp`). Locks / MVCC / isolation levels.
+- SQL-text `BEGIN TRANSACTION` / `COMMIT` / `ROLLBACK` (Bundle 3, optional — EF Core uses SqlClient's API instead, so this is hand-written-SQL fidelity only) and TRANCOUNT-based nesting semantics. `ROLLBACK TRANSACTION` without a savepoint name (full-tx rollback as SQL text). Locks / MVCC / isolation levels.
 - `RIGHT JOIN` (rewrite as LEFT with sources swapped); `FULL OUTER JOIN`. Both raise `NotSupportedException` at parse.
 - Comma-separated FROM (legacy ANSI-89 join syntax).
 - Plain derived tables in FROM (without APPLY) don't see outer scope — they execute eagerly at parse time. Lateral access requires `CROSS APPLY` / `OUTER APPLY`. SQL Server actually allows derived-table-sees-outer in any FROM subquery; the gap shows up in compound shapes like `(SELECT … FROM (SELECT TOP(N) … WHERE outer.col = …) AS t)` where the inner correlation isn't expressed via APPLY.

SqlServerSimulator.Tests.EFCore/EFCoreTransaction.cs

@@ -0,0 +1,106 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// End-to-end tests for EF Core 10's <c>Database.BeginTransaction</c> path.
+/// Probe-confirmed against SQL Server 2025: EF wraps SaveChanges through
+/// SqlClient's transaction API (not raw <c>BEGIN TRANSACTION</c> SQL), so
+/// the simulator's connection-scoped <see cref="Storage.UndoLog"/> handles
+/// the entire transaction lifecycle. Bundle 1 already covered statement-
+/// level atomicity; Bundle 2 adds the cross-statement transaction scope.
+/// </summary>
+[TestClass]
+public class EFCoreTransaction
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    [TestMethod]
+    public void Database_BeginTransaction_Commit_PersistsAcrossSaveChanges()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateAuthorsSimulation());
+        using var tx = context.Database.BeginTransaction();
+
+        _ = context.Authors.Add(new Author { Name = "alice" });
+        _ = context.SaveChanges();
+        _ = context.Books.Add(new Book { AuthorId = 1, Title = "B1", Score = 10 });
+        _ = context.SaveChanges();
+
+        tx.Commit();
+
+        Assert.AreEqual(1, context.Authors.AsNoTracking().Count());
+        Assert.AreEqual(1, context.Books.AsNoTracking().Count());
+    }
+
+    [TestMethod]
+    public void Database_BeginTransaction_Rollback_UndoesAcrossSaveChanges()
+    {
+        using var context = new TestDbContext(TestDbContext.CreateAuthorsSimulation());
+        using (var tx = context.Database.BeginTransaction())
+        {
+            _ = context.Authors.Add(new Author { Name = "alice" });
+            _ = context.SaveChanges();
+            _ = context.Books.Add(new Book { AuthorId = 1, Title = "B1", Score = 10 });
+            _ = context.SaveChanges();
+            tx.Rollback();
+        }
+
+        // Both saves rolled back together.
+        Assert.AreEqual(0, context.Authors.AsNoTracking().Count());
+        Assert.AreEqual(0, context.Books.AsNoTracking().Count());
+    }
+
+    [TestMethod]
+    public void SaveChangesFailure_InsideTx_LeavesTxAliveAndCommitable()
+    {
+        // Probe-confirmed shape: a SaveChanges that hits a constraint
+        // mid-batch (rolled back via the EF-emitted ROLLBACK TRANSACTION
+        // savepoint) leaves the surrounding transaction alive. The user
+        // can continue with more SaveChanges or commit what survived.
+        var simulation = TestDbContext.CreateAuthorsSimulation();
+        // Pre-seed via raw SQL so we have a key to collide with.
+        _ = simulation.CreateOpenConnection()
+            .CreateCommand("set identity_insert Authors on; insert into Authors (Id, Name) values (1, 'alice'); set identity_insert Authors off;")
+            .ExecuteNonQuery();
+
+        using var context = new TestDbContext(simulation);
+        using var tx = context.Database.BeginTransaction();
+
+        // Bob saves successfully (auto-Id=2).
+        _ = context.Authors.Add(new Author { Name = "bob" });
+        _ = context.SaveChanges();
+
+        // Force a duplicate-PK collision against the pre-seeded alice (Id=1).
+        var dup = new Author { Id = 1, Name = "duplicate" };
+        _ = context.Authors.Add(dup);
+        _ = Assert.Throws<DbUpdateException>(() => context.SaveChanges());
+        context.Entry(dup).State = EntityState.Detached;
+
+        // Tx alive — commit succeeds; bob's pre-failure save survives.
+        tx.Commit();
+
+        var names = context.Authors.AsNoTracking().Select(a => a.Name).OrderBy(n => n).ToArray();
+        CollectionAssert.AreEqual(new[] { "alice", "bob" }, names);
+    }
+
+    [TestMethod]
+    public void Using_TxDisposedWithoutCommit_AutoRollsBack()
+    {
+        // The classic "exception before tx.Commit()" pattern: the using-block
+        // disposes the tx, which auto-rolls-back since neither Commit nor
+        // Rollback ran.
+        using var context = new TestDbContext(TestDbContext.CreateAuthorsSimulation());
+        try
+        {
+            using var tx = context.Database.BeginTransaction();
+            _ = context.Authors.Add(new Author { Name = "alice" });
+            _ = context.SaveChanges();
+            throw new InvalidOperationException("simulated failure pre-commit");
+        }
+        catch (InvalidOperationException)
+        {
+        }
+
+        Assert.AreEqual(0, context.Authors.AsNoTracking().Count());
+    }
+}

SqlServerSimulator.Tests/ExplicitTransactionTests.cs

@@ -0,0 +1,218 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for explicit transactions opened via <c>DbConnection.BeginTransaction()</c>
+/// — the SqlClient API EF Core 10's <c>Database.BeginTransaction()</c> uses.
+/// Confirms a connection-scoped <see cref="Storage.UndoLog"/> spans multiple
+/// statements, that <c>Commit()</c> persists everything and <c>Rollback()</c>
+/// undoes everything, and that a failed statement within a transaction only
+/// undoes its own writes (the surrounding transaction stays alive — probe-
+/// confirmed against SQL Server 2025).
+/// </summary>
+[TestClass]
+public sealed class ExplicitTransactionTests
+{
+    private static int CountRows(DbConnection conn, string table) =>
+        (int)conn.CreateCommand($"select count(*) from {table}").ExecuteScalar()!;
+
+    private static DbConnection NewSeededConnection()
+    {
+        var conn = new Simulation().CreateOpenConnection();
+        _ = conn.CreateCommand("create table t (id int primary key, val int)").ExecuteNonQuery();
+        return conn;
+    }
+
+    /// <summary>
+    /// Runs <paramref name="sql"/> as a non-query bound to <paramref name="tx"/>.
+    /// Keeps the test bodies focused on what's being executed rather than on
+    /// the four-line ceremony of building a tx-bound DbCommand.
+    /// </summary>
+    private static void RunInTx(DbConnection conn, DbTransaction tx, string sql)
+    {
+        using var cmd = conn.CreateCommand();
+        cmd.Transaction = tx;
+        cmd.CommandText = sql;
+        _ = cmd.ExecuteNonQuery();
+    }
+
+    [TestMethod]
+    public void Commit_PersistsAllWritesAcrossMultipleStatements()
+    {
+        using var conn = NewSeededConnection();
+        using var tx = conn.BeginTransaction();
+        RunInTx(conn, tx, "insert into t values (1, 10)");
+        RunInTx(conn, tx, "insert into t values (2, 20)");
+        tx.Commit();
+        AreEqual(2, CountRows(conn, "t"));
+    }
+
+    [TestMethod]
+    public void Rollback_UndoesAllWritesAcrossMultipleStatements()
+    {
+        using var conn = NewSeededConnection();
+        using var tx = conn.BeginTransaction();
+        RunInTx(conn, tx, "insert into t values (1, 10)");
+        RunInTx(conn, tx, "insert into t values (2, 20)");
+        tx.Rollback();
+        AreEqual(0, CountRows(conn, "t"));
+    }
+
+    [TestMethod]
+    public void OwnTransactionSeesOwnWrites_BeforeCommit()
+    {
+        using var conn = NewSeededConnection();
+        using var tx = conn.BeginTransaction();
+        RunInTx(conn, tx, "insert into t values (42, 100)");
+
+        using var sel = conn.CreateCommand();
+        sel.Transaction = tx;
+        sel.CommandText = "select count(*) from t";
+        AreEqual(1, sel.ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void StatementFailureWithinTx_LeavesTxAlive_OnlyOwnWritesUndone()
+    {
+        // Probe-confirmed: a statement that fails inside an explicit transaction
+        // rolls back ONLY its own writes; subsequent statements still run; commit
+        // persists the surviving (pre-failure + post-failure-success) writes.
+        using var conn = NewSeededConnection();
+        using var tx = conn.BeginTransaction();
+        RunInTx(conn, tx, "insert into t values (1, 10)");
+
+        // Mid-tx failure: PK collision against the just-inserted row.
+        _ = Throws<DbException>(() => RunInTx(conn, tx, "insert into t values (1, 99)"));
+
+        // Tx alive — third statement still works.
+        RunInTx(conn, tx, "insert into t values (3, 30)");
+        tx.Commit();
+
+        var rows = new List<(int, int)>();
+        using var reader = conn.CreateCommand("select id, val from t order by id").ExecuteReader();
+        while (reader.Read())
+            rows.Add((reader.GetInt32(0), reader.GetInt32(1)));
+        CollectionAssert.AreEqual(new[] { (1, 10), (3, 30) }, rows);
+    }
+
+    [TestMethod]
+    public void Dispose_WithoutCommit_AutoRollsBack()
+    {
+        // SqlClient's SqlTransaction auto-rolls-back on dispose if neither
+        // Commit nor Rollback ran. Mirrors `using var tx = ...; ... tx.Commit();`
+        // where an early exception path leaves dispose to do the rollback.
+        using var conn = NewSeededConnection();
+        {
+            using var tx = conn.BeginTransaction();
+            RunInTx(conn, tx, "insert into t values (1, 10)");
+            // Drop out of scope without committing.
+        }
+        AreEqual(0, CountRows(conn, "t"));
+    }
+
+    [TestMethod]
+    public void ParallelBeginTransaction_RaisesInvalidOperation()
+    {
+        // SqlClient: "SqlConnection does not support parallel transactions."
+        using var conn = NewSeededConnection();
+        using var tx1 = conn.BeginTransaction();
+        _ = Throws<InvalidOperationException>(() => _ = conn.BeginTransaction());
+    }
+
+    [TestMethod]
+    public void Commit_AfterCommit_RaisesInvalidOperation()
+    {
+        using var conn = NewSeededConnection();
+        var tx = conn.BeginTransaction();
+        tx.Commit();
+        _ = Throws<InvalidOperationException>(tx.Commit);
+    }
+
+    [TestMethod]
+    public void Rollback_AfterCommit_RaisesInvalidOperation()
+    {
+        using var conn = NewSeededConnection();
+        var tx = conn.BeginTransaction();
+        tx.Commit();
+        _ = Throws<InvalidOperationException>(tx.Rollback);
+    }
+
+    [TestMethod]
+    public void NewTransaction_AfterCommit_Allowed()
+    {
+        // Once committed, the connection is free to begin a fresh transaction.
+        using var conn = NewSeededConnection();
+        var tx1 = conn.BeginTransaction();
+        RunInTx(conn, tx1, "insert into t values (1, 10)");
+        tx1.Commit();
+
+        var tx2 = conn.BeginTransaction();
+        RunInTx(conn, tx2, "insert into t values (2, 20)");
+        tx2.Rollback();
+
+        AreEqual(1, CountRows(conn, "t"));
+    }
+
+    [TestMethod]
+    public void Savepoint_RollbackToName_UndoesOnlyPostSavepointWrites()
+    {
+        // SAVE TRANSACTION + ROLLBACK TRANSACTION savepoint_name partial
+        // rollback. EF Core 10 emits this around each SaveChanges within
+        // a Database.BeginTransaction so a failed save undoes only its
+        // own writes while the surrounding transaction stays alive.
+        using var conn = NewSeededConnection();
+        using var tx = conn.BeginTransaction();
+        RunInTx(conn, tx, "insert into t values (1, 10)");
+        RunInTx(conn, tx, "save transaction sp1");
+        RunInTx(conn, tx, "insert into t values (2, 20)");
+        RunInTx(conn, tx, "insert into t values (3, 30)");
+        RunInTx(conn, tx, "rollback transaction sp1");
+        tx.Commit();
+
+        var rows = new List<(int, int)>();
+        using var reader = conn.CreateCommand("select id, val from t order by id").ExecuteReader();
+        while (reader.Read())
+            rows.Add((reader.GetInt32(0), reader.GetInt32(1)));
+        CollectionAssert.AreEqual(new[] { (1, 10) }, rows);
+    }
+
+    [TestMethod]
+    public void Savepoint_AcceptsTranAbbreviation()
+    {
+        // SAVE TRAN / ROLLBACK TRAN are interchangeable with TRANSACTION.
+        using var conn = NewSeededConnection();
+        using var tx = conn.BeginTransaction();
+        RunInTx(conn, tx, "insert into t values (1, 10)");
+        RunInTx(conn, tx, "save tran sp1");
+        RunInTx(conn, tx, "insert into t values (2, 20)");
+        RunInTx(conn, tx, "rollback tran sp1");
+        tx.Commit();
+
+        AreEqual(1, CountRows(conn, "t"));
+    }
+
+    [TestMethod]
+    public void Rollback_RestoresExistingRows_NotJustNewOnes()
+    {
+        // A transaction that updates and deletes existing rows must restore
+        // them on rollback. UPDATE = delete-old + insert-new, so each affected
+        // row produces two log entries — undo unwinds both halves.
+        using var conn = NewSeededConnection();
+        _ = conn.CreateCommand("insert into t values (1, 10), (2, 20), (3, 30)").ExecuteNonQuery();
+
+        using (var tx = conn.BeginTransaction())
+        {
+            RunInTx(conn, tx, "update t set val = val * 10 where id <= 2");
+            RunInTx(conn, tx, "delete from t where id = 3");
+            tx.Rollback();
+        }
+
+        var rows = new List<(int, int)>();
+        using var reader = conn.CreateCommand("select id, val from t order by id").ExecuteReader();
+        while (reader.Read())
+            rows.Add((reader.GetInt32(0), reader.GetInt32(1)));
+        CollectionAssert.AreEqual(new[] { (1, 10), (2, 20), (3, 30) }, rows);
+    }
+}