Optimized system stored procedure lookup.

Author: RyanLamansky

SqlServerSimulator/Collation.cs

@@ -45,6 +45,17 @@ private protected Collation()
     {
     }
 
+    /// <summary>
+    /// Lazily-built set of the system procedure names EXEC routes to
+    /// built-in handlers, using this collation as the comparer. Owned and
+    /// populated by <see cref="Simulation"/>'s EXEC parser (see
+    /// <c>Simulation.Exec.cs::ResolveSystemProcedureName</c>, including its
+    /// note on the benign first-touch race); held here so the cache follows
+    /// the interned collation instance's lifetime. Contents are fixed
+    /// literals, so sharing across simulations is safe.
+    /// </summary>
+    internal HashSet<string>? SystemProcedureLookup;
+
     public abstract string Name { get; }
 
     /// <summary>

SqlServerSimulator/Simulation/Simulation.Exec.cs

@@ -1,3 +1,4 @@
+using System.Text;
 using SqlServerSimulator.Parser;
 using SqlServerSimulator.Parser.Tokens;
 using SqlServerSimulator.Storage;
@@ -6,6 +7,78 @@ namespace SqlServerSimulator;
 
 partial class Simulation
 {
+    /// <summary>
+    /// Matches <paramref name="leaf"/> against the system procedure names
+    /// under the database collation's equality, returning the canonical
+    /// as-declared name (so the dispatch switch in <see cref="ParseExec"/>
+    /// can match ordinal string constants) or null when the name is not a
+    /// system procedure. Matching is collation-aware — probe-confirmed
+    /// (2026-05-21): system proc names follow the database collation, so
+    /// <c>SP_EXECUTESQL</c> on a case-sensitive database misses here and
+    /// falls through to "procedure not found".
+    /// </summary>
+    private static string? ResolveSystemProcedureName(Collation collation, string leaf)
+    {
+        // Lazily built once per interned collation instance (stable across
+        // ALTER DATABASE COLLATE, which swaps the database's field to a
+        // different interned instance). A concurrent first-touch race is
+        // benign: both threads build identical sets and the reference
+        // assignment is atomic.
+        var lookup = collation.SystemProcedureLookup ??= new HashSet<string>(
+            [
+                // sp_executesql is a built-in proc with a special argument
+                // shape (param-defs and OUTPUT writeback to @-variables in
+                // the caller's scope) parsed by ParseSpExecuteSql rather
+                // than the generic EXEC-argument grammar.
+                "sp_executesql",
+                // Extended-property sprocs — all 3 share argument parsing +
+                // target resolution via InvokeSpExtendedProperty. The
+                // bacpac loader emits `EXEC sp_addextendedproperty …` for
+                // every `<SqlExtendedProperty>` element in model.xml; the
+                // update/drop variants round out the API.
+                "sp_addextendedproperty",
+                "sp_updateextendedproperty",
+                "sp_dropextendedproperty",
+                // Linked-server sprocs — sp_addlinkedserver / sp_dropserver
+                // carry semantic effect (activating / deactivating an entry
+                // in Simulation.ActiveLinkedServers); sp_addlinkedsrvlogin /
+                // sp_droplinkedsrvlogin / sp_serveroption parse-and-discard
+                // since the simulator has no principal-mapping or
+                // per-server-option model but BACPAC / migration scripts
+                // often emit them.
+                "sp_addlinkedserver",
+                "sp_dropserver",
+                "sp_addlinkedsrvlogin",
+                "sp_droplinkedsrvlogin",
+                "sp_serveroption",
+                "sp_set_session_context",
+                "sp_getapplock",
+                "sp_releaseapplock",
+            ],
+            collation);
+        if (lookup.TryGetValue(leaf, out var canonical))
+            return canonical;
+
+        // A set miss is definitive only when the probe hashes consistently
+        // with the stored names. SqlLatin1Cp1CiAsCollation.GetHashCode
+        // hashes in-repertoire strings by SQL sort weights but
+        // out-of-repertoire strings via its inner Windows collation, so an
+        // out-of-repertoire spelling that IS Equals-equal to a stored name
+        // (fullwidth ｓp_executesql — regime-1 fullwidth folding) hashes
+        // differently and misses the set. Every stored name is ASCII and
+        // therefore in-repertoire, so a pure-ASCII probe shares their
+        // hashing scheme and its miss is exact; anything else re-checks by
+        // direct equality.
+        if (Ascii.IsValid(leaf))
+            return null;
+        foreach (var name in lookup)
+        {
+            if (collation.Equals(leaf, name))
+                return name;
+        }
+        return null;
+    }
+
     /// <summary>
     /// Parses an <c>[@rc =] EXEC[UTE] target [args]</c> statement where
     /// <c>target</c> is either a procedure name (regular EXEC), a
@@ -74,85 +147,31 @@ private IEnumerable<SimulatedStatementOutcome> ParseExec(BatchContext batch)
         var procName = BatchContext.ParseObjectName(context);
         context.MoveNextOptional();
 
-        // sp_executesql is a built-in proc with a special argument shape
-        // (param-defs and OUTPUT writeback to @-variables in the caller's
-        // scope). Route to its own parser before falling through to the
-        // generic-procedure path. Probe-confirmed (2026-05-21): system proc
-        // names follow the database collation, so `SP_EXECUTESQL` on a CS
-        // database raises "procedure not found" — that's what falls through
-        // here when the case mismatch causes a dispatch miss.
-        var dbCollation = batch.CurrentDatabase.Collation;
-        if (dbCollation.Equals(procName.Leaf, "sp_executesql"))
+        // System procedures route to built-in handlers before generic
+        // resolution. ResolveSystemProcedureName does the collation-aware
+        // match and hands back the canonical as-declared name, so the
+        // switch arms below match ordinary string constants regardless of
+        // the SQL text's casing. A null falls through to user-procedure
+        // resolution.
+        var systemProcName = ResolveSystemProcedureName(batch.CurrentDatabase.Collation, procName.Leaf);
+        var systemProc = systemProcName switch
         {
-            foreach (var outcome in ParseSpExecuteSql(batch, returnCodeVar))
-                yield return outcome;
-            yield break;
-        }
-
-        // Extended-property sprocs — all 3 share argument parsing + target
-        // resolution via InvokeSpExtendedProperty. The bacpac loader emits
-        // `EXEC sp_addextendedproperty …` for every `<SqlExtendedProperty>`
-        // element in model.xml; the update/drop variants round out the API.
-        if (dbCollation.Equals(procName.Leaf, "sp_addextendedproperty"))
-        {
-            foreach (var outcome in InvokeSpExtendedProperty(batch, ExtendedPropertyOp.Add))
-                yield return outcome;
-            yield break;
-        }
-        if (dbCollation.Equals(procName.Leaf, "sp_updateextendedproperty"))
-        {
-            foreach (var outcome in InvokeSpExtendedProperty(batch, ExtendedPropertyOp.Update))
-                yield return outcome;
-            yield break;
-        }
-        if (dbCollation.Equals(procName.Leaf, "sp_dropextendedproperty"))
-        {
-            foreach (var outcome in InvokeSpExtendedProperty(batch, ExtendedPropertyOp.Drop))
-                yield return outcome;
-            yield break;
-        }
-
-        // Linked-server sprocs — sp_addlinkedserver / sp_dropserver carry
-        // semantic effect (activating / deactivating an entry in
-        // Simulation.ActiveLinkedServers); sp_addlinkedsrvlogin /
-        // sp_droplinkedsrvlogin / sp_serveroption parse-and-discard since
-        // the simulator has no principal-mapping or per-server-option model
-        // but BACPAC / migration scripts often emit them.
-        if (dbCollation.Equals(procName.Leaf, "sp_addlinkedserver"))
-        {
-            foreach (var outcome in InvokeSpAddLinkedServer(batch))
-                yield return outcome;
-            yield break;
-        }
-        if (dbCollation.Equals(procName.Leaf, "sp_dropserver"))
-        {
-            foreach (var outcome in InvokeSpDropServer(batch))
-                yield return outcome;
-            yield break;
-        }
-        if (dbCollation.Equals(procName.Leaf, "sp_set_session_context"))
-        {
-            foreach (var outcome in InvokeSpSetSessionContext(batch))
-                yield return outcome;
-            yield break;
-        }
-        if (dbCollation.Equals(procName.Leaf, "sp_getapplock"))
-        {
-            foreach (var outcome in InvokeSpGetAppLock(batch, returnCodeVar))
-                yield return outcome;
-            yield break;
-        }
-        if (dbCollation.Equals(procName.Leaf, "sp_releaseapplock"))
-        {
-            foreach (var outcome in InvokeSpReleaseAppLock(batch, returnCodeVar))
-                yield return outcome;
-            yield break;
-        }
-        if (dbCollation.Equals(procName.Leaf, "sp_addlinkedsrvlogin")
-            || dbCollation.Equals(procName.Leaf, "sp_droplinkedsrvlogin")
-            || dbCollation.Equals(procName.Leaf, "sp_serveroption"))
+            null => null,
+            "sp_addextendedproperty" => InvokeSpExtendedProperty(batch, ExtendedPropertyOp.Add),
+            "sp_addlinkedserver" => InvokeSpAddLinkedServer(batch),
+            "sp_addlinkedsrvlogin" or "sp_droplinkedsrvlogin" or "sp_serveroption" => InvokeSpLinkedServerNoOp(batch),
+            "sp_dropextendedproperty" => InvokeSpExtendedProperty(batch, ExtendedPropertyOp.Drop),
+            "sp_dropserver" => InvokeSpDropServer(batch),
+            "sp_executesql" => ParseSpExecuteSql(batch, returnCodeVar),
+            "sp_getapplock" => InvokeSpGetAppLock(batch, returnCodeVar),
+            "sp_releaseapplock" => InvokeSpReleaseAppLock(batch, returnCodeVar),
+            "sp_set_session_context" => InvokeSpSetSessionContext(batch),
+            "sp_updateextendedproperty" => InvokeSpExtendedProperty(batch, ExtendedPropertyOp.Update),
+            _ => throw new InvalidOperationException($"{systemProcName} is in SystemProcedureNames but has no dispatch arm."),
+        };
+        if (systemProc is not null)
         {
-            foreach (var outcome in InvokeSpLinkedServerNoOp(batch))
+            foreach (var outcome in systemProc)
                 yield return outcome;
             yield break;
         }

