Fixed three profiled constant-factor costs of scan-bound execution: per-row column-name resolution (per-enumeration SourceColumnMemo keyed by string reference identity), RowDecoder.DecodeColumn's two O(columns) walks (per-schema RowLayout cache + O(1) array-overload fast path), and HashEquiJoin's per-key List growth (forward-linked ordinal chains).

Author: RyanLamansky

CLAUDE.md

@@ -40,7 +40,7 @@ Full suite runs in ~3s; single-test filter (`--filter "FullyQualifiedName~Foo"`)
 Layout: `Storage/` (pages, types, row encoder/decoder, heap, constraints, lock manager + DMVs), `Parser/` (tokenizer, expressions, query planning + execution), `Simulation/` (per-statement-kind partials), `Schemas/` (`SchemaObject` hierarchy + alias/catalog-view/full-text/spatial/xml-schema-collection types), `Errors/` (exception factory partials), root (`Simulated*` ADO.NET front-door + `Simulation` / `Database` / `Schema` / supporting types).
 
 ### Storage
-8KB heap pages. Rows encoded as bytes, navigated column-by-column without rehydrating. Every non-NULL variable-length column carries a 1-byte inline/pointer marker. LOB-eligible types (`varchar(MAX)` / `nvarchar(MAX)` / `varbinary(MAX)` / `text` / `ntext` / `image`) flow through a parallel chain of 8KB LOB pages. Bounded `varchar(N)` / `nvarchar(N)` / `varbinary(N)` start inline; the encoder pushes the largest off-row greedily until the row fits within 8060 bytes. Allocation tracking is a flat page list (no IAM/PFS).
+8KB heap pages. Rows encoded as bytes, navigated column-by-column without rehydrating; single-column reads through an array-typed schema take the `RowLayout` fast path (per-schema geometry cached by array identity via `ConditionalWeakTable`, making `RowDecoder.DecodeColumn` O(1) instead of two O(columns) walks — the per-row execution resolvers' path). Every non-NULL variable-length column carries a 1-byte inline/pointer marker. LOB-eligible types (`varchar(MAX)` / `nvarchar(MAX)` / `varbinary(MAX)` / `text` / `ntext` / `image`) flow through a parallel chain of 8KB LOB pages. Bounded `varchar(N)` / `nvarchar(N)` / `varbinary(N)` start inline; the encoder pushes the largest off-row greedily until the row fits within 8060 bytes. Allocation tracking is a flat page list (no IAM/PFS).
 
 ### Type system
 `SqlType` / `SqlValue` is the storage-layer pair. Three coercion paths: `SqlValue.Coerce` (runtime values), `SqlType.Promote` (static unification for CASE / set ops / COALESCE), `SqlType.PromoteForArithmetic(a, b, op)` (per-operator decimal/integer/money/float result type — the single source of truth for both `TwoSidedExpression.GetSqlType` and `DecimalArithmetic`; static/runtime parity required because the row encoder rejects type mismatches).
@@ -49,7 +49,7 @@ Layout: `Storage/` (pages, types, row encoder/decoder, heap, constraints, lock m
 `Selection.cs` + `Selection.Execution.cs` are a partial-class pair. `Parse → Selection`, `Execute → SimulatedSqlResultSet`. Correlated subqueries re-run the same plan per outer row via `outerResolver: Func<MultiPartName, SqlValue>?` (execute) and `outerTypeResolver: Func<MultiPartName, SqlType>?` (parse). Both walk arbitrary nesting depth via `ParserContext.OuterTypeResolver` + the runtime arg. **Derived tables in FROM are always deferred** (`FromSource.LateralPlan` is re-executed per outer row), matching SQL Server's "any FROM derived table can correlate" rule — required because outer references in WHERE/ON resolve through `Run`, not `GetSqlType`.
 
 ### Multi-source rows
-`FromSource[]`; rows during enumeration are `byte[]?[]`, one slot per source, null = NULL-filled outer-join side (LEFT/RIGHT/FULL/OUTER APPLY). Column resolution is qualifier-aware via `FindSourceColumn` / `ResolveAcrossTuple`; ambiguous unqualified name → Msg 209.
+`FromSource[]`; rows during enumeration are `byte[]?[]`, one slot per source, null = NULL-filled outer-join side (LEFT/RIGHT/FULL/OUTER APPLY). Column resolution is qualifier-aware via `FindSourceColumn` / `ResolveAcrossTuple`; ambiguous unqualified name → Msg 209. Per-row resolution goes through a per-enumeration `SourceColumnMemo` (name → (source, column), keyed by the name's string reference identity — execution-scoped per the plan-cache shared-plan contract); un-memoized re-resolution was the single largest CPU cost of scan-bound joins/aggregates.
 
 ### `MultiPartName`
 Readonly struct, up to 4 inline slots (SQL Server's grammar limit). API: `Leaf`, `ImmediateQualifier` (null when unqualified — pair with `Collation.Baseline.Equals(name.ImmediateQualifier, "INSERTED")`, the equality folds null into `false`), `Count`, `ToString()`. 5th segment → Msg 4104.

SqlServerSimulator/Parser/Selection.Cursor.cs

@@ -82,11 +82,12 @@ internal List<CursorRow> EnumerateForCursor(BatchContext batch)
         var sources = new[] { source };
         var orderBy = this.CursorOrderBy ?? [];
 
+        var memo = new SourceColumnMemo();
         var rows = new List<CursorRow>();
         foreach (var (pageIndex, slotIndex, bytes) in table.Heap.EnumerateRowsWithAddress())
         {
             var tuple = new byte[]?[] { bytes };
-            SqlValue Resolve(MultiPartName name) => ResolveAcrossTuple(sources, tuple, name, batch, null, Resolve);
+            SqlValue Resolve(MultiPartName name) => ResolveAcrossTuple(sources, tuple, name, batch, null, Resolve, memo);
 
             var keep = true;
             foreach (var excluder in profile.Excluders)

SqlServerSimulator/Parser/Selection.Execution.Aggregate.cs

@@ -41,6 +41,7 @@ private static List<SqlValue[]> BuildAggregateProjectionRows(
     {
         if (topCount == 0)
             return [];
+        var memo = new SourceColumnMemo();
 
         var aggregateOperandTypes = new SqlType[aggregates.Count];
         var aggregateResultTypes = new SqlType[aggregates.Count];
@@ -76,7 +77,7 @@ GroupState NewGroup(int keyArity)
         foreach (var tuple in EnumerateJoinedRows(sources, joins, batch, outerResolver))
         {
             var localTuple = tuple;
-            SqlValue ResolveColumn(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveColumn);
+            SqlValue ResolveColumn(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveColumn, memo);
 
             var include = true;
             foreach (var excluder in fromClause.Excluders)
@@ -112,7 +113,7 @@ GroupState NewGroup(int keyArity)
             foreach (var tuple in buffered)
             {
                 var localTuple = tuple;
-                SqlValue ResolveColumn(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveColumn);
+                SqlValue ResolveColumn(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveColumn, memo);
 
                 GroupState state;
                 if (groupingSet.Length == 0)
@@ -226,7 +227,7 @@ SqlValue ResolveByGroupKey(MultiPartName name)
                     // to the outer resolver / Msg 207 when the name isn't a
                     // source column, so this subsumes the outer-or-throw tail.
                     return capturedSet.Length > 0 && state.Representative is { } rep
-                        ? ResolveAcrossTuple(sources, rep, name, batch, outerResolver, ResolveByGroupKey)
+                        ? ResolveAcrossTuple(sources, rep, name, batch, outerResolver, ResolveByGroupKey, memo)
                         : outerResolver is not null
                             ? outerResolver(name)
                             : throw SimulatedSqlException.InvalidColumnName(name);

SqlServerSimulator/Parser/Selection.Execution.Joins.cs

@@ -30,9 +30,10 @@ private static SqlValue ResolveAcrossTuple(
         MultiPartName name,
         BatchContext batch,
         Func<MultiPartName, SqlValue>? outerResolver,
-        Func<MultiPartName, SqlValue> selfRecursive)
+        Func<MultiPartName, SqlValue> selfRecursive,
+        SourceColumnMemo memo)
     {
-        var (s, c) = FindSourceColumn(sources, name);
+        var (s, c) = memo.Find(sources, name);
         if (s == -1)
         {
             return outerResolver is not null
@@ -74,9 +75,10 @@ private static SqlValue ResolveAcrossTuple(
         Func<MultiPartName, SqlValue>? outerResolver)
     {
         var tuple = new byte[]?[sources.Length];
+        var memo = new SourceColumnMemo();
 
         SqlValue Resolve(MultiPartName name) =>
-            ResolveAcrossTuple(sources, tuple, name, batch, outerResolver, Resolve);
+            ResolveAcrossTuple(sources, tuple, name, batch, outerResolver, Resolve, memo);
 
         var rowset = EnumerateLeftmost(sources[0], tuple, batch, outerResolver);
         for (var level = 1; level < sources.Length; level++)
@@ -674,18 +676,33 @@ internal static JoinSpec[] RewriteCommaJoinsToEquiJoins(
     {
         var runtime = new RuntimeContext(resolve, batch);
 
+        // Bucket membership is a forward-linked chain over row ordinals —
+        // buckets[key] holds the chain's (head, tail) and next[ordinal] links
+        // to the same key's following row — rather than a List<int> per key:
+        // one shared next list replaces the per-key list allocations and their
+        // growth churn, which profiling showed as the hash build's dominant
+        // cost on a 228k-row build side. Forward links keep probe emission in
+        // build order, matching the per-key List's insertion order exactly.
         var rightRows = new List<byte[]>();
-        var index = new Dictionary<SqlValueKey, List<int>>();
+        var next = new List<int>();
+        var buckets = new Dictionary<SqlValueKey, (int Head, int Tail)>();
         foreach (var row in right.Rows)
         {
             tuple[level] = row;
             var ordinal = rightRows.Count;
             rightRows.Add(row);
+            next.Add(-1);
             if (TryComputeKey(plan.Keys, runtime, rightSide: true, out var buildKey))
             {
-                if (!index.TryGetValue(buildKey, out var bucket))
-                    index[buildKey] = bucket = [];
-                bucket.Add(ordinal);
+                if (buckets.TryGetValue(buildKey, out var chain))
+                {
+                    next[chain.Tail] = ordinal;
+                    buckets[buildKey] = (chain.Head, ordinal);
+                }
+                else
+                {
+                    buckets[buildKey] = (ordinal, ordinal);
+                }
             }
         }
         tuple[level] = null;
@@ -696,9 +713,9 @@ internal static JoinSpec[] RewriteCommaJoinsToEquiJoins(
         {
             var matchedLeft = false;
             if (TryComputeKey(plan.Keys, runtime, rightSide: false, out var probeKey)
-                && index.TryGetValue(probeKey, out var bucket))
+                && buckets.TryGetValue(probeKey, out var probeChain))
             {
-                foreach (var ordinal in bucket)
+                for (var ordinal = probeChain.Head; ordinal != -1; ordinal = next[ordinal])
                 {
                     tuple[level] = rightRows[ordinal];
                     if (ResidualMatches(plan.Residual, runtime))

SqlServerSimulator/Parser/Selection.Execution.Window.cs

@@ -55,12 +55,13 @@ private static IEnumerable<SqlValue[]> ProjectWindowedRows(
         // cloned. For each buffered tuple, also pre-compute every window's
         // partition + order keys so the per-row resolver doesn't have to
         // be re-bound during window evaluation.
+        var memo = new SourceColumnMemo();
         var buffered = new List<byte[]?[]>();
         var perWindowKeys = new List<(SqlValue[] PartitionKeys, SqlValue[] OrderKeys)[]>();
         foreach (var tuple in EnumerateJoinedRows(sources, joins, batch, outerResolver))
         {
             var localTuple = tuple;
-            SqlValue ResolveSource(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSource);
+            SqlValue ResolveSource(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSource, memo);
 
             var include = true;
             foreach (var excluder in excluders)
@@ -357,14 +358,14 @@ private static IEnumerable<SqlValue[]> ProjectWindowedRows(
                                     else
                                     {
                                         var localTuple = buffered[indices[i]];
-                                        SqlValue ResolveSelf(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSelf);
+                                        SqlValue ResolveSelf(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSelf, memo);
                                         results[indices[i]] = win.DefaultArg.Run(new RuntimeContext(ResolveSelf, batch));
                                     }
                                 }
                                 else
                                 {
                                     var targetTuple = buffered[indices[targetIdx]];
-                                    SqlValue ResolveTarget(MultiPartName name) => ResolveAcrossTuple(sources, targetTuple, name, batch, outerResolver, ResolveTarget);
+                                    SqlValue ResolveTarget(MultiPartName name) => ResolveAcrossTuple(sources, targetTuple, name, batch, outerResolver, ResolveTarget, memo);
                                     results[indices[i]] = win.Operand.Run(new RuntimeContext(ResolveTarget, batch));
                                 }
                             }
@@ -396,7 +397,7 @@ private static IEnumerable<SqlValue[]> ProjectWindowedRows(
                                 }
                                 var refIdx = isLast ? frameEnd : frameStart;
                                 var refTuple = buffered[indices[refIdx]];
-                                SqlValue ResolveRef(MultiPartName name) => ResolveAcrossTuple(sources, refTuple, name, batch, outerResolver, ResolveRef);
+                                SqlValue ResolveRef(MultiPartName name) => ResolveAcrossTuple(sources, refTuple, name, batch, outerResolver, ResolveRef, memo);
                                 results[indices[i]] = win.Operand.Run(new RuntimeContext(ResolveRef, batch));
                             }
                         }
@@ -443,7 +444,7 @@ private static IEnumerable<SqlValue[]> ProjectWindowedRows(
                                 foreach (var i in indices)
                                 {
                                     var localTuple = buffered[i];
-                                    SqlValue ResolveSource(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSource);
+                                    SqlValue ResolveSource(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSource, memo);
                                     var operandValue = aggregate.Operand is null
                                         ? SqlValue.Null(SqlType.Int32)
                                         : aggregate.Operand.Run(new RuntimeContext(ResolveSource, batch));
@@ -468,7 +469,7 @@ private static IEnumerable<SqlValue[]> ProjectWindowedRows(
                             for (var p = 0; p < count; p++)
                             {
                                 var localTuple = buffered[indices[p]];
-                                SqlValue ResolveSource(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSource);
+                                SqlValue ResolveSource(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSource, memo);
                                 operandByPos[p] = aggregate.Operand is null
                                     ? SqlValue.Null(SqlType.Int32)
                                     : aggregate.Operand.Run(new RuntimeContext(ResolveSource, batch));
@@ -538,7 +539,7 @@ private static IEnumerable<SqlValue[]> ProjectWindowedRows(
                 windows[w].BindResult(batch, perWindowResults[w][i]);
 
             var localTuple = buffered[i];
-            SqlValue ResolveSource(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSource);
+            SqlValue ResolveSource(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSource, memo);
 
             var projected = new SqlValue[expressions.Count];
             for (var j = 0; j < expressions.Count; j++)
@@ -595,6 +596,7 @@ private static void ComputeJsonObjectAggWindow(
         Func<MultiPartName, SqlValue>? outerResolver)
     {
         var aggregate = win.AggregateInfo!;
+        var memo = new SourceColumnMemo();
         foreach (var (_, indices) in partitions)
         {
             if (orderByList.Count > 0)
@@ -609,7 +611,7 @@ private static void ComputeJsonObjectAggWindow(
             for (var p = 0; p < count; p++)
             {
                 var localTuple = buffered[indices[p]];
-                SqlValue ResolveSource(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSource);
+                SqlValue ResolveSource(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSource, memo);
                 var runtime = new RuntimeContext(ResolveSource, batch);
                 keys[p] = aggregate.KeyExpression!.Run(runtime);
                 values[p] = aggregate.Operand!.Run(runtime);
@@ -771,7 +773,8 @@ private static SqlValue EvaluateScalarArg(
         if (buffered.Count == 0)
             return SqlValue.Null(SqlType.Int32);
         var firstTuple = buffered[0];
-        SqlValue Resolve(MultiPartName name) => ResolveAcrossTuple(sources, firstTuple, name, batch, outerResolver, Resolve);
+        var memo = new SourceColumnMemo();
+        SqlValue Resolve(MultiPartName name) => ResolveAcrossTuple(sources, firstTuple, name, batch, outerResolver, Resolve, memo);
         return arg.Run(new RuntimeContext(Resolve, batch));
     }
 }

SqlServerSimulator/Parser/Selection.Execution.cs

@@ -334,10 +334,11 @@ private static IEnumerable<SqlValue[]> ProjectStreaming(
 
         IEnumerable<SqlValue[]> InnerStream()
         {
+            var memo = new SourceColumnMemo();
             foreach (var tuple in EnumerateJoinedRows(sources, joins, batch, outerResolver))
             {
                 var localTuple = tuple;
-                SqlValue ResolveColumn(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveColumn);
+                SqlValue ResolveColumn(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveColumn, memo);
 
                 var include = true;
                 foreach (var excluder in excluders)
@@ -380,10 +381,11 @@ private static IEnumerable<SqlValue[]> ProjectBuffered(
     {
         var buffer = new List<(SqlValue[] Projected, SqlValue[] Keys)>();
 
+        var memo = new SourceColumnMemo();
         foreach (var tuple in EnumerateJoinedRows(sources, joins, batch, outerResolver))
         {
             var localTuple = tuple;
-            SqlValue ResolveSource(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSource);
+            SqlValue ResolveSource(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, ResolveSource, memo);
 
             var include = true;
             foreach (var excluder in excluders)

SqlServerSimulator/Parser/Selection.Pivot.cs

@@ -241,10 +241,11 @@ private static IEnumerable<byte[]> UnpivotRows(
         BatchContext batch, Func<MultiPartName, SqlValue>? outerResolver)
     {
         FromSource[] sources = [source];
+        var memo = new SourceColumnMemo();
         foreach (var tuple in EnumerateJoinedRows(sources, [], batch, outerResolver))
         {
             var localTuple = tuple;
-            SqlValue Resolve(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, Resolve);
+            SqlValue Resolve(MultiPartName name) => ResolveAcrossTuple(sources, localTuple, name, batch, outerResolver, Resolve, memo);
 
             foreach (var col in unpivotColumns)
             {