Explicit RuntimeContext threading: replaces Simulation.ActiveBatch (AsyncLocal<BatchContext?>) with a readonly struct RuntimeContext { ResolveColumn, Batch } passed as the single Expression.Run / BooleanExpression.Run parameter (named runtime at every callsite, symmetric with ParserContext context). Late-bound expressions (CurrentTimeFunction, LastIdentityExpression, RowCountExpression, IdentCurrent) read runtime.Batch.CurrentStatement.UtcNow / runtime.Batch.Connection.LastIdentity / runtime.Batch.CurrentDatabase.HeapTables directly at evaluation time instead of capturing Simulation at parse time — closes the parse-once-run-many side channel that the prior AsyncLocal patched. Selection.Execute(BatchContext, Func<MPN, V>? outerResolver = null) and every internal helper (BuildSqlProjection / BuildAggregateProjectionRows / ProjectSqlRows / ProjectStreaming / ProjectBuffered / ProjectWindowedRows / EnumerateJoinedRows / JoinDriver / CoerceBranchRows + set-op variants / RunRecursiveCte / EnumerateOpenJsonRows / ResolveAcrossTuple + DecodeOrCompute / ComputeOrderKeys) thread batch alongside outerResolver and build new RuntimeContext(perRowResolver, batch) at each Run call. MutationOutputProjection / OutputProjection capture BatchContext at construction so per-row ProjectRow has access; EvaluateComputedColumns / EnforceCheckConstraints take batch. CLAUDE.md's Context layering and Expression evaluation sections drop ActiveBatch references and document the explicit shape.

Author: RyanLamansky

CLAUDE.md

