Added SQL-text BEGIN / COMMIT / ROLLBACK + TRANCOUNT-based nesting + @@TRANCOUNT (Bundle 3 of the transactions arc), wrapping up the three-bundle transaction feature.

RyanLamansky · RyanLamansky · commit de30725ddc82 · 2026-05-08T10:19:33.000-05:00
diff --git a/CLAUDE.md b/CLAUDE.md
diff --git a/SqlServerSimulator.Tests/SqlTransactionStatementTests.cs b/SqlServerSimulator.Tests/SqlTransactionStatementTests.cs
@@ -0,0 +1,167 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for SQL-text transaction control: <c>BEGIN TRANSACTION</c>,
+/// <c>COMMIT</c>, <c>ROLLBACK</c> (no savepoint), and <c>@@TRANCOUNT</c>.
+/// EF Core never emits these — it uses SqlClient's API path — so this is
+/// hand-written-SQL fidelity. Probe-confirmed against SQL Server 2025
+/// (2026-05-08): nesting via TRANCOUNT (BEGIN increments; COMMIT decrements;
+/// ROLLBACK without a savepoint name zeroes regardless of depth);
+/// COMMIT / ROLLBACK without an active tx raise Msg 3902 / 3903 verbatim.
+/// </summary>
+[TestClass]
+public sealed class SqlTransactionStatementTests
+{
+    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;
+    }
+
+    [TestMethod]
+    public void BeginCommit_PersistsWrites()
+    {
+        using var conn = NewSeededConnection();
+        _ = conn.CreateCommand("begin transaction").ExecuteNonQuery();
+        _ = conn.CreateCommand("insert into t values (1, 10)").ExecuteNonQuery();
+        _ = conn.CreateCommand("commit").ExecuteNonQuery();
+        AreEqual(1, CountRows(conn, "t"));
+    }
+
+    [TestMethod]
+    public void BeginRollback_UndoesWrites()
+    {
+        using var conn = NewSeededConnection();
+        _ = conn.CreateCommand("begin transaction").ExecuteNonQuery();
+        _ = conn.CreateCommand("insert into t values (1, 10)").ExecuteNonQuery();
+        _ = conn.CreateCommand("rollback").ExecuteNonQuery();
+        AreEqual(0, CountRows(conn, "t"));
+    }
+
+    [TestMethod]
+    public void TranCount_TracksNestingDepth()
+    {
+        using var conn = NewSeededConnection();
+        AreEqual(0, conn.CreateCommand("select @@trancount").ExecuteScalar());
+
+        _ = conn.CreateCommand("begin transaction").ExecuteNonQuery();
+        AreEqual(1, conn.CreateCommand("select @@trancount").ExecuteScalar());
+
+        _ = conn.CreateCommand("begin tran").ExecuteNonQuery();
+        AreEqual(2, conn.CreateCommand("select @@trancount").ExecuteScalar());
+
+        _ = conn.CreateCommand("commit").ExecuteNonQuery();
+        AreEqual(1, conn.CreateCommand("select @@trancount").ExecuteScalar());
+
+        _ = conn.CreateCommand("commit transaction").ExecuteNonQuery();
+        AreEqual(0, conn.CreateCommand("select @@trancount").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void NestedBeginCommit_InnerCommitDoesNotPersist()
+    {
+        // Probe-confirmed: only the outermost COMMIT actually commits.
+        // Inner COMMITs just decrement TRANCOUNT — the writes survive an
+        // outer ROLLBACK only if the OUTER level commits too. Here we
+        // inner-COMMIT then outer-ROLLBACK; everything must rollback.
+        using var conn = NewSeededConnection();
+        _ = conn.CreateCommand("begin transaction").ExecuteNonQuery();
+        _ = conn.CreateCommand("insert into t values (1, 10)").ExecuteNonQuery();
+        _ = conn.CreateCommand("begin transaction").ExecuteNonQuery();
+        _ = conn.CreateCommand("insert into t values (2, 20)").ExecuteNonQuery();
+        _ = conn.CreateCommand("commit").ExecuteNonQuery();
+        AreEqual(1, conn.CreateCommand("select @@trancount").ExecuteScalar());
+        _ = conn.CreateCommand("rollback").ExecuteNonQuery();
+        AreEqual(0, CountRows(conn, "t"));
+    }
+
+    [TestMethod]
+    public void RollbackWithoutSavepoint_WipesAllNestingLevels()
+    {
+        using var conn = NewSeededConnection();
+        _ = conn.CreateCommand("begin transaction").ExecuteNonQuery();
+        _ = conn.CreateCommand("insert into t values (1, 10)").ExecuteNonQuery();
+        _ = conn.CreateCommand("begin transaction").ExecuteNonQuery();
+        _ = conn.CreateCommand("insert into t values (2, 20)").ExecuteNonQuery();
+        _ = conn.CreateCommand("rollback").ExecuteNonQuery();
+
+        AreEqual(0, CountRows(conn, "t"));
+        AreEqual(0, conn.CreateCommand("select @@trancount").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void BeginTransaction_AcceptsName()
+    {
+        // BEGIN TRANSACTION my_tx — name is cosmetic; matches SQL Server.
+        using var conn = NewSeededConnection();
+        _ = conn.CreateCommand("begin transaction my_tx").ExecuteNonQuery();
+        AreEqual(1, conn.CreateCommand("select @@trancount").ExecuteScalar());
+        _ = conn.CreateCommand("commit transaction my_tx").ExecuteNonQuery();
+        AreEqual(0, conn.CreateCommand("select @@trancount").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void CommitWork_RollbackWork_AcceptedAsAnsiVariants()
+    {
+        using var conn = NewSeededConnection();
+        _ = conn.CreateCommand("begin transaction").ExecuteNonQuery();
+        _ = conn.CreateCommand("commit work").ExecuteNonQuery();
+        AreEqual(0, conn.CreateCommand("select @@trancount").ExecuteScalar());
+
+        _ = conn.CreateCommand("begin transaction").ExecuteNonQuery();
+        _ = conn.CreateCommand("rollback work").ExecuteNonQuery();
+        AreEqual(0, conn.CreateCommand("select @@trancount").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void Commit_WithoutActiveTx_RaisesMsg3902()
+    {
+        using var conn = NewSeededConnection();
+        var ex = Throws<DbException>(() => _ = conn.CreateCommand("commit").ExecuteNonQuery());
+        AreEqual("3902", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void Rollback_WithoutActiveTx_RaisesMsg3903()
+    {
+        using var conn = NewSeededConnection();
+        var ex = Throws<DbException>(() => _ = conn.CreateCommand("rollback").ExecuteNonQuery());
+        AreEqual("3903", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void SqlClientApi_AndSqlText_ShareTheSameTransaction()
+    {
+        // SqlClient API BeginTransaction → TRANCOUNT 1.
+        // SQL BEGIN inside → TRANCOUNT 2.
+        // SQL COMMIT → TRANCOUNT 1.
+        // API tx.Commit() → TRANCOUNT 0, persists writes.
+        using var conn = NewSeededConnection();
+        using var tx = conn.BeginTransaction();
+        AreEqual(1, conn.CreateCommand("select @@trancount").ExecuteScalar());
+
+        using var cmd = conn.CreateCommand();
+        cmd.Transaction = tx;
+        cmd.CommandText = "begin transaction";
+        _ = cmd.ExecuteNonQuery();
+        AreEqual(2, conn.CreateCommand("select @@trancount").ExecuteScalar());
+
+        cmd.CommandText = "insert into t values (1, 10)";
+        _ = cmd.ExecuteNonQuery();
+
+        cmd.CommandText = "commit";
+        _ = cmd.ExecuteNonQuery();
+        AreEqual(1, conn.CreateCommand("select @@trancount").ExecuteScalar());
+
+        tx.Commit();
+        AreEqual(0, conn.CreateCommand("select @@trancount").ExecuteScalar());
+        AreEqual(1, CountRows(conn, "t"));
+    }
+}
diff --git a/SqlServerSimulator/Parser/AtAtKeyword.cs b/SqlServerSimulator/Parser/AtAtKeyword.cs
@@ -17,5 +17,6 @@ enum AtAtKeyword
     ServiceName,
     SpId,
     TextSize,
+    TranCount,
     Version
 }
diff --git a/SqlServerSimulator/Parser/Expression.cs b/SqlServerSimulator/Parser/Expression.cs
@@ -62,9 +62,12 @@ public static Expression Parse(ParserContext context)
             Numeric number => new Value(number.Value),
             Literal literal => new Value(literal.Value),
             AtPrefixedString atPrefixed => new Value(atPrefixed, context),
-            DoubleAtPrefixedString doubleAtPrefixedString => doubleAtPrefixedString.Parse() == AtAtKeyword.Identity
-                ? new LastIdentityExpression(context.Simulation)
-                : new Value(doubleAtPrefixedString),
+            DoubleAtPrefixedString doubleAtPrefixedString => doubleAtPrefixedString.Parse() switch
+            {
+                AtAtKeyword.Identity => new LastIdentityExpression(context.Simulation),
+                AtAtKeyword.TranCount => new TranCountExpression(context),
+                _ => new Value(doubleAtPrefixedString),
+            },
             ReservedKeyword { Keyword: Keyword.Null } => new Value(),
             ReservedKeyword { Keyword: Keyword.Case } => CaseExpression.ParseCase(context),
             // LEFT, RIGHT, CONVERT, and TRY_CONVERT are reserved keywords
diff --git a/SqlServerSimulator/Parser/Expressions/TranCountExpression.cs b/SqlServerSimulator/Parser/Expressions/TranCountExpression.cs
@@ -0,0 +1,21 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// Backs <c>@@TRANCOUNT</c>: returns the connection's current transaction
+/// nesting depth as <see cref="SqlType.Int32"/>. Zero when no transaction
+/// is active; one after a single <c>BEGIN TRANSACTION</c> (or SqlClient
+/// <c>BeginTransaction()</c>); higher when nested SQL-text <c>BEGIN</c>s
+/// have been issued without matching <c>COMMIT</c>s. Probe-confirmed
+/// behavior against SQL Server 2025 (2026-05-08).
+/// </summary>
+internal sealed class TranCountExpression(ParserContext context) : Expression
+{
+    public override SqlValue Run(Func<MultiPartName, SqlValue> getColumnValue) =>
+        SqlValue.FromInt32(context.Connection.CurrentTransaction?.TranCount ?? 0);
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => SqlType.Int32;
+
+    internal override string DebugDisplay() => "@@TRANCOUNT";
+}
diff --git a/SqlServerSimulator/Parser/ParserContext.cs b/SqlServerSimulator/Parser/ParserContext.cs
@@ -123,6 +123,16 @@ private static SqlValue ConvertParameter(object? raw, SqlType type) =>
 
     public Simulation Simulation => Command.simulation;
 
+    /// <summary>
+    /// The connection backing <see cref="Command"/>. Always a
+    /// <see cref="SimulatedDbConnection"/>: <see cref="SimulatedDbCommand"/>'s
+    /// constructor takes one and the setter rejects re-assignment, so once
+    /// the command exists this cast is never wrong and never null. Used by
+    /// transaction-related parsers and <see cref="Expressions.TranCountExpression"/>
+    /// to reach the connection's <see cref="SimulatedDbConnection.CurrentTransaction"/>.
+    /// </summary>
+    public SimulatedDbConnection Connection => (SimulatedDbConnection)Command.Connection!;
+
     /// <summary>
     /// Gets the value of the variable with the provided <paramref name="name"/>.
     /// </summary>
diff --git a/SqlServerSimulator/SimulatedDbTransaction.cs b/SqlServerSimulator/SimulatedDbTransaction.cs
@@ -20,6 +20,17 @@ sealed class SimulatedDbTransaction(Simulation simulation, SimulatedDbConnection
     /// </summary>
     internal readonly UndoLog UndoLog = new();
 
+    /// <summary>
+    /// SQL Server's <c>@@TRANCOUNT</c> nesting depth. Starts at 1 when this
+    /// transaction is created (via either SqlClient API or SQL-text
+    /// <c>BEGIN TRANSACTION</c>). Each subsequent SQL-text <c>BEGIN</c>
+    /// increments it; each SQL-text <c>COMMIT</c> decrements; only when it
+    /// reaches 0 does the transaction actually commit. <c>ROLLBACK</c>
+    /// (without a savepoint name) zeroes it regardless of depth — matches
+    /// SQL Server's documented behavior (probe-confirmed 2026-05-08).
+    /// </summary>
+    internal int TranCount = 1;
+
     /// <summary>
     /// Savepoint name → log position at the time of <c>SAVE TRANSACTION</c>.
     /// EF Core 10's <c>RelationalTransaction.CreateSavepoint</c> emits
@@ -48,6 +59,9 @@ public override void Commit()
     {
         if (this.finished)
             throw new InvalidOperationException("This SqlTransaction has completed; it is no longer usable.");
+        this.TranCount--;
+        if (this.TranCount > 0)
+            return;
         this.UndoLog.Clear();
         this.connection.CurrentTransaction = null;
         this.finished = true;
@@ -58,6 +72,7 @@ public override void Rollback()
         if (this.finished)
             throw new InvalidOperationException("This SqlTransaction has completed; it is no longer usable.");
         this.UndoLog.Rollback();
+        this.TranCount = 0;
         this.connection.CurrentTransaction = null;
         this.finished = true;
     }
diff --git a/SqlServerSimulator/SimulatedSqlException.SyntaxErrors.cs b/SqlServerSimulator/SimulatedSqlException.SyntaxErrors.cs
@@ -21,4 +21,20 @@ internal static SimulatedSqlException UnclosedStringLiteral() =>
     internal static SimulatedSqlException SyntaxErrorNear(Token? token) => new($"Incorrect syntax near '{token}'.", 102, 15, 1);
 
     internal static SimulatedSqlException SyntaxErrorNear(char c) => new($"Incorrect syntax near '{c}'.", 102, 15, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 3902: a <c>COMMIT</c> was issued with no
+    /// active transaction. Probe-confirmed against SQL Server 2025
+    /// (2026-05-08): Class 16, State 1, exact wording verbatim.
+    /// </summary>
+    internal static SimulatedSqlException NoCorrespondingBeginCommit() =>
+        new("The COMMIT TRANSACTION request has no corresponding BEGIN TRANSACTION.", 3902, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 3903: a <c>ROLLBACK</c> was issued with no
+    /// active transaction. Probe-confirmed against SQL Server 2025
+    /// (2026-05-08): Class 16, State 1, exact wording verbatim.
+    /// </summary>
+    internal static SimulatedSqlException NoCorrespondingBeginRollback() =>
+        new("The ROLLBACK TRANSACTION request has no corresponding BEGIN TRANSACTION.", 3903, 16, 1);
 }
diff --git a/SqlServerSimulator/Simulation.cs b/SqlServerSimulator/Simulation.cs

Original file line number	Diff line number	Diff line change
`@@ -17,5 +17,6 @@ enum AtAtKeyword`
`17`	`17`	`ServiceName,`
`18`	`18`	`SpId,`
`19`	`19`	`TextSize,`
	`20`	`+ TranCount,`
`20`	`21`	`Version`
`21`	`22`	`}`