Result-drain hot path stops re-laying-out row geometry per column read: RowDecoder.ColumnsFor caches the type-only-schema HeapColumn[] conversion by schema-array identity so SqlValueCursor and the subquery decode sites hit RowLayout's identity-keyed cache instead of allocating a fresh array per call.

Author: RyanLamansky

CLAUDE.md

@@ -42,7 +42,7 @@ A full build + test cycle runs 20–30s; single-test filter (`--filter "FullyQua
 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; single-column reads via an array-typed schema take the `RowLayout` fast path (per-schema geometry cached by array identity in a `ConditionalWeakTable`, making `RowDecoder.DecodeColumn` O(1) vs two O(columns) walks — the per-row resolvers' path). Every non-NULL variable-length column carries a 1-byte inline/pointer marker. LOB-eligible types (`varchar/nvarchar/varbinary(MAX)`, `text`/`ntext`/`image`) flow through a parallel 8KB-LOB-page chain. Bounded `varchar/nvarchar/varbinary(N)` start inline; the encoder pushes the largest off-row greedily until the row fits 8060 bytes. Allocation is a flat page list (no IAM/PFS).
+8KB heap pages. Rows encoded as bytes, navigated column-by-column without rehydrating; single-column reads via an array-typed schema take the `RowLayout` fast path (per-schema geometry cached by array identity in a `ConditionalWeakTable`, making `RowDecoder.DecodeColumn` O(1) vs two O(columns) walks — the per-row resolvers' path). Type-only `SqlType[]` schemas reach that same fast path through `RowDecoder.ColumnsFor`, which caches the `HeapColumn[]` conversion by schema-array identity — **never convert per call**: a fresh array defeats the layout cache's identity key and re-lays-out the geometry every read (measured at a third of result-drain CPU; the reader-cursor and subquery decode sites are the precedent consumers). Every non-NULL variable-length column carries a 1-byte inline/pointer marker. LOB-eligible types (`varchar/nvarchar/varbinary(MAX)`, `text`/`ntext`/`image`) flow through a parallel 8KB-LOB-page chain. Bounded `varchar/nvarchar/varbinary(N)` start inline; the encoder pushes the largest off-row greedily until the row fits 8060 bytes. Allocation 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 — single source of truth for `TwoSidedExpression.GetSqlType` + `DecimalArithmetic`; static/runtime parity required since the row encoder rejects type mismatches).

SqlServerSimulator.Tests.Internal/Storage/DecodeColumnTests.cs

@@ -84,4 +84,20 @@ public void OutOfRange_Throws()
         _ = Throws<ArgumentOutOfRangeException>(() => RowDecoder.DecodeColumn(schema, bytes, 1));
         _ = Throws<ArgumentOutOfRangeException>(() => RowDecoder.DecodeColumn(schema, bytes, -1));
     }
+
+    /// <summary>
+    /// The type-only schema's <see cref="HeapColumn"/>[] conversion must be
+    /// cached by schema-array identity: a fresh array per call would defeat
+    /// <see cref="RowLayout"/>'s identity-keyed cache, re-laying-out the row
+    /// geometry on every single-column read (measured at a third of
+    /// result-drain CPU before the conversion was cached).
+    /// </summary>
+    [TestMethod]
+    public void ColumnsFor_SameSchemaArray_ReturnsCachedInstance()
+    {
+        SqlType[] schema = [SqlType.Int32, SqlType.Varchar];
+
+        AreSame(RowDecoder.ColumnsFor(schema), RowDecoder.ColumnsFor(schema));
+        AreNotSame(RowDecoder.ColumnsFor(schema), RowDecoder.ColumnsFor([SqlType.Int32, SqlType.Varchar]));
+    }
 }

SqlServerSimulator/SimulatedSqlResultSet.cs

@@ -131,6 +131,7 @@ public override bool MoveNext()
     /// </remarks>
     private sealed class SqlValueCursor(SqlType[] schema, IEnumerator<byte[]> source) : RowCursor
     {
+        private readonly HeapColumn[] columns = RowDecoder.ColumnsFor(schema);
         private byte[]? buffered;
         private byte[]? current;
         private bool peeked;
@@ -186,7 +187,7 @@ public override bool MoveNext()
 
         public override SqlValue this[int ordinal] => current is null
             ? throw new InvalidOperationException("No current row.")
-            : RowDecoder.DecodeColumn(schema, current, ordinal);
+            : RowDecoder.DecodeColumn(columns, current, ordinal);
 
         protected override void DisposeCore() => source.Dispose();
     }

SqlServerSimulator/Storage/RowDecoder.cs

@@ -106,14 +106,32 @@ public static SqlValue[] DecodeRow(ReadOnlySpan<HeapColumn> schema, ReadOnlySpan
     /// Decodes a single column from a row's bytes without materializing the
     /// other columns. The data reader uses this to navigate row bytes directly
     /// per <see cref="System.Data.Common.DbDataReader"/> accessor call.
+    /// Routes through <see cref="ColumnsFor"/> so repeated reads against the
+    /// same schema array reuse one <see cref="HeapColumn"/>[] — and therefore
+    /// one cached <see cref="RowLayout"/> — instead of allocating and
+    /// re-laying-out per call (the per-call rebuild dominated result-drain CPU
+    /// at 34% and its discarded arrays defeated the layout cache's identity
+    /// key).
     /// </summary>
-    public static SqlValue DecodeColumn(ReadOnlySpan<SqlType> schema, ReadOnlySpan<byte> bytes, int ordinal)
-    {
-        var columns = new HeapColumn[schema.Length];
-        for (var i = 0; i < schema.Length; i++)
-            columns[i] = new HeapColumn(string.Empty, schema[i], maxLength: null, nullable: true);
-        return DecodeColumn(columns, bytes, ordinal, lobStore: null);
-    }
+    public static SqlValue DecodeColumn(SqlType[] schema, ReadOnlySpan<byte> bytes, int ordinal) =>
+        DecodeColumn(ColumnsFor(schema), bytes, ordinal, lobStore: null);
+
+    /// <summary>
+    /// The nameless all-nullable <see cref="HeapColumn"/>[] equivalent of a
+    /// type-only schema, cached by the schema array's identity (schema arrays
+    /// are per-result-set and long-lived, mirroring <see cref="RowLayout"/>'s
+    /// keying).
+    /// </summary>
+    public static HeapColumn[] ColumnsFor(SqlType[] schema) =>
+        typeOnlyColumns.GetValue(schema, static s =>
+        {
+            var columns = new HeapColumn[s.Length];
+            for (var i = 0; i < s.Length; i++)
+                columns[i] = new HeapColumn(string.Empty, s[i], maxLength: null, nullable: true);
+            return columns;
+        });
+
+    private static readonly System.Runtime.CompilerServices.ConditionalWeakTable<SqlType[], HeapColumn[]> typeOnlyColumns = [];
 
     /// <summary>
     /// Array-schema fast path of