@@ -55,15 +55,15 @@ Readonly struct, up to 4 inline slots (SQL Server's grammar limit). API: `Leaf`,
 `SimulatedSqlException` constructor is private; each error case is an `internal static` factory in a topical partial (`TypeErrors`, `SchemaErrors`, `ConstraintErrors`, `ResolutionErrors`, `QueryErrors`, `SyntaxErrors`). The number lands in `Data["HelpLink.EvtID"]`. **Grep for an existing factory before adding a new one.**
 
 ### 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.
+`Expression.Run(RuntimeContext runtime)` (runtime) and `Expression.GetSqlType(...)` (static, for projection schema) must agree on result type — drift breaks union/CASE/coalesce schema. `RuntimeContext` bundles `ResolveColumn` (per-row column lookup) and `Batch` (the executing `BatchContext`); expressions that need batch / session / database state read `runtime.Batch.*` directly. `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.
 
 ### 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 / 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.
+- **`Simulation`** = server / instance. Process-shared system tables (`SystemHeapTables`), `NEWSEQUENTIALID` anchor + counter, the `Databases` dictionary. 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.
+- **`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`. Threaded explicitly into every `Expression.Run(RuntimeContext runtime)` call via `runtime.Batch` (see "Expression runtime context" below).
 - **`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.
 
 **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.
@@ -287,7 +287,9 @@ Variable references resolve at runtime via a captured `VariableSlot` — require
 
 **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 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.
+**Expression runtime context** (`RuntimeContext`): `Expression.Run` takes a single `RuntimeContext runtime` bundling `ResolveColumn` (per-row column lookup) and `Batch` (the executing `BatchContext`). Most expressions only touch `runtime.ResolveColumn`; the few that need batch-, session-, or database-scoped state (`CurrentTimeFunction`, `LastIdentityExpression`, `RowCountExpression`, `IdentCurrent`) read `runtime.Batch.CurrentStatement.UtcNow`, `runtime.Batch.Connection.LastIdentity`, etc. directly. Explicit threading replaced an earlier `Simulation.ActiveBatch` `AsyncLocal` — necessary because column defaults parsed once at CREATE TABLE run on every later INSERT, possibly from a different batch / connection, and parse-time capture froze them on the wrong batch.
+
+`BooleanExpression.Run(RuntimeContext)` mirrors the same shape (returning `bool?` for three-valued logic). `Selection.Execute(BatchContext, Func<MPN, V>? outerResolver)` threads `batch` through the row pipeline so internal helpers can build `new RuntimeContext(perRowResolver, batch)` at each Run call site. The only callsites that don't have a `BatchContext` in scope are EF-relevant SCALAR expressions evaluated at parse time (TOP / OFFSET / FETCH literals, column-default eval for `BuildSynthesizedSqlRow`) — those construct a `new RuntimeContext(throwingResolver, context.Batch)` from the parser context's batch.
 
 **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/Parser/BooleanExpression.cs

@@ -236,8 +236,8 @@ private static BooleanExpression ParseInList(Expression left, ParserContext cont
     /// (only <c>true</c> rows pass); CHECK constraints treat it as pass
     /// (only an explicit <c>false</c> rejects the row).
     /// </summary>
-    /// <param name="getColumnValue">Provides the value for a column.</param>
-    public abstract bool? Run(Func<MultiPartName, SqlValue> getColumnValue);
+    /// <param name="runtime">Runtime context: column resolver plus batch state.</param>
+    public abstract bool? Run(RuntimeContext runtime);
 
     /// <summary>
     /// Diagnostic-only string rendering, surfaced via
@@ -255,12 +255,12 @@ private static BooleanExpression ParseInList(Expression left, ParserContext cont
     /// </summary>
     private sealed class AndExpression(BooleanExpression left, BooleanExpression right) : BooleanExpression
     {
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue)
+        public override bool? Run(RuntimeContext runtime)
         {
-            var l = left.Run(getColumnValue);
+            var l = left.Run(runtime);
             if (l == false)
                 return false;
-            var r = right.Run(getColumnValue);
+            var r = right.Run(runtime);
             return r == false
                 ? false
                 : l == true && r == true ? true : null;
@@ -276,12 +276,12 @@ private sealed class AndExpression(BooleanExpression left, BooleanExpression rig
     /// </summary>
     private sealed class OrExpression(BooleanExpression left, BooleanExpression right) : BooleanExpression
     {
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue)
+        public override bool? Run(RuntimeContext runtime)
         {
-            var l = left.Run(getColumnValue);
+            var l = left.Run(runtime);
             if (l == true)
                 return true;
-            var r = right.Run(getColumnValue);
+            var r = right.Run(runtime);
             return r == true
                 ? true
                 : l == false && r == false ? false : null;
@@ -300,8 +300,8 @@ private sealed class OrExpression(BooleanExpression left, BooleanExpression righ
     /// </summary>
     private sealed class IsNullExpression(Expression source, bool negated) : BooleanExpression
     {
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue) =>
-            source.Run(getColumnValue).IsNull ^ negated;
+        public override bool? Run(RuntimeContext runtime) =>
+            source.Run(runtime).IsNull ^ negated;
 
         internal override string DebugDisplay() => $"{source.DebugDisplay()} IS {(negated ? "NOT NULL" : "NULL")}";
     }
@@ -317,15 +317,15 @@ private sealed class IsNullExpression(Expression source, bool negated) : Boolean
     /// </summary>
     private sealed class InExpression(Expression source, Expression[] candidates, bool negated) : BooleanExpression
     {
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue)
+        public override bool? Run(RuntimeContext runtime)
         {
-            var src = source.Run(getColumnValue);
+            var src = source.Run(runtime);
             if (src.IsNull)
                 return null;
             var sawNull = false;
             foreach (var candidate in candidates)
             {
-                var c = candidate.Run(getColumnValue);
+                var c = candidate.Run(runtime);
                 if (c.IsNull)
                 {
                     sawNull = true;
@@ -354,8 +354,8 @@ internal override string DebugDisplay()
     /// </summary>
     private sealed class ExistsExpression(Selection inner) : BooleanExpression
     {
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue) =>
-            inner.Execute(getColumnValue).RowBytes.Any();
+        public override bool? Run(RuntimeContext runtime) =>
+            inner.Execute(runtime.Batch, runtime.ResolveColumn).RowBytes.Any();
 
         internal override string DebugDisplay() => "EXISTS (...)";
     }
@@ -373,14 +373,14 @@ private sealed class ExistsExpression(Selection inner) : BooleanExpression
     /// </summary>
     private sealed class InSubqueryExpression(Expression source, Selection inner, bool negated) : BooleanExpression
     {
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue)
+        public override bool? Run(RuntimeContext runtime)
         {
-            var src = source.Run(getColumnValue);
+            var src = source.Run(runtime);
             if (src.IsNull)
                 return null;
 
             var sawNull = false;
-            var resultSet = inner.Execute(getColumnValue);
+            var resultSet = inner.Execute(runtime.Batch, runtime.ResolveColumn);
             foreach (var rowBytes in resultSet.RowBytes)
             {
                 var rowValue = RowDecoder.DecodeColumn(resultSet.Schema, rowBytes, 0);
@@ -406,7 +406,7 @@ private sealed class InSubqueryExpression(Expression source, Selection inner, bo
     /// </summary>
     private sealed class NotExpression(BooleanExpression inner) : BooleanExpression
     {
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue) => inner.Run(getColumnValue) switch
+        public override bool? Run(RuntimeContext runtime) => inner.Run(runtime) switch
         {
             true => false,
             false => true,
@@ -451,8 +451,8 @@ private protected CompareExpression(Expression left, ParserContext context)
         /// equality slot, and the operator name is woven into the message via
         /// the caller-supplied <paramref name="operatorName"/>.
         /// </summary>
-        protected static bool? ComparePromoted(Expression left, Expression right, Func<MultiPartName, SqlValue> getColumnValue, string operatorName, Func<SqlValue, SqlValue, bool> compare) =>
-            CompareValuesPromoted(left.Run(getColumnValue), right.Run(getColumnValue), operatorName, compare);
+        protected static bool? ComparePromoted(Expression left, Expression right, RuntimeContext runtime, string operatorName, Func<SqlValue, SqlValue, bool> compare) =>
+            CompareValuesPromoted(left.Run(runtime), right.Run(runtime), operatorName, compare);
     }
 
     /// <summary>
@@ -478,48 +478,48 @@ private protected CompareExpression(Expression left, ParserContext context)
 
     private sealed class EqualityExpression(Expression left, ParserContext context) : CompareExpression(left, context)
     {
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue) =>
-            ComparePromoted(left, right, getColumnValue, "equal to", static (l, r) => l.Equals(r));
+        public override bool? Run(RuntimeContext runtime) =>
+            ComparePromoted(left, right, runtime, "equal to", static (l, r) => l.Equals(r));
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} = {right.DebugDisplay()}";
     }
 
     private sealed class InequalityExpression(Expression left, ParserContext context) : CompareExpression(left, context)
     {
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue) =>
-            ComparePromoted(left, right, getColumnValue, "not equal to", static (l, r) => !l.Equals(r));
+        public override bool? Run(RuntimeContext runtime) =>
+            ComparePromoted(left, right, runtime, "not equal to", static (l, r) => !l.Equals(r));
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} <> {right.DebugDisplay()}";
     }
 
     private sealed class GreaterThanExpression(Expression left, Expression right) : CompareExpression(left, right)
     {
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue) =>
-            ComparePromoted(left, right, getColumnValue, "greater than", static (l, r) => l.CompareTo(r) > 0);
+        public override bool? Run(RuntimeContext runtime) =>
+            ComparePromoted(left, right, runtime, "greater than", static (l, r) => l.CompareTo(r) > 0);
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} > {right.DebugDisplay()}";
     }
 
     private sealed class GreaterThanOrEqualExpression(Expression left, ParserContext context) : CompareExpression(left, context)
     {
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue) =>
-            ComparePromoted(left, right, getColumnValue, "greater than or equal to", static (l, r) => l.CompareTo(r) >= 0);
+        public override bool? Run(RuntimeContext runtime) =>
+            ComparePromoted(left, right, runtime, "greater than or equal to", static (l, r) => l.CompareTo(r) >= 0);
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} >= {right.DebugDisplay()}";
     }
 
     private sealed class LessThanExpression(Expression left, Expression right) : CompareExpression(left, right)
     {
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue) =>
-            ComparePromoted(left, right, getColumnValue, "less than", static (l, r) => l.CompareTo(r) < 0);
+        public override bool? Run(RuntimeContext runtime) =>
+            ComparePromoted(left, right, runtime, "less than", static (l, r) => l.CompareTo(r) < 0);
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} < {right.DebugDisplay()}";
     }
 
     private sealed class LessThanOrEqualExpression(Expression left, ParserContext context) : CompareExpression(left, context)
     {
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue) =>
-            ComparePromoted(left, right, getColumnValue, "less than or equal to", static (l, r) => l.CompareTo(r) <= 0);
+        public override bool? Run(RuntimeContext runtime) =>
+            ComparePromoted(left, right, runtime, "less than or equal to", static (l, r) => l.CompareTo(r) <= 0);
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} <= {right.DebugDisplay()}";
     }
@@ -539,10 +539,10 @@ private sealed class LikeExpression(Expression left, Expression right, Expressio
         private readonly Expression? escape = escape;
         private readonly bool negated = negated;
 
-        public override bool? Run(Func<MultiPartName, SqlValue> getColumnValue)
+        public override bool? Run(RuntimeContext runtime)
         {
-            var l = left.Run(getColumnValue);
-            var r = right.Run(getColumnValue);
+            var l = left.Run(runtime);
+            var r = right.Run(runtime);
             if (l.IsNull || r.IsNull)
                 return null;
 
@@ -552,7 +552,7 @@ private sealed class LikeExpression(Expression left, Expression right, Expressio
             char? escapeChar = null;
             if (this.escape is not null)
             {
-                var e = this.escape.Run(getColumnValue);
+                var e = this.escape.Run(runtime);
                 if (e.IsNull)
                     return null;
                 if (e.Type.Category != SqlTypeCategory.String)