Database collation is now used instead of the "Default" collation where appropriate.

Author: RyanLamansky

SqlServerSimulator.Tests/NameComparisonRegimeTests.cs

@@ -177,4 +177,76 @@ public void Regime3_SpatialMethod_LowercaseTostring_NotResolved()
     public void Regime3_SpatialStatic_LowercasePoint_NotResolved()
         => _ = Throws<Exception>(() => new Simulation().ExecuteScalar(
             "select cast(geography::point(0, 0, 4326) as varchar(50))"));
+
+    // ===== CS-database fidelity: regime 1 sites flip case-sensitivity =====
+    // Probe-confirmed (2026-05-21): under a case-sensitive database
+    // collation (SQL_Latin1_General_CP1_CS_AS), reserved-name checks,
+    // system-proc dispatch, and CLR-type-prefix lookups all follow the
+    // database collation. Width-folding still applies (IgnoreWidth stays
+    // on under CS_AS — no _WS_ suffix). True system tokens routed through
+    // BuiltInToken (INSERTED / DELETED / OBJECT_ID type filter /
+    // sp_addextendedproperty arg names) stay invariant — those have
+    // dedicated regime-1 coverage in the section above.
+
+    private static Simulation CsCollation()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("ALTER DATABASE simulated COLLATE SQL_Latin1_General_CP1_CS_AS");
+        return sim;
+    }
+
+    [TestMethod]
+    public void CsDatabase_CreateSchemaUppercaseDBO_PassesReservedCheck()
+    {
+        // The reserved-name check follows database collation: under CS,
+        // `DBO` doesn't case-equal the reserved `dbo`, so the check
+        // passes (the schema-creation attempt then proceeds). The
+        // Schemas dict's construction-time CI comparer doesn't rebuild
+        // on ALTER COLLATE (documented fidelity gap on
+        // <see cref="Database.Schemas"/>), so the TryAdd collides with
+        // the pre-seeded `dbo` and raises Msg 2714 "already exists"
+        // instead. Surfacing Msg 2714 (rather than Msg 2760 "reserved")
+        // confirms the reserved-name check now follows DB collation.
+        var ex = CsCollation().AssertSqlError("CREATE SCHEMA DBO", 2714);
+        Assert.Contains("already an object", ex.Message);
+    }
+
+    [TestMethod]
+    public void CsDatabase_CreateSchemaCanonicalDbo_StillRejectedAsReserved()
+        => _ = CsCollation().AssertSqlError("CREATE SCHEMA dbo", 2760);
+
+    [TestMethod]
+    public void CsDatabase_CreateSchemaFullwidthSys_StillRejectedAsReserved()
+    {
+        // Width-folding stays on under CS_AS (no _WS_ suffix), so ｓys
+        // folds to sys and matches the reserved set.
+        _ = CsCollation().AssertSqlError("CREATE SCHEMA ｓys", 2760);
+    }
+
+    [TestMethod]
+    public void CsDatabase_SystemProcSpExecuteSql_UppercaseCase_NotFound()
+        // `SP_EXECUTESQL` doesn't case-equal `sp_executesql` under CS, so
+        // the dispatch falls through to generic user-proc lookup which
+        // also misses → Msg 2812 "Could not find stored procedure".
+        => _ = CsCollation().AssertSqlError("EXEC SP_EXECUTESQL N'select 1'", 2812);
+
+    [TestMethod]
+    public void CsDatabase_SystemProcSpExecuteSql_FullwidthCase_Dispatches()
+        // Probe-confirmed: ｓp_executesql width-folds to sp_executesql
+        // under CS_AS (IgnoreWidth stays on), so dispatch still routes
+        // through the simulator's sp_executesql handler.
+        => AreEqual(1, CsCollation().ExecuteScalar("EXEC ｓp_executesql N'select 1'"));
+
+    [TestMethod]
+    public void CsDatabase_HierarchyIdTypePrefix_UppercaseHIERARCHYID_NotResolved()
+        // hierarchyid:: is the canonical lowercase form; HIERARCHYID
+        // doesn't case-equal it under CS, so the static-call dispatch
+        // misses and the parser raises a syntax error.
+        => _ = Throws<Exception>(() => CsCollation().ExecuteScalar(
+            "SELECT HIERARCHYID::GetRoot()"));
+
+    [TestMethod]
+    public void CsDatabase_HierarchyIdTypePrefix_CanonicalCase_Resolves()
+        => AreEqual("/", CsCollation().ExecuteScalar(
+            "SELECT hierarchyid::GetRoot().ToString()"));
 }

SqlServerSimulator/BuiltInResources.cs

