Introduced server-level collation simulation via the new ServerCollationName property to eliminate more uses of Collation.Default.

Author: RyanLamansky

CLAUDE.md

@@ -61,7 +61,7 @@ Readonly struct, up to 4 inline slots (SQL Server's grammar limit). API: `Leaf`,
 ### Context layering
 Six scopes, one home each. **Add new state to whichever class matches its true scope** — when in doubt, ask who outlives whom. The field roster on each class lives in the source XML docs; this section captures only the identity + load-bearing contracts.
 
-- **`Simulation`** = server / instance. Holds `SystemHeapTables`, NEWSEQUENTIALID anchor, the `Databases` dict. Public surface (`Simulation` ctor + `CreateDbConnection()`) is the entire external API.
+- **`Simulation`** = server / instance. Holds `SystemHeapTables`, NEWSEQUENTIALID anchor, the `Databases` dict, `ServerCollationName` (string-typed `init`-only knob; defaults to `SQL_Latin1_General_CP1_CI_AS`; mirrors `model.collation` — install-time seed for every freshly-created `Database`, both the lazy `"simulated"` seed and bacpac imports without their own collation declaration; `init` reflects real SQL Server's immutability and Azure's outright block on changing it). Public surface (`Simulation` ctor + `CreateDbConnection()` + `ImportBacpac()` + `AddRemoteSimulation()` + `ServerCollationName`) is the entire external API.
 - **`Database`** (internal) = one database in the instance. Holds `Schemas`, `CompatibilityLevel`, `CollationName`, `Principals`, `Permissions`, `ExtendedProperties`, `FullTextCatalogs`, `DdlTriggers`, the rowversion counter (`@@DBTS`), MVCC version store. `Simulation.Databases` starts empty; the first `CreateDbConnection()` call lazily seeds `Simulation.DefaultDatabaseName` (`"simulated"`) when no `ImportBacpac` has landed a database first. `USE <db>` switches the session to a different entry (Msg 911 on miss); 3-part names route reads across databases (`SELECT * FROM other.dbo.t` works), but cross-DB writes raise `NotSupportedException` via `BatchContext.RejectCrossDatabaseMutation` — issue `USE` first.
 - **`Schema`** (internal) = one namespace inside a database. Holds the object dicts: `HeapTables`, `Functions`, `Views`, `Procedures`, `Sequences`, `Triggers` (DML — share the object namespace), and the separate type namespace `TableTypes` + `AliasTypes` + `XmlSchemaCollections`. Schema-qualified references (`audit.t`, `audit.fn`, `audit.proc`, `audit.seq`, …) route through `Database.Schemas["audit"]`; unqualified falls back to `Database.DefaultSchemaName` (`"dbo"`).
 - **`SimulatedDbConnection`** = session. Holds `CurrentDatabase`, `CurrentTransaction`, `LastIdentity` (`SCOPE_IDENTITY` / `@@IDENTITY`), `LastStatementRowCount` (`@@ROWCOUNT`), `LastErrorNumber` (`@@ERROR`), `NestingLevel` (capped at 32), `TempTables` (per-session `#foo` dict, cleared on Dispose), `Spid` (≥51), `LockTimeoutMillis`, `SessionIsolationLevel`, `FiringTriggerIds`, `CurrentExecutingThreadId` (drives same-thread-deadlock detection).

SqlServerSimulator.Tests/NameComparisonRegimeTests.cs

@@ -255,4 +255,61 @@ public void CsDatabase_HierarchyIdTypePrefix_UppercaseHIERARCHYID_NotResolved()
     public void CsDatabase_HierarchyIdTypePrefix_CanonicalCase_Resolves()
         => AreEqual("/", CsCollation().ExecuteScalar(
             "SELECT hierarchyid::GetRoot().ToString()"));
+
+    // ===== Simulation.ServerCollationName seeds new-database collation =====
+    // Mirrors SQL Server's model.collation role: setting it before the
+    // first CreateDbConnection / ImportBacpac makes the lazy-seeded
+    // "simulated" database (and any subsequent bacpac import that
+    // doesn't declare its own collation) inherit the value. Equivalent
+    // end state to ALTER DATABASE COLLATE for the simulated DB, but
+    // chosen up-front rather than as a post-hoc adjustment.
+
+    [TestMethod]
+    public void ServerCollationName_DefaultIsClassicCi()
+        => AreEqual("SQL_Latin1_General_CP1_CI_AS", new Simulation().ServerCollationName);
+
+    [TestMethod]
+    public void ServerCollationName_SetToRecognizedCs_Persists()
+    {
+        var sim = new Simulation { ServerCollationName = "SQL_Latin1_General_CP1_CS_AS" };
+        AreEqual("SQL_Latin1_General_CP1_CS_AS", sim.ServerCollationName);
+    }
+
+    [TestMethod]
+    public void ServerCollationName_Unrecognized_Throws()
+    {
+        var ex = Throws<ArgumentException>(() => new Simulation { ServerCollationName = "Not_A_Real_Collation" });
+        Assert.Contains("not recognized", ex.Message);
+    }
+
+    [TestMethod]
+    public void ServerCollationName_Null_Throws()
+        => _ = Throws<ArgumentNullException>(() => new Simulation { ServerCollationName = null! });
+
+    [TestMethod]
+    public void ServerCollationName_SeedsLazySimulatedDatabase()
+    {
+        var sim = new Simulation { ServerCollationName = "SQL_Latin1_General_CP1_CS_AS" };
+        AreEqual("SQL_Latin1_General_CP1_CS_AS",
+            sim.ExecuteScalar("SELECT collation_name FROM sys.databases WHERE name = N'simulated'"));
+    }
+
+    [TestMethod]
+    public void ServerCollationName_SeededDatabase_CreateSchemaDBO_CoexistsWithDbo()
+    {
+        // Probe-confirmed on real SQL Server CS database (2026-05-22):
+        // CREATE SCHEMA DBO succeeds on a CS-collation DB — both `dbo`
+        // and `DBO` end up in sys.schemas as distinct entries. The
+        // ALTER-DATABASE-COLLATE variant (CsDatabase_CreateSchemaUppercaseDBO_…)
+        // hits Msg 2714 instead because the Schemas dict's comparer
+        // was built CI at construction time and doesn't rebuild on
+        // ALTER (documented fidelity gap). With ServerCollationName
+        // seeded up-front, the dict is CS from the start and the gap
+        // doesn't apply — the simulator matches real SQL Server's
+        // coexistence behavior.
+        var sim = new Simulation { ServerCollationName = "SQL_Latin1_General_CP1_CS_AS" };
+        _ = sim.ExecuteNonQuery("CREATE SCHEMA DBO");
+        AreEqual(2, sim.ExecuteScalar("SELECT COUNT(*) FROM sys.schemas WHERE name IN (N'dbo', N'DBO')"));
+    }
+
 }

