Context layering: split Simulation's conflated server+database role into Simulation (instance) + Database (HeapTables, CompatibilityLevel, VerboseTruncationWarnings, @@DBTS rowversion counter); split ParserContext's parse+runtime role into pure-parse ParserContext + BatchContext (Variables, CurrentUndoLog, owns the parser context) + StatementContext (UtcNow frame mutated per dispatch iteration). SimulatedDbConnection gains a CurrentDatabase pointer into the new Databases dict (single "simulated" entry today; USE <db> populates more later). Late-bind switches from Simulation.ActiveConnection to Simulation.ActiveBatch (AsyncLocal<BatchContext?>) — CurrentTimeFunction / LastIdentityExpression / RowCountExpression / IdentCurrent capture Simulation at parse time and resolve through the executing batch at runtime, so a column default's getutcdate() parsed under one batch reads the running batch's frame on later INSERTs.

Author: RyanLamansky

CLAUDE.md

@@ -57,14 +57,16 @@ Readonly struct, up to 4 inline slots (SQL Server's grammar limit). API: `Leaf`,
 ### Expression evaluation
 `Expression.Run(columnResolver)` (runtime) and `Expression.GetSqlType(...)` (static, for projection schema) must agree on result type — drift breaks union/CASE/coalesce schema. `BooleanExpression.Run` returns `bool?` (three-valued); WHERE/MERGE-ON exclude UNKNOWN, CHECK passes UNKNOWN. Aggregates: subclass `Aggregator` (`Add(SqlValue)` / `Result()`), register in `AggregateExpression`'s dispatch.
 
-### Known architectural debt — context layering
-Real SQL Server has five concentric scopes — **server / database / session / batch / statement** — and each piece of state has exactly one home. The simulator collapses these to three buckets and several pieces of state squat in the closest neighbor:
+### Context layering
+Five scopes, one home each. **Add new state to whichever class matches its true scope** — when in doubt, the rule of thumb is: who outlives whom?
 
-- **`Simulation`** = server *and* database. Server-scoped (system tables, `NEWSEQUENTIALID` anchor, rowversion counter) and database-scoped (`HeapTables`, `CompatibilityLevel`, `VerboseTruncationWarnings`) share one class.
-- **`SimulatedDbConnection`** = session. Cleanly mapped (`LastIdentity`, `LastStatementRowCount`, `IdentityInsertTable`, `TraceFlags`, `CurrentTransaction`) — *plus* `CurrentStatementUtcNow`, which is semantically statement-scoped but lives here because statement scope has no home.
-- **`ParserContext`** = parse-time scratch *and* per-batch runtime context. Pure parse state (`Token`, `AggregateCollector`, `WindowCollector`, `OuterTypeResolver`, `CteBindings`) shares the class with batch-lifetime runtime state (`Variables`, `CurrentUndoLog`).
+- **`Simulation`** = server / instance. Process-shared system tables (`SystemHeapTables`), `NEWSEQUENTIALID` anchor + counter, the `Databases` dictionary, and the `ActiveBatch` `AsyncLocal` pointer published by the dispatch loop. Public surface (`Simulation` ctor + `CreateDbConnection()`) stays on this class.
+- **`Database`** (internal) = one database hosted by the server instance. `HeapTables`, `CompatibilityLevel`, `VerboseTruncationWarnings`, `rowVersionCounter` (per-DB `@@DBTS`). Every `Simulation` ships with one entry named `Simulation.DefaultDatabaseName` (`"simulated"`); a future `USE <db>` adds entries to the dictionary.
+- **`SimulatedDbConnection`** = session. `CurrentDatabase` pointer, `CurrentTransaction`, `LastIdentity` (`SCOPE_IDENTITY()` / `@@IDENTITY`), `LastStatementRowCount` (`@@ROWCOUNT`), `IdentityInsertTable`, `TraceFlags`, `IsVerboseTruncationActive()` (reads its own `TraceFlags` + the current database's compat / scoped-config).
+- **`BatchContext`** (internal, in `Parser/`) = one command execution. Owns the `ParserContext` (parse-time-only scratch — `Token`, `AggregateCollector`, `WindowCollector`, `OuterTypeResolver`, `CteBindings`, `InDefaultClause`, `AllowsWindowExpressions`) and holds batch-lifetime runtime state: `Variables`, `CurrentUndoLog`, plus the per-statement frame `CurrentStatement`. Late-bound expressions (`CurrentTimeFunction`, `LastIdentityExpression`, `RowCountExpression`, `IdentCurrent`) capture `Simulation` at parse time and read through `simulation.ActiveBatch` at runtime, so a column default's `getutcdate()` parsed during one batch correctly resolves against the *executing* batch on later INSERTs.
+- **`StatementContext`** (internal, in `Parser/`) = the dispatch loop's per-statement frame. Allocated once per batch and overwritten in place at the top of each iteration; holds `UtcNow` (the per-statement-freeze the time scalars read). Stored-proc EXEC / TRY-CATCH frames slot in here when added.
 
-This is a known smell, not an active task. Refactor trigger: the next feature that genuinely needs a boundary the current shape can't express — `USE <db>` / cross-database queries, true session-vs-global trace-flag scope, stored procedures (which introduce a real per-call statement frame), or two or three consecutive "I had to add it to `Simulation` because no better home exists" moments. Until then, splitting layers churns code without changing user-observable behavior. **Don't stack more state into these buckets unthinkingly** — when adding fields, ask which of the five scopes it actually belongs to and note the mismatch if there is one.
+**Don't stack misfit state into these buckets unthinkingly**: when adding fields, ask which scope it actually belongs to. If none fits, that's the signal to introduce the missing scope rather than squat on a neighbor. Multi-database is structurally supported but exercised only by the default entry; `USE <db>` is the trigger to populate the dictionary properly.
 
 ## Conventions that fail builds
 
@@ -177,7 +179,7 @@ Unknown keyword → Msg 155 with the calling function's lowercase name embedded.
 ### Current-time scalars
 Result types: `GETDATE`/`GETUTCDATE`/`CURRENT_TIMESTAMP` → `datetime`; `SYSDATETIME`/`SYSUTCDATETIME` → `datetime2(7)`; `SYSDATETIMEOFFSET` → `datetimeoffset(7)`. EF emits these from `DateTime.UtcNow`/`Now`/`DateTimeOffset.UtcNow` and `HasDefaultValueSql("getutcdate()")`.
 
-**Per-statement freeze**: two `SYSDATETIME()` calls in one SELECT return identical values; an UPDATE that stamps every row writes the same value; successive SELECTs in one batch DO advance. Captured once per statement-loop iteration into `Simulation.CurrentStatementUtcNow`.
+**Per-statement freeze**: two `SYSDATETIME()` calls in one SELECT return identical values; an UPDATE that stamps every row writes the same value; successive SELECTs in one batch DO advance. Captured once per statement-loop iteration into `BatchContext.CurrentStatement.UtcNow`.
 
 **UTC == Local** (Azure SQL Database default): no local-time conversion; all six functions return the same UTC instant (rounded per type — datetime variants quantize to 1/300s tick). `SYSDATETIMEOFFSET` reports `+00:00`. Apps depending on `GETDATE` ≠ `GETUTCDATE` differing by zone won't behave like on-prem; matches cloud default.
 
@@ -283,9 +285,9 @@ Variable references resolve at runtime via a captured `VariableSlot` — require
 
 **`@@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.
+**Per-session state lives on `SimulatedDbConnection`** (see the Context layering section for the full five-scope map): alongside `@@ROWCOUNT`, the connection carries `LastIdentity` (`SCOPE_IDENTITY()` / `@@IDENTITY`), `IdentityInsertTable` (active `SET IDENTITY_INSERT` table), `TraceFlags` (`DBCC TRACEON(N)`), `IsVerboseTruncationActive()` (reads its own `TraceFlags` plus the current database's compat / scoped-config), `CurrentDatabase` (per-session pointer into `Simulation.Databases`), and `CurrentTransaction`. 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.
+**Late-binding via `Simulation.ActiveBatch`**: `CurrentTimeFunction`, `LastIdentityExpression`, `RowCountExpression`, and `IdentCurrent` capture the **`Simulation`** at parse time and look up the runtime-active batch via `Simulation.ActiveBatch` (an `AsyncLocal<BatchContext?>` published by the dispatch loop with try/finally save-restore) when `Run` fires. Parse-time-capture-the-connection-or-batch is wrong for any expression embedded in a column default: `HasDefaultValueSql("getutcdate()")` parses once during CREATE TABLE, then every later INSERT runs in a different batch, and the default has to read *that* batch's per-statement freeze (`ActiveBatch.CurrentStatement.UtcNow`), not the long-gone CREATE-time batch'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.
 

SqlServerSimulator/Database.cs

@@ -0,0 +1,51 @@
+using System.Collections.Concurrent;
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// One simulated SQL Server database. A <see cref="Simulation"/> hosts a
+/// dictionary of these, keyed by name; each <see cref="SimulatedDbConnection"/>
+/// tracks which one is active via <see cref="SimulatedDbConnection.CurrentDatabase"/>.
+/// The shape is in place so <c>USE &lt;db&gt;</c> / temp-table / cross-database
+/// features can graft on cleanly later — at the moment every
+/// <see cref="Simulation"/> ships with exactly one entry named
+/// <see cref="Simulation.DefaultDatabaseName"/>.
+/// </summary>
+internal sealed class Database(string name)
+{
+    /// <summary>Database name (the key in <see cref="Simulation.Databases"/>).</summary>
+    public readonly string Name = name;
+
+    /// <summary>User tables in this database, keyed by name.</summary>
+    public readonly ConcurrentDictionary<string, HeapTable> HeapTables = new(Collation.Default);
+
+    /// <summary>
+    /// Database compatibility level. Freshly-constructed databases default
+    /// to the most recent supported level; user code switches via
+    /// <c>ALTER DATABASE … SET COMPATIBILITY_LEVEL = N</c>.
+    /// </summary>
+    public CompatibilityLevel CompatibilityLevel = CompatibilityLevel.Sql170;
+
+    /// <summary>
+    /// Explicit override of the per-database <c>VERBOSE_TRUNCATION_WARNINGS</c>
+    /// scoped configuration; <c>null</c> means follow the compatibility-level
+    /// default. Set via
+    /// <c>ALTER DATABASE SCOPED CONFIGURATION SET VERBOSE_TRUNCATION_WARNINGS = ON|OFF</c>.
+    /// </summary>
+    public bool? VerboseTruncationWarnings;
+
+    private long rowVersionCounter;
+
+    /// <summary>
+    /// Allocates the next <c>rowversion</c> counter value (also surfaced as
+    /// <c>@@DBTS</c> in real SQL Server). Database-scoped, monotonic, shared
+    /// across every <c>rowversion</c> column in every table — INSERT and
+    /// UPDATE on a rowversion-bearing table both advance it. The counter is
+    /// the in-memory representation; the 8-byte big-endian wire form
+    /// materializes on demand via <see cref="SqlValue.AsBytes"/> /
+    /// <see cref="RowVersionSqlType.Encode"/>, never per-row in the hot
+    /// path.
+    /// </summary>
+    public long AllocateRowVersion() => Interlocked.Increment(ref this.rowVersionCounter);
+}

SqlServerSimulator/Parser/BatchContext.cs

@@ -0,0 +1,101 @@
+using SqlServerSimulator.Storage;
+using System.Data.Common;
+
+namespace SqlServerSimulator.Parser;
+
+/// <summary>
+/// Per-batch runtime state. One <see cref="BatchContext"/> is constructed
+/// per command execution by <see cref="Simulation.CreateResultSetsForCommand"/>;
+/// it owns the <see cref="ParserContext"/> that walks the command's tokens
+/// and the runtime state both parsing and execution mutate (variable slots,
+/// undo log). Parsers see the parser context and reach runtime state via
+/// <see cref="ParserContext.Batch"/>; the dispatch loop and writeback
+/// helpers operate on the batch context directly.
+/// </summary>
+internal sealed class BatchContext
+{
+    /// <summary>The parser-side cursor / scratch state for this batch.</summary>
+    public readonly ParserContext Parser;
+
+    /// <summary>
+    /// Heap-mutation undo log scoped to the current top-level statement. Set
+    /// by <see cref="Simulation.CreateResultSetsForCommand"/>'s mutation
+    /// dispatch around each INSERT / UPDATE / DELETE / MERGE; the
+    /// <see cref="Heap.Insert"/> / <see cref="Heap.DeleteAt"/>
+    /// call sites read it from here and append entries on success. A
+    /// statement that throws mid-execution (e.g. a multi-row INSERT whose
+    /// fourth row violates a constraint) walks the log backwards before the
+    /// exception propagates, restoring the heap to its pre-statement state.
+    /// Explicit transactions reuse the same log shape, lifetime extended
+    /// across statements until COMMIT / ROLLBACK.
+    /// </summary>
+    public UndoLog? CurrentUndoLog;
+
+    /// <summary>
+    /// Per-statement scratch frame, allocated once per batch and overwritten
+    /// in place by the dispatch loop at the top of each statement iteration.
+    /// See <see cref="StatementContext"/> for the fields it carries.
+    /// </summary>
+    public readonly StatementContext CurrentStatement = new();
+
+    /// <summary>The connection executing this batch.</summary>
+    public SimulatedDbConnection Connection => this.Parser.Connection;
+
+    /// <summary>The database this batch is executing against.</summary>
+    public Database CurrentDatabase => this.Parser.CurrentDatabase;
+
+    /// <summary>
+    /// Per-batch variable store. Seeded with SqlClient parameters at
+    /// construction; <c>DECLARE</c> adds entries; <c>SET</c> /
+    /// <c>SELECT @v = expr</c> mutate them. Parameters and declared variables
+    /// share a namespace — a <c>DECLARE</c> whose name collides with a
+    /// parameter raises Msg 134 (probe-confirmed: real SQL Server treats
+    /// SqlClient parameters as if they were already declared). End-of-batch
+    /// write-back to <c>InputOutput</c> / <c>Output</c> direction parameters
+    /// reads from this store.
+    /// </summary>
+    public readonly Dictionary<string, VariableSlot> Variables;
+
+    public BatchContext(SimulatedDbCommand command)
+    {
+        this.Variables = SeedVariables(command);
+        this.Parser = new ParserContext(command, this);
+    }
+
+    private static Dictionary<string, VariableSlot> SeedVariables(SimulatedDbCommand command)
+    {
+        var dict = new Dictionary<string, VariableSlot>(StringComparer.InvariantCultureIgnoreCase);
+        foreach (DbParameter parameter in command.Parameters)
+        {
+            var name = parameter.ParameterName;
+            if (name.StartsWith('@'))
+                name = name[1..];
+            var dbType = SqlType.GetByDbType(parameter.DbType);
+            var seed = parameter.Value is null or DBNull
+                ? SqlValue.Null(dbType)
+                : dbType.ConvertParameter(parameter.Value);
+            // For decimal / numeric parameters, ConvertParameter widens the
+            // declared type to fit the value's natural scale (e.g. caller sends
+            // 123.45m without an explicit scale → widens to decimal(28, 2)).
+            // Track the post-widen type so VariableReference.GetSqlType returns
+            // the right schema and downstream readers don't truncate.
+            var declaredType = seed.IsNull ? dbType : seed.Type;
+            dict[name] = new VariableSlot(declaredType, declaredMaxLength: null, seed, parameter);
+        }
+        return dict;
+    }
+
+    /// <summary>
+    /// Resolves <paramref name="name"/> to a live <see cref="VariableSlot"/>
+    /// reference. Captured at parse time by <see cref="Expressions.VariableReference"/>
+    /// so subsequent <c>SET</c> / <c>SELECT @v = expr</c> mutations are
+    /// observable when the expression evaluates at runtime — the dictionary
+    /// is append-only within a batch (re-DECLARE raises Msg 134), so a slot
+    /// reference captured during parse stays valid.
+    /// </summary>
+    /// <exception cref="SimulatedSqlException">Must declare the scalar variable \"@{value of <paramref name="name"/>}\".</exception>
+    public VariableSlot GetVariableSlot(string name) =>
+        Variables.TryGetValue(name, out var slot)
+        ? slot
+        : throw SimulatedSqlException.MustDeclareScalarVariable(name);
+}

SqlServerSimulator/Parser/Expressions/CurrentTimeFunction.cs

@@ -20,7 +20,7 @@ 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
-/// the executing connection's <see cref="SimulatedDbConnection.CurrentStatementUtcNow"/>
+/// the executing statement's <see cref="StatementContext.UtcNow"/>
 /// — 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
@@ -31,13 +31,12 @@ internal enum CurrentTimeKind
 /// <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:
+/// runtime-active batch via <see cref="Simulation.ActiveBatch"/> 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.
+/// time, but every subsequent INSERT runs in a different batch, and the
+/// default has to read that runtime batch's per-statement freeze, not the
+/// long-gone CREATE-time batch's.
 /// </para>
 /// <para>
 /// <c>CURRENT_TIMESTAMP</c> is unique in being a parens-less identifier in
@@ -78,7 +77,7 @@ public CurrentTimeFunction(ParserContext context, CurrentTimeKind kind)
 
     public override SqlValue Run(Func<MultiPartName, SqlValue> getColumnValue)
     {
-        var utcNow = this.simulation.ActiveConnection!.CurrentStatementUtcNow;
+        var utcNow = this.simulation.ActiveBatch!.CurrentStatement.UtcNow;
         return this.Kind switch
         {
             CurrentTimeKind.GetDate or CurrentTimeKind.GetUtcDate or CurrentTimeKind.CurrentTimestamp =>

SqlServerSimulator/Parser/Expressions/IdentCurrent.cs

@@ -32,7 +32,7 @@ public IdentCurrent(ParserContext context)
 
     public override SqlValue Run(Func<MultiPartName, SqlValue> getColumnValue)
     {
-        if (!this.simulation.HeapTables.TryGetValue(this.tableName, out var table))
+        if (!this.simulation.ActiveBatch!.CurrentDatabase.HeapTables.TryGetValue(this.tableName, out var table))
             return SqlValue.Null(ResultType);
         var identityOrdinal = table.IdentityOrdinal;
         return identityOrdinal < 0