docs/claude/backlog.md

@@ -46,6 +46,7 @@ Real bugs / limitations against shipped behavior — fixes are concrete work, no
 
 - **Trailing-space MIN/MAX representative** — for a group of values differing only in trailing spaces (sort-equal under SQL Server), MIN/MAX returns a different byte-variant than the live server's scan-order representative. Surfaced by the AdventureWorks crosscheck on synthetic XML data (`vJobCandidateEducation._max_Edu_Loc_CountryRegion`). Needs trailing-space-insensitive compare + SQL Server's unspecified MAX-tie scan-order. See [`collations.md`](collations.md) "byte-exact sort" trailing-space note. **Deferred** — synthetic data, and the representative is unspecified scan-order on the live side.
 - **Leaked-connection session cleanup** — a `SimulatedDbConnection` that's never `Dispose`d never reclaims its session state: an open transaction holds its locks and pins the MVCC version store, `##temp` tables linger, session-owned app locks stay held, and the SPID accumulates. Real SqlClient's GC-finalization eventually closes a leaked connection and the server resets the session, so this is a genuine fidelity divergence. **Scope correction (2026-07-11): the fix is bigger than "weaken the registry."** Investigation found *three* global strong-reference cycles that pin exactly the connections that hold session state, so GC can't collect them and a finalizer never fires: (1) `LockResource.Hold.Owner` is a strong `SimulatedDbConnection` (reachable Database → table → lock → hold) — pins any lock- or session-app-lock-holding connection; (2) `HeapTable.OwnerConnection` is strong and `Simulation.GlobalTempTables` holds the table — pins any `##temp` owner; (3) `Database.ActiveSnapshotTxs` holds the transaction, which strongly refs its connection — pins any open-snapshot session. Weakening `Simulation.Connections` alone accomplishes nothing because the resource *is* the pin. A correct fix must break all three cycles — cleanest via a one-way `SessionToken` indirection (resources reference a lightweight token identity; the connection references the token, not vice versa) plus a finalizer that enqueues a **deferred teardown** drained on a normal worker thread (next `CreateDbConnection` / version-store GC) so transaction rollback stays off the finalizer thread. This is a broad, mechanical owner-indirection refactor landing on the most regression-sensitive subsystem (lock manager × GC timing × threading). Payoff is bounded (EF disposes scrupulously; only buggy consumer code leaks), so it's **deliberately deferred** as high-risk / low-frequency. Eventual home: [`locking.md`](locking.md).