SqlServerSimulator.Tests/QualityTests.cs

@@ -28,6 +28,7 @@ public void PublicApiWhitelist()
                 nameof(Simulation.CreateDbConnection),
                 nameof(Simulation.ImportBacpac),
                 nameof(Simulation.AddRemoteSimulation),
+                nameof(Simulation.ServerCollationName),
             ],
             [typeof(SimulatedDbConnection)] = [
                 nameof(SimulatedDbConnection.InfoMessage),

SqlServerSimulator/Collation.cs

@@ -68,17 +68,23 @@ private protected Collation()
     /// <summary>
     /// The simulator's hardcoded baseline collation —
     /// <c>SQL_Latin1_General_CP1_CI_AS</c>. Resolved once via
-    /// <see cref="TryGet"/>. Used as the seed for new
-    /// <see cref="Database.Collation"/> instances, as the fallback for
-    /// string-typed values whose <see cref="SqlType.Collation"/> is
-    /// <see langword="null"/>, and as the default for the storage-layer
+    /// <see cref="TryGet"/>. Two consumers:
+    /// <list type="bullet">
+    /// <item>The default for
+    /// <see cref="Simulation.ServerCollation"/>, which in turn seeds every
+    /// freshly-created <see cref="Database.Collation"/>. Apps that want a
+    /// non-default identifier collation set <see cref="Simulation.ServerCollation"/>
+    /// before the first <c>CreateDbConnection</c> / <c>ImportBacpac</c>;
+    /// per-database divergence happens via <c>ALTER DATABASE COLLATE</c>.</item>
+    /// <item>The storage-layer baseline for the
     /// <see cref="VarcharSqlType"/> / <see cref="NVarcharSqlType"/> /
-    /// <see cref="CharSqlType"/> / <see cref="NCharSqlType"/> singletons.
-    /// Identifier-resolution sites should route through
-    /// <see cref="Database.Collation"/> (which defaults here but may
-    /// diverge under <c>ALTER DATABASE COLLATE</c>); only sites that
-    /// genuinely need "the simulator's baseline regardless of database"
-    /// belong on this property.
+    /// <see cref="CharSqlType"/> / <see cref="NCharSqlType"/> singletons
+    /// (<c>Unspecified</c>, <c>MaxForm</c>, <c>Get(length)</c>). Those
+    /// caches are process-global and can't be per-simulation, so literal /
+    /// parameter / CAST result types carry this collation regardless of
+    /// the active database; per-column declared collation overrides at
+    /// compare and sort time.</item>
+    /// </list>
     /// </summary>
     internal static Collation Default => defaultLazy.Value;
 

SqlServerSimulator/Database.cs

@@ -45,11 +45,6 @@ internal sealed class Database
     /// <summary>Conventional schema-id for <c>sys</c> (matches real SQL Server).</summary>
     public const int SysSchemaId = 4;
 
-    public Database(string name)
-        : this(name, Collation.Default)
-    {
-    }
-
     public Database(string name, Collation collation)
     {
         this.Name = name;
@@ -109,7 +104,8 @@ public Database(string name, Collation collation)
     /// new collation, but the construction-time dict comparers don't
     /// rebuild (matches real SQL Server's behavior: existing objects keep
     /// their identifier registration, new ones bind under the new
-    /// collation). Defaults to <see cref="Collation.Default"/>.
+    /// collation). Seeded at construction from
+    /// <see cref="Simulation.ServerCollation"/>.
     /// </summary>
     public Collation Collation;
 

SqlServerSimulator/Parser/BooleanExpression.cs

@@ -890,8 +890,8 @@ internal override void VisitOperandExpressions(Action<Expression> visitor)
             // Probe-confirmed wording order: right operand's collation first,
             // left operand's collation second.
             throw SimulatedSqlException.CollationConflict(
-                (r.Type.Collation ?? Collation.Default).Name,
-                (l.Type.Collation ?? Collation.Default).Name,
+                r.Type.Collation!.Name,
+                l.Type.Collation!.Name,
                 operatorName);
         }
 
@@ -1000,8 +1000,8 @@ private sealed class LikeExpression(Expression left, Expression right, Expressio
             // name); higher rank wins otherwise.
             var resolved = Collation.Resolve(l.Type, r.Type)
                 ?? throw SimulatedSqlException.CollationConflict(
-                    (r.Type.Collation ?? Collation.Default).Name,
-                    (l.Type.Collation ?? Collation.Default).Name,
+                    r.Type.Collation!.Name,
+                    l.Type.Collation!.Name,
                     "like");
 
             var matched = LikePatternBuilder.BuildAnchored(r.AsString, escapeChar, resolved.Collation.CaseSensitive).IsMatch(l.AsString);

SqlServerSimulator/SimulatedDbConnection.cs

@@ -55,7 +55,7 @@ private static Database ResolveInitialDatabase(Simulation simulation)
                 return existing;
             if (simulation.Databases.Count == 0)
             {
-                var seeded = new Database(Simulation.DefaultDatabaseName);
+                var seeded = new Database(Simulation.DefaultDatabaseName, simulation.ServerCollation);
                 simulation.Databases.Add(Simulation.DefaultDatabaseName, seeded);
                 return seeded;
             }

SqlServerSimulator/Simulation/Simulation.ImportBacpac.cs

@@ -50,7 +50,7 @@ private void ImportBacpacCore(Stream stream, string databaseName, int maxDegreeO
         if (Databases.ContainsKey(databaseName))
             throw new InvalidOperationException($"A database named '{databaseName}' already exists in this Simulation. Import is a create-only operation; choose a different name via BacpacImportOptions.DatabaseName.");
         result = new BacpacImportResult();
-        var database = new Database(databaseName);
+        var database = new Database(databaseName, this.ServerCollation);
         Databases.Add(databaseName, database);
         BacpacReader.Load(stream, this, database, maxDegreeOfParallelism, result);
     }

SqlServerSimulator/Simulation/Simulation.cs

@@ -76,7 +76,7 @@ public void AddRemoteSimulation(string name, Simulation target)
     /// by <c>sp_addlinkedserver</c>; cleared by <c>sp_dropserver</c>.
     /// Four-part-name FROM resolution consults this dict; <c>sys.servers</c>
     /// projects one row per entry plus the local-server row. Case-
-    /// insensitive keys (<see cref="Collation.Default"/>).
+    /// insensitive keys (<see cref="BuiltInToken"/>).
     /// </summary>
     internal readonly ConcurrentDictionary<string, LinkedServer> ActiveLinkedServers = new(BuiltInToken.Comparer);
 
@@ -89,6 +89,49 @@ public void AddRemoteSimulation(string name, Simulation target)
     /// </summary>
     internal const string DefaultDatabaseName = "simulated";
 
+    /// <summary>
+    /// Server-wide default collation name. Used as the seed for every
+    /// <see cref="Database"/> created on this simulation — both the lazy
+    /// <c>"simulated"</c> seed picked up on first
+    /// <see cref="CreateDbConnection"/> and bacpac imports that don't carry
+    /// their own collation declaration. Defaults to
+    /// <c>SQL_Latin1_General_CP1_CI_AS</c>.
+    /// </summary>
+    /// <remarks>
+    /// Mirrors SQL Server's <c>model.collation</c>: install-time choice,
+    /// immutable thereafter (the only way to change it on a real instance
+    /// is the <c>sqlservr -m -q</c> rebuild-master dance, and it's blocked
+    /// outright on Azure SQL). Hence <see langword="init"/>-only on this
+    /// API — set it in an object initializer
+    /// (<c>new Simulation { ServerCollationName = "…" }</c>) before the
+    /// first <see cref="CreateDbConnection"/> /
+    /// <see cref="ImportBacpac(Stream, out Storage.Bacpac.BacpacImportResult, Storage.Bacpac.BacpacImportOptions?)"/>.
+    /// Per-database divergence after construction goes through
+    /// <c>ALTER DATABASE COLLATE</c>, which only affects the targeted
+    /// database. An unrecognized collation name raises
+    /// <see cref="ArgumentException"/>.
+    /// </remarks>
+    public string ServerCollationName
+    {
+        get => this.ServerCollation.Name;
+        init
+        {
+            ArgumentNullException.ThrowIfNull(value);
+            this.ServerCollation = Collation.TryGet(value)
+                ?? throw new ArgumentException($"Collation '{value}' is not recognized by the simulator.", nameof(value));
+        }
+    }
+
+    /// <summary>
+    /// Resolved <see cref="Collation"/> backing <see cref="ServerCollationName"/>.
+    /// Internal accessor used by <see cref="Database"/> seeding paths
+    /// (<c>SimulatedDbConnection.ResolveInitialDatabase</c>,
+    /// <see cref="ImportBacpac(Stream, out Storage.Bacpac.BacpacImportResult, Storage.Bacpac.BacpacImportOptions?)"/>);
+    /// public callers go through the string-typed property to keep
+    /// <see cref="Collation"/> off the public API surface.
+    /// </summary>
+    internal Collation ServerCollation { get; private set; } = Collation.Default;
+
     /// <summary>
     /// Per-database state hosted by this server instance, keyed by name.
     /// Starts empty; <see cref="SimulatedDbConnection"/>'s constructor

SqlServerSimulator/Storage/SqlValue.cs

@@ -701,7 +701,7 @@ public bool Equals(SqlValue other) =>
         && this.IsNull == other.IsNull
         && (this.IsNull
             || (IsStringTypeRef(this.Type)
-                ? (this.Type.Collation ?? Collation.Default).Equals(TrimTrailing((string)this.reference!), TrimTrailing((string)other.reference!))
+                ? this.Type.Collation!.Equals(TrimTrailing((string)this.reference!), TrimTrailing((string)other.reference!))
                 : this.Type is DateTimeOffsetSqlType
                     ? this.primitive == other.primitive
                     : this.Type == SqlType.UniqueIdentifier
@@ -756,7 +756,7 @@ public int CompareTo(SqlValue other) =>
         : this.Type == SqlType.SmallInt ? this.AsInt16.CompareTo(other.AsInt16)
         : this.Type == SqlType.TinyInt ? this.AsByte.CompareTo(other.AsByte)
         : this.Type == SqlType.Bit ? this.AsBoolean.CompareTo(other.AsBoolean)
-        : IsStringTypeRef(this.Type) ? (this.Type.Collation ?? Collation.Default).Compare(TrimTrailing((string)this.reference!), TrimTrailing((string)other.reference!))
+        : IsStringTypeRef(this.Type) ? this.Type.Collation!.Compare(TrimTrailing((string)this.reference!), TrimTrailing((string)other.reference!))
         : this.Type is RowVersionSqlType ? this.primitive.CompareTo(other.primitive)
         : this.Type is VarbinarySqlType or BinarySqlType or ImageSqlType ? this.AsBytes.AsSpan().SequenceCompareTo(other.AsBytes)
         : this.Type == SqlType.Date ? this.primitive.CompareTo(other.primitive)
@@ -787,7 +787,7 @@ public override int GetHashCode()
         {
             // Trailing spaces and case folding are part of equality, so the
             // hash must agree.
-            hash.Add((this.Type.Collation ?? Collation.Default).GetHashCode(TrimTrailing((string)this.reference!)));
+            hash.Add(this.Type.Collation!.GetHashCode(TrimTrailing((string)this.reference!)));
         }
         else if (this.Type is DateTimeOffsetSqlType)
         {