@@ -1410,7 +1410,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysCheckConstraints(Parser.Batch
                     {
                         for (var i = 0; i < table.Columns.Length; i++)
                         {
-                            if (Collation.Default.Equals(table.Columns[i].Name, inlineCol))
+                            if (database.Collation.Equals(table.Columns[i].Name, inlineCol))
                             {
                                 parentColumnId = i + 1;
                                 break;

SqlServerSimulator/BuiltInToken.cs

@@ -74,4 +74,13 @@ public static bool EqualsAny(string? value, params ReadOnlySpan<string> options)
         }
         return false;
     }
+
+    /// <summary>
+    /// Hash code consistent with <see cref="Equals(string?, string?)"/>:
+    /// two strings that compare equal under the built-in-token options
+    /// hash to the same value. Required when a built-in-token-keyed type
+    /// participates in a dictionary or hashset.
+    /// </summary>
+    public static int GetHashCode(string value) =>
+        compareInfo.GetHashCode(value, Options);
 }

SqlServerSimulator/Collation.cs

@@ -66,12 +66,19 @@ private protected Collation()
     public virtual bool CaseSensitive => false;
 
     /// <summary>
-    /// The simulator's default collation — <c>SQL_Latin1_General_CP1_CI_AS</c>.
-    /// Resolved by <see cref="TryGet"/> through the parser; used by
-    /// <see cref="Database.CollationName"/> when no explicit
-    /// <c>ALTER DATABASE COLLATE</c> has landed, and as the fallback when
-    /// a string-typed value's <see cref="SqlType.Collation"/> is
-    /// <see langword="null"/>.
+    /// 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="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.
     /// </summary>
     internal static Collation Default => defaultLazy.Value;
 

SqlServerSimulator/Database.cs

@@ -26,9 +26,11 @@ internal sealed class Database
     /// default <c>dbo</c> schema; <c>CREATE SCHEMA &lt;name&gt;</c> adds more.
     /// Schema-qualified table references (<c>SELECT * FROM audit.t</c>) route
     /// through here; unqualified references fall back to
-    /// <see cref="DefaultSchemaName"/>.
+    /// <see cref="DefaultSchemaName"/>. Comparer is <see cref="Collation"/>
+    /// at the database's construction time; doesn't rebuild if a later
+    /// <c>ALTER DATABASE COLLATE</c> shifts <see cref="Collation"/>.
     /// </summary>
-    public readonly ConcurrentDictionary<string, Schema> Schemas = new(Collation.Default);
+    public readonly ConcurrentDictionary<string, Schema> Schemas;
 
     /// <summary>
     /// Schema-id of the default <c>dbo</c> schema. Matches real SQL Server's
@@ -44,8 +46,19 @@ internal sealed class Database
     public const int SysSchemaId = 4;
 
     public Database(string name)
+        : this(name, Collation.Default)
+    {
+    }
+
+    public Database(string name, Collation collation)
     {
         this.Name = name;
+        this.Collation = collation;
+        this.CollationName = collation.Name;
+        this.Schemas = new(collation);
+        this.DdlTriggers = new(collation);
+        this.Principals = new(collation);
+        this.FullTextCatalogs = new(collation);
         this.Schemas[DefaultSchemaName] = new Schema(this, DefaultSchemaName, DboSchemaId);
         this.Schemas["INFORMATION_SCHEMA"] = new Schema(this, "INFORMATION_SCHEMA", InformationSchemaId);
         this.Schemas["sys"] = new Schema(this, "sys", SysSchemaId);
@@ -87,18 +100,32 @@ public Database(string name)
     public CompatibilityLevel CompatibilityLevel = CompatibilityLevel.Sql170;
 
     /// <summary>
-    /// Database-scope <c>COLLATE</c> declaration. The simulator routes every
-    /// comparison / sort / LIKE through <see cref="Collation.Default"/>
-    /// regardless of what this names — it's a metadata field for BACPAC
-    /// round-trip and catalog-view fidelity (<c>sys.databases.collation_name</c>,
-    /// <c>DATABASEPROPERTYEX(name, 'Collation')</c>,
-    /// <c>INFORMATION_SCHEMA.COLUMNS.COLLATION_NAME</c>). Whitelist of accepted
-    /// names lives in <see cref="Collation.IsRecognized"/>; <c>ALTER DATABASE
-    /// name COLLATE name</c> raises <see cref="NotSupportedException"/> on an
-    /// unrecognized name. Defaults to the simulator's modeled collation
-    /// (<see cref="Collation.Default"/>.Name).
+    /// Database identifier-resolution collation. Drives every catalog dict
+    /// comparer in this database (<see cref="Schemas"/>,
+    /// <see cref="Schema.HeapTables"/>, <see cref="Schema.Functions"/>, …)
+    /// and every <c>BatchContext</c> / <c>Schema</c> identifier-equality
+    /// site. Set once at construction; <c>ALTER DATABASE COLLATE</c>
+    /// updates this so subsequent identifier compares route through the
+    /// 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"/>.
+    /// </summary>
+    public Collation Collation;
+
+    /// <summary>
+    /// Database-scope <c>COLLATE</c> declaration as a string. Surfaces in
+    /// <c>sys.databases.collation_name</c>,
+    /// <c>DATABASEPROPERTYEX(name, 'Collation')</c>, and
+    /// <c>INFORMATION_SCHEMA.COLUMNS.COLLATION_NAME</c>. Kept in sync with
+    /// <see cref="Collation"/>.Name on every <c>ALTER DATABASE COLLATE</c>;
+    /// also seeds the per-column default collation for new columns that
+    /// don't carry an explicit <c>COLLATE</c> clause. Whitelist of accepted
+    /// names lives in <see cref="Collation.IsRecognized"/>; an unrecognized
+    /// name raises <see cref="NotSupportedException"/> from
+    /// <c>ALTER DATABASE COLLATE</c>.
     /// </summary>
-    public string CollationName = Collation.Default.Name;
+    public string CollationName;
 
     /// <summary>
     /// Explicit override of the per-database <c>VERBOSE_TRUNCATION_WARNINGS</c>
@@ -229,7 +256,7 @@ public Database(string name)
     /// and <c>sys.sql_modules</c>. <strong>Not fired</strong> — see
     /// <see cref="DdlTrigger"/> for the no-enforcement rationale.
     /// </summary>
-    public readonly ConcurrentDictionary<string, DdlTrigger> DdlTriggers = new(Collation.Default);
+    public readonly ConcurrentDictionary<string, DdlTrigger> DdlTriggers;
 
     /// <summary>
     /// Per-database principals (users + roles). Pre-seeded with the fixed
@@ -240,7 +267,7 @@ public Database(string name)
     /// model; this dict exists for catalog-view round-trip and for
     /// resolving <c>GRANT … TO &lt;name&gt;</c> at parse time.
     /// </summary>
-    public readonly ConcurrentDictionary<string, DatabasePrincipal> Principals = new(Collation.Default);
+    public readonly ConcurrentDictionary<string, DatabasePrincipal> Principals;
 
     /// <summary>
     /// Per-database permission grants/denies. Populated by
@@ -277,7 +304,7 @@ public Database(string name)
     /// visibility — query-time CONTAINS / FREETEXT predicates raise
     /// <see cref="NotSupportedException"/> rather than evaluate.
     /// </summary>
-    public readonly ConcurrentDictionary<string, FullTextCatalog> FullTextCatalogs = new(Collation.Default);
+    public readonly ConcurrentDictionary<string, FullTextCatalog> FullTextCatalogs;
 
     private int nextFullTextCatalogId;
 
@@ -326,12 +353,12 @@ public bool Equals(ExtendedPropertyKey other) =>
         this.Class == other.Class
         && this.MajorId == other.MajorId
         && this.MinorId == other.MinorId
-        && Collation.Default.Equals(this.Name, other.Name);
+        && BuiltInToken.Equals(this.Name, other.Name);
 
     public override bool Equals(object? obj) => obj is ExtendedPropertyKey other && this.Equals(other);
 
     public override int GetHashCode() =>
-        HashCode.Combine(this.Class, this.MajorId, this.MinorId, Collation.Default.GetHashCode(this.Name));
+        HashCode.Combine(this.Class, this.MajorId, this.MinorId, BuiltInToken.GetHashCode(this.Name));
 
     public static bool operator ==(ExtendedPropertyKey left, ExtendedPropertyKey right) => left.Equals(right);
     public static bool operator !=(ExtendedPropertyKey left, ExtendedPropertyKey right) => !left.Equals(right);

SqlServerSimulator/Parser/BatchContext.cs

@@ -1309,7 +1309,7 @@ public bool TryResolveTable(MultiPartName name, [System.Diagnostics.CodeAnalysis
     /// </summary>
     public void RejectCrossDatabaseMutation(MultiPartName name)
     {
-        if (name.Count == 3 && !Collation.Default.Equals(name[0], this.CurrentDatabase.Name))
+        if (name.Count == 3 && !this.CurrentDatabase.Collation.Equals(name[0], this.CurrentDatabase.Name))
         {
             throw new NotSupportedException(
                 $"Cross-database write to '{name}' isn't modeled. The simulator routes 3-part-name reads (SELECT / JOIN / catalog views) across databases but defers cross-database INSERT / UPDATE / DELETE / MERGE / TRUNCATE / DDL — trigger scope swapping, identity allocation routing, and FK validation across DB boundaries are pending. Issue USE [{name[0]}] from this connection and reference the target with a 1- or 2-part name.");

SqlServerSimulator/Parser/Expression.cs

@@ -220,11 +220,12 @@ public static Expression Parse(ParserContext context)
                         if (secondColon is not Operator { Character: ':' })
                             throw SimulatedSqlException.SyntaxErrorNear(context);
                         context.MoveNextRequired();
-                        expression = Collation.Default.Equals(typeName, "hierarchyid")
+                        var typePrefixCollation = context.Batch.CurrentDatabase.Collation;
+                        expression = typePrefixCollation.Equals(typeName, "hierarchyid")
                             ? HierarchyIdStaticCall.Parse(context)
-                            : Collation.Default.Equals(typeName, "geography")
+                            : typePrefixCollation.Equals(typeName, "geography")
                                 ? SpatialStaticCall.Parse(SqlType.Geography, context)
-                                : Collation.Default.Equals(typeName, "geometry")
+                                : typePrefixCollation.Equals(typeName, "geometry")
                                     ? SpatialStaticCall.Parse(SqlType.Geometry, context)
                                     : throw SimulatedSqlException.SyntaxErrorNear(context);
                         continue;