+- **`SqlLatin1Cp1CiAsCollation.GetHashCode` inconsistent with `Equals` across the repertoire boundary** — the hybrid default collation hashes in-repertoire strings by SQL sort weights but out-of-repertoire strings via its inner Windows collation, so a pair that `Equals` deems equal across the boundary (fullwidth `ｓchema` vs `schema`, the regime-1 fullwidth fold) hashes to different buckets and misses any hash container keyed by the collation. Probe-confirmed divergences (2026-07-13, default collation): real SQL Server resolves fullwidth spellings of user **table / schema / procedure names** (simulator: Msg 208 / "could not find stored procedure" — `Database.Schemas` / `Schema.HeapTables` / `Procedures` dictionary hash-miss), resolves fullwidth **`@variable` references** (simulator: "must declare" — `BatchContext.Variables` hash-miss), and raises **Msg 8143** for a duplicate EXEC named argument spelled `@a` + fullwidth `@ａ` (simulator: silently binds both — `Simulation.Exec.cs` `seenNames` hash-miss). Column references, named-arg→parameter matching, and `#temp` references already match (linear `Equals` paths). The system-procedure dispatch in `ParseExec` works around it locally (ASCII probes hash consistently with the all-ASCII stored names, so only non-ASCII probes take a linear `Equals` fallback — see `ResolveSystemProcedureName`); that trick doesn't generalize to user-named keys, which can themselves be out-of-repertoire. A general fix means making `GetHashCode` constant on cross-boundary equivalence classes — e.g. hashing everything through the inner Windows collation, which is safe only if weight-equality implies inner-equality for in-repertoire pairs (false collisions are harmless, false splits are not; the ligature/ignorable tiebreaks are the suspect cases) — and needs its own probe-backed bundle since the hash is load-bearing for GROUP BY / DISTINCT / seek caches. `CultureCollation` and the binary collations are self-consistent and unaffected.
 - **Workload-harness divergence reporting quirks** (`.vs/workload/Program.cs`, local-only) — the parity report's example line rebuilds parameters from the op seed and can mismatch the actual divergent instance, and divergent instances aren't re-run single-threaded to classify transient-vs-stable. Both made the 2026-07-10 shared-plan-state hunt slower than it needed to be (the fixed bug class itself — instance-bound aggregate/window results, baked TOP/OFFSET counts, frozen RAND, unstamped replay clock — is documented in [`plan-cache.md`](plan-cache.md)'s shared-plan contract section).
 
 ## Design choices to revisit