Moved connection-specific state to the connection, fixed tests that relied on incorrect behavior.

Author: RyanLamansky

CLAUDE.md

@@ -272,7 +272,11 @@ Variable references resolve at runtime via a captured `VariableSlot` — require
 
 **Output-parameter write-back**: at end of batch, the dispatch walks the parameter list and copies each `InputOutput` / `Output` direction parameter's final slot value back to `DbParameter.Value`. Mirrors SqlClient's round-trip behavior for hand-rolled scripts that mutate parameters.
 
-**`@@ROWCOUNT`**: tracks the most-recently-completed statement's row count via `Simulation.LastStatementRowCount`. SELECT row counts populate after the dispatch materializes rows up-front (so the next statement in the batch sees the final count); DML mutations write their affected count; `SET` / `DECLARE @v = init` write 1; bare `DECLARE @v` (no initializer) preserves the prior count; transaction / DDL statements reset to 0.
+**`@@ROWCOUNT`**: tracks the most-recently-completed statement's row count via `SimulatedDbConnection.LastStatementRowCount` (per-session state, not shared across connections that fan out from one `Simulation`). SELECT row counts populate after the dispatch materializes rows up-front (so the next statement in the batch sees the final count); DML mutations write their affected count; `SET` / `DECLARE @v = init` write 1; bare `DECLARE @v` (no initializer) preserves the prior count; transaction / DDL statements reset to 0.
+
+**Per-session state lives on `SimulatedDbConnection`**: alongside `@@ROWCOUNT`, the connection carries `LastIdentity` (`SCOPE_IDENTITY()` / `@@IDENTITY`), `IdentityInsertTable` (active `SET IDENTITY_INSERT` table), `TraceFlags` (`DBCC TRACEON(N)`), `CurrentStatementUtcNow` (per-statement-freeze for the time scalars), and `IsVerboseTruncationActive()` (which reads its own `TraceFlags` plus the simulation's compatibility level / scoped config). Two connections fanned from one `Simulation` are isolated — matches SQL Server's session = ADO.NET connection scoping.
+
+**Late-binding the executing connection**: `CurrentTimeFunction`, `LastIdentityExpression`, and `RowCountExpression` capture the **`Simulation`** at parse time and look up the runtime-active connection via `Simulation.ActiveConnection` (an `AsyncLocal<SimulatedDbConnection?>` published by the dispatch loop with try/finally save-restore). Parse-time-capture-the-connection is wrong for any expression embedded in a column default: `HasDefaultValueSql("getutcdate()")` parses once during CREATE TABLE on the connection that ran the CREATE, then every later INSERT runs on whichever connection's batch is dispatching, and the default has to read *that* connection's per-statement freeze, not the long-gone CREATE-time connection's.
 
 **Compound assignment** (`SET @v += expr` etc.) and **table variables** (`DECLARE @t TABLE (...)`) aren't modeled — rewrite as `SET @v = @v + expr` for the former; the latter is a separate bundle.
 
@@ -354,7 +358,6 @@ Full `DbDataReader` contract. Typed accessors read `SqlValue` directly via the c
 - Msg 8133 (CASE where every branch is bare `NULL`; simulator returns NULL of `int`).
 - `PRIMARY KEY` / `UNIQUE` on a computed column (`NotSupportedException`).
 - Heap allocation tracking (flat page list, no IAM/PFS).
-- Per-connection session state for `SCOPE_IDENTITY()` / `@@IDENTITY`, `SET IDENTITY_INSERT`'s active table, `DBCC TRACEON(N)` flags — all live on `Simulation` rather than connection. (Tx state is already per-connection.)
 - Compound assignment (`SET @v += expr` / `-=` / `*=` etc.) — rewrite as `SET @v = @v + expr`. The arithmetic-operator runtime is locked behind `protected` instance methods on `TwoSidedExpression`; exposing them as static helpers is the prerequisite refactor.
 - Table variables (`DECLARE @t TABLE (...)`) — separate feature with its own storage / scope / lifecycle.
 - T-SQL control flow (`IF` / `WHILE` / `BEGIN ... END` / `BREAK` / `CONTINUE`) — Bundle 2 of scripting.

SqlServerSimulator.Tests.EFCore/EFCoreIdentity.cs

@@ -88,16 +88,16 @@ public void Where_FiltersByAutoGeneratedId()
     [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 Widgets (Name) values ('First'),('Second')")
-            .ExecuteNonQuery();
+        // SCOPE_IDENTITY/@@IDENTITY are per-session — the priming INSERT and
+        // the read have to share the EF context's connection.
+        using var context = new TestDbContext(TestDbContext.CreateWidgetsSimulation());
+        context.Database.OpenConnection();
+        using (var cmd = context.Database.GetDbConnection().CreateCommand())
+        {
+            cmd.CommandText = "insert Widgets (Name) values ('First'),('Second')";
+            _ = cmd.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();
 
@@ -128,13 +128,12 @@ public void SqlQueryRaw_ScopeIdentity_BeforeAnyInsertIsNull()
     [TestMethod]
     public void SaveChanges_WithIdentityInsertOn_PersistsExplicitId()
     {
-        var simulation = TestDbContext.CreateStickersSimulation();
-        _ = simulation
-            .CreateOpenConnection()
-            .CreateCommand("set identity_insert Stickers on")
-            .ExecuteNonQuery();
+        // SET IDENTITY_INSERT scopes to the connection — issue it on the EF
+        // context's connection so SaveChanges runs under the same flag.
+        using var context = new TestDbContext(TestDbContext.CreateStickersSimulation());
+        context.Database.OpenConnection();
+        _ = context.Database.ExecuteSqlRaw("set identity_insert Stickers on");
 
-        using var context = new TestDbContext(simulation);
         _ = context.Stickers.Add(new Sticker { Id = 100, Tag = "explicit" });
         _ = context.SaveChanges();
 
@@ -145,15 +144,14 @@ public void SaveChanges_WithIdentityInsertOn_PersistsExplicitId()
     public void SaveChanges_WithIdentityInsertOn_AdvancesSeed()
     {
         // Inserting an explicit Id past the high-water mark via EF should
-        // reseed the same way raw SQL does.
+        // reseed the same way raw SQL does. SET IDENTITY_INSERT and the
+        // SaveChanges insert have to share the connection; IDENT_CURRENT
+        // (database-scoped, not session-scoped) is observable from anywhere.
         var simulation = TestDbContext.CreateStickersSimulation();
-        _ = simulation
-            .CreateOpenConnection()
-            .CreateCommand("set identity_insert Stickers on")
-            .ExecuteNonQuery();
-
         using (var context = new TestDbContext(simulation))
         {
+            context.Database.OpenConnection();
+            _ = context.Database.ExecuteSqlRaw("set identity_insert Stickers on");
             _ = context.Stickers.Add(new Sticker { Id = 50, Tag = "jump" });
             _ = context.SaveChanges();
         }

SqlServerSimulator.Tests/ConnectionIsolationTests.cs

@@ -0,0 +1,92 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Per-session state on <see cref="SimulatedDbConnection"/> must not leak
+/// between connections that share a <see cref="Simulation"/>. Before
+/// per-connection scoping these all lived on <see cref="Simulation"/> and
+/// each test below would have failed in the cross-connection direction.
+/// </summary>
+[TestClass]
+public sealed class ConnectionIsolationTests
+{
+    [TestMethod]
+    public void ScopeIdentity_DoesNotLeakBetweenConnections()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int identity(1,1), x int)");
+
+        using var connA = simulation.CreateOpenConnection();
+        using var connB = simulation.CreateOpenConnection();
+
+        _ = connA.CreateCommand("insert t (x) values (42)").ExecuteNonQuery();
+
+        AreEqual(1m, connA.CreateCommand("select SCOPE_IDENTITY()").ExecuteScalar());
+        AreEqual(DBNull.Value, connB.CreateCommand("select SCOPE_IDENTITY()").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void RowCount_DoesNotLeakBetweenConnections()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int)");
+
+        using var connA = simulation.CreateOpenConnection();
+        using var connB = simulation.CreateOpenConnection();
+
+        _ = connA.CreateCommand("insert t values (1),(2),(3)").ExecuteNonQuery();
+
+        // Connection B never ran a row-producing statement, so its @@ROWCOUNT
+        // is still 0 — A's INSERT writing 3 doesn't bleed across.
+        AreEqual(0, connB.CreateCommand("select @@ROWCOUNT").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void IdentityInsert_DoesNotLeakBetweenConnections()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int identity(1,1), x int)");
+
+        using var connA = simulation.CreateOpenConnection();
+        using var connB = simulation.CreateOpenConnection();
+
+        _ = connA.CreateCommand("set identity_insert t on").ExecuteNonQuery();
+
+        // SET IDENTITY_INSERT scopes to A. B still sees the column as a
+        // generated identity and rejects an explicit value with Msg 544.
+        var ex = Throws<System.Data.Common.DbException>(
+            () => connB.CreateCommand("insert t (id, x) values (99, 1)").ExecuteNonQuery());
+        AreEqual("544", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void TimeDefault_ParsedOnOneConnection_RunsOnDispatchingConnection()
+    {
+        // Regression coverage for the parse-once-run-many trap: a column
+        // default's getutcdate() is parsed once at CREATE TABLE time on whichever
+        // connection issued the CREATE, but every later INSERT can run on a
+        // different connection. The default must read the *dispatching*
+        // connection's per-statement freeze, not the long-frozen value left on
+        // the connection that parsed it. Capturing the connection at parse time
+        // would freeze both INSERTs at the CREATE-TABLE timestamp.
+        var simulation = new Simulation();
+        using var connA = simulation.CreateOpenConnection();
+        using var connB = simulation.CreateOpenConnection();
+
+        _ = connA.CreateCommand(
+            "create table t (id int identity, note nvarchar(10), stamp datetime2(7) default getutcdate())")
+            .ExecuteNonQuery();
+
+        _ = connB.CreateCommand("insert t (note) values ('a')").ExecuteNonQuery();
+        Thread.Sleep(10);
+        _ = connB.CreateCommand("insert t (note) values ('b')").ExecuteNonQuery();
+
+        using var reader = connB.CreateCommand("select stamp from t order by id").ExecuteReader();
+        IsTrue(reader.Read());
+        var first = reader.GetDateTime(0);
+        IsTrue(reader.Read());
+        var second = reader.GetDateTime(0);
+        IsGreaterThan(first, second);
+    }
+}

SqlServerSimulator.Tests/IdentityTests.cs

@@ -55,13 +55,15 @@ select SCOPE_IDENTITY()
     [TestMethod]
     public void ScopeIdentity_AfterMultiRowInsert_ReturnsLastValue()
     {
-        var simulation = new Simulation();
-        _ = simulation.ExecuteNonQuery("""
+        // SCOPE_IDENTITY/@@IDENTITY are per-session (per-connection) so the
+        // setup INSERT and the read have to share a connection.
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("""
             create table t (id int identity(1,1), x int);
             insert t (x) values (1),(2),(3)
-            """);
-        AreEqual(3m, simulation.ExecuteScalar("select SCOPE_IDENTITY()"));
-        AreEqual(3m, simulation.ExecuteScalar("select @@IDENTITY"));
+            """).ExecuteNonQuery();
+        AreEqual(3m, connection.CreateCommand("select SCOPE_IDENTITY()").ExecuteScalar());
+        AreEqual(3m, connection.CreateCommand("select @@IDENTITY").ExecuteScalar());
     }
 
     // Verified: insert a table without identity clears SCOPE_IDENTITY/@@IDENTITY back to NULL.

SqlServerSimulator/Errors/SimulatedSqlException.ConstraintErrors.cs

@@ -14,7 +14,7 @@ partial class SimulatedSqlException
     /// became the default in SQL Server 2022+ (compatibility level 160+),
     /// superseding the legacy <see cref="StringOrBinaryWouldBeTruncatedLegacy"/>
     /// (Msg 8152). The simulator selects between the two via
-    /// <see cref="Simulation.IsVerboseTruncationActive"/>.
+    /// <see cref="SimulatedDbConnection.IsVerboseTruncationActive"/>.
     /// </remarks>
     internal static SimulatedSqlException StringOrBinaryWouldBeTruncated(string tableName, string columnName, string value, int max)
     {

SqlServerSimulator/Parser/Expressions/CurrentTimeFunction.cs

@@ -20,15 +20,26 @@ internal enum CurrentTimeKind
 /// Backs the six current-time scalar functions (<c>GETDATE</c>,
 /// <c>GETUTCDATE</c>, <c>SYSDATETIME</c>, <c>SYSUTCDATETIME</c>,
 /// <c>SYSDATETIMEOFFSET</c>, <c>CURRENT_TIMESTAMP</c>). All six read from
-/// <see cref="Simulation.CurrentStatementUtcNow"/> — captured once per
-/// top-level statement — so multiple calls within one statement return
-/// identical values (matching SQL Server's per-statement freeze, probe-
-/// confirmed 2026-05-09). The simulator collapses local time onto UTC the
-/// way Azure SQL Database does by default: every variant returns the same
-/// instant; the offset-returning variant reports <c>+00:00</c>.
+/// the executing connection's <see cref="SimulatedDbConnection.CurrentStatementUtcNow"/>
+/// — captured once per top-level statement — so multiple calls within one
+/// statement return identical values (matching SQL Server's per-statement
+/// freeze, probe-confirmed 2026-05-09). The simulator collapses local time
+/// onto UTC the way Azure SQL Database does by default: every variant
+/// returns the same instant; the offset-returning variant reports
+/// <c>+00:00</c>.
 /// </summary>
 /// <remarks>
 /// <para>
+/// Captures the <see cref="Simulation"/> at parse time and looks up the
+/// runtime-active connection via <see cref="Simulation.ActiveConnection"/>
+/// when <see cref="Run"/> fires. Critical for column-default reuse:
+/// <c>HasDefaultValueSql("getutcdate()")</c> parses once at CREATE TABLE
+/// time on the connection that ran the CREATE, but every subsequent
+/// INSERT runs on whichever connection's batch is dispatching, and the
+/// default has to read that runtime connection's per-statement freeze, not
+/// the long-gone CREATE-time connection's.
+/// </para>
+/// <para>
 /// <c>CURRENT_TIMESTAMP</c> is unique in being a parens-less identifier in
 /// SQL Server's grammar. The parser recognizes it as
 /// <c>ReservedKeyword { Keyword: Keyword.Current_Timestamp }</c> directly in
@@ -67,7 +78,7 @@ public CurrentTimeFunction(ParserContext context, CurrentTimeKind kind)
 
     public override SqlValue Run(Func<MultiPartName, SqlValue> getColumnValue)
     {
-        var utcNow = this.simulation.CurrentStatementUtcNow;
+        var utcNow = this.simulation.ActiveConnection!.CurrentStatementUtcNow;
         return this.Kind switch
         {
             CurrentTimeKind.GetDate or CurrentTimeKind.GetUtcDate or CurrentTimeKind.CurrentTimestamp =>

SqlServerSimulator/Parser/Expressions/LastIdentityExpression.cs

@@ -4,13 +4,19 @@ namespace SqlServerSimulator.Parser.Expressions;
 
 /// <summary>
 /// Backs both <c>SCOPE_IDENTITY()</c> and <c>@@IDENTITY</c>: returns the
-/// simulation's last-inserted identity value as <c>numeric(38, 0)</c>, or
-/// NULL when the most recent INSERT didn't touch an identity column. The
-/// two T-SQL surfaces differ in scope on real SQL Server (SCOPE_IDENTITY
-/// is per scope, @@IDENTITY is per session); the simulator collapses both
-/// to <see cref="Simulation.LastIdentity"/> until session-scoped state is
-/// modeled — see the same simplification on <see cref="Simulation.TraceFlags"/>.
+/// executing connection's last-inserted identity value as
+/// <c>numeric(38, 0)</c>, or NULL when the most recent INSERT didn't touch
+/// an identity column. The two T-SQL surfaces differ in scope on real SQL
+/// Server (SCOPE_IDENTITY is per scope, @@IDENTITY is per session); the
+/// simulator collapses both to <see cref="SimulatedDbConnection.LastIdentity"/>.
 /// </summary>
+/// <remarks>
+/// Captures the <see cref="Simulation"/> at parse time and looks up the
+/// runtime-active connection via <see cref="Simulation.ActiveConnection"/>
+/// when <see cref="Run"/> fires. Late-binding matters when this expression
+/// is parsed once and reused across many statements (e.g. baked into a
+/// column default) on possibly-different connections.
+/// </remarks>
 internal sealed class LastIdentityExpression : Expression
 {
     private static readonly SqlType ResultType = SqlType.GetDecimal(38, 0);
@@ -27,7 +33,7 @@ public LastIdentityExpression(ParserContext context)
     }
 
     public override SqlValue Run(Func<MultiPartName, SqlValue> getColumnValue) =>
-        this.simulation.LastIdentity is decimal v
+        this.simulation.ActiveConnection!.LastIdentity is decimal v
             ? SqlValue.FromDecimal(ResultType, v)
             : SqlValue.Null(ResultType);
 

SqlServerSimulator/Parser/Expressions/RowCountExpression.cs

@@ -19,7 +19,7 @@ namespace SqlServerSimulator.Parser.Expressions;
 internal sealed class RowCountExpression(Simulation simulation) : Expression
 {
     public override SqlValue Run(Func<MultiPartName, SqlValue> getColumnValue) =>
-        SqlValue.FromInt32(simulation.LastStatementRowCount);
+        SqlValue.FromInt32(simulation.ActiveConnection!.LastStatementRowCount);
 
     public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => SqlType.Int32;