Made SQL_Latin1_General_CP1_CI_AS as accurate as possible through extensive analysis and reverse-engineering of the official implementation.

Author: RyanLamansky

SqlServerSimulator.Tests.Internal/CollationTests.cs

@@ -52,6 +52,40 @@ public void Sql_NullHandling()
         IsGreaterThan(0, Collation.Baseline.Compare("x", null));
     }
 
+    /// <summary>
+    /// The default collation routes through the byte-exact
+    /// <c>SqlLatin1Cp1CiAsCollation</c> override, which sorts varchar and
+    /// nvarchar through different probe-extracted weight tables. The two
+    /// storage families disagree on symbol order (varchar <c>'+'</c> &lt;
+    /// <c>'/'</c>; nvarchar <c>'/'</c> &lt; <c>'+'</c>) and on ligature
+    /// expansion (both expand <c>æ</c>, but only nvarchar expands <c>ß</c> to
+    /// <c>ss</c> — varchar keeps it a single letter). <c>ForVarcharStorage</c>
+    /// returns the varchar-flavored body. Probe-confirmed on SQL Server 2025.
+    /// </summary>
+    [TestMethod]
+    public void Sql_VarcharAndNvarcharSortThroughDistinctTables()
+    {
+        var nvarchar = Collation.Baseline;
+        var varchar = Collation.Baseline.ForVarcharStorage();
+
+        IsLessThan(0, varchar.Compare("+", "/"));
+        IsGreaterThan(0, nvarchar.Compare("+", "/"));
+
+        // æ expands to "ae" in both: 'æx' (=> 'aex') sorts between 'ad' and 'af'.
+        IsGreaterThan(0, nvarchar.Compare("æx", "ad"));
+        IsLessThan(0, nvarchar.Compare("æx", "af"));
+        IsGreaterThan(0, varchar.Compare("æx", "ad"));
+        IsLessThan(0, varchar.Compare("æx", "af"));
+
+        // ß expands to "ss" only in nvarchar.
+        AreEqual(0, nvarchar.Compare("ß", "ss"));
+        AreNotEqual(0, varchar.Compare("ß", "ss"));
+
+        // Cedilla folds onto its base letter at the primary level in both.
+        IsLessThan(0, varchar.Compare("Çm", "cn"));
+        IsLessThan(0, nvarchar.Compare("Çm", "cn"));
+    }
+
     // ---- Latin1_General_100_CI_AS (Windows-style v100) ----
 
     [TestMethod]

SqlServerSimulator.Tests/CollationBehaviorTests.cs

@@ -142,6 +142,49 @@ public void DefaultCollation_Distinct_HashContractAgreesWithEquals()
         AreEqual(2, sim.ExecuteScalar("select count(*) from (select distinct v from accent) d"));
     }
 
+    /// <summary>
+    /// The default collation sorts at two levels: primary (accent-folded base
+    /// letter) then a secondary accent tie-break. So <c>'à'</c> orders before
+    /// <c>'Ao'</c> (base <c>a</c> precedes <c>Ao</c>) even though the accented
+    /// letter sorts after its plain form within a tie (<c>'az'</c> &lt;
+    /// <c>'àz'</c>). Probe-confirmed against SQL Server 2025; this is the level
+    /// a single-rank table can't express.
+    /// </summary>
+    [TestMethod]
+    public void DefaultCollation_OrderBy_AccentIsSecondaryWeight()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery(
+            "create table t (v nvarchar(20)); insert t values ('Ao'), ('à'), ('az'), ('àz')");
+        using var reader = sim.CreateCommand("select v from t order by v").ExecuteReader();
+        var rows = new List<string>();
+        while (reader.Read())
+            rows.Add(reader.GetString(0));
+        CollectionAssert.AreEqual(new[] { "à", "Ao", "az", "àz" }, rows);
+    }
+
+    /// <summary>
+    /// nvarchar expands the Latin ligatures to their base letters (probe-
+    /// confirmed <c>'æ' = 'ae'</c>, <c>'ß' = 'ss'</c>); varchar's legacy sort
+    /// order expands only <c>æ</c>/<c>Æ</c> and treats <c>œ</c>/<c>ß</c> as
+    /// distinct single-weight letters. Here MIN under nvarchar collapses
+    /// <c>'æ'</c> against <c>'ae'</c> and orders it between <c>'ad'</c> and
+    /// <c>'af'</c>.
+    /// </summary>
+    [TestMethod]
+    public void DefaultCollation_OrderBy_NvarcharExpandsLigatures()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery(
+            "create table t (v nvarchar(20)); insert t values ('ad'), ('af'), ('æx')");
+        using var reader = sim.CreateCommand("select v from t order by v").ExecuteReader();
+        var rows = new List<string>();
+        while (reader.Read())
+            rows.Add(reader.GetString(0));
+        // 'æx' expands to 'aex', which sorts between 'ad' and 'af'.
+        CollectionAssert.AreEqual(new[] { "ad", "æx", "af" }, rows);
+    }
+
     [TestMethod]
     public void CollationName_LookupIsCaseInsensitive()
     {

SqlServerSimulator/Collation.Parser.cs

@@ -41,17 +41,6 @@ private enum CollationFlags : ushort
         VariationSelectorSensitive = 1 << 10,
     }
 
-    /// <summary>
-    /// Per-name override registry. Populated by <see cref="RegisterOverride"/>
-    /// at static-init time. Names in this map bypass <see cref="TryParse"/>
-    /// and return the registered instance directly — the extension point
-    /// for hand-tuned bodies with quirky semantics that the parser's
-    /// generic <see cref="CultureCollation"/> / <see cref="BinaryCollationBody"/>
-    /// constructions don't capture.
-    /// </summary>
-    private static readonly ConcurrentDictionary<string, Collation> overrides =
-        new(StringComparer.OrdinalIgnoreCase);
-
     /// <summary>
     /// Interning cache for parser-derived collation instances. Keyed by the
     /// canonical (uppercase) name; <see cref="TryGet"/> inserts on first
@@ -64,41 +53,29 @@ private enum CollationFlags : ushort
     /// <summary>
     /// Returns the recognized <see cref="Collation"/> for <paramref name="name"/>,
     /// or <see langword="null"/> if the name isn't grammatically valid +
-    /// doesn't carry a known prefix. Override-registry entries take
-    /// precedence over the parser; subsequent calls with the same name
-    /// return the same reference (interned).
+    /// doesn't carry a known prefix. Subsequent calls with the same name
+    /// return the same reference (interned). The default collation name is
+    /// special-cased inside <see cref="CreateInstance"/> to wrap its comparer
+    /// in the byte-exact <see cref="SqlLatin1Cp1CiAsCollation"/>.
     /// </summary>
     internal static Collation? TryGet(string name) =>
         string.IsNullOrEmpty(name)
             ? null
-            : overrides.TryGetValue(name, out var ov)
-                ? ov
-                : interned.TryGetValue(name, out var hit)
-                    ? hit
-                    : TryParse(name, out var parsed) ? interned.GetOrAdd(parsed.Name, parsed) : null;
-
-    /// <summary>
-    /// Adds <paramref name="specialized"/> to the override registry under
-    /// its <see cref="Name"/>. Overrides take precedence over parser-derived
-    /// instances; the slot supports per-name behavior tuning when the
-    /// parser's generic body doesn't match real SQL Server's quirks for
-    /// that specific collation.
-    /// </summary>
-    private static void RegisterOverride(Collation specialized) =>
-        overrides[specialized.Name] = specialized;
+            : interned.TryGetValue(name, out var hit)
+                ? hit
+                : TryParse(name, out var parsed) ? interned.GetOrAdd(parsed.Name, parsed) : null;
 
     /// <summary>
     /// True if <paramref name="name"/> is a recognized SQL Server collation
-    /// name — either in the override registry or grammatically parseable
-    /// with a known prefix. Replaces the legacy whitelist check.
+    /// name — grammatically parseable with a known prefix. Replaces the legacy
+    /// whitelist check.
     /// </summary>
     internal static bool IsRecognized(string name) => TryGet(name) is not null;
 
     /// <summary>
     /// Enumerates every recognized collation name with its description
     /// (the form <c>sys.fn_helpcollations()</c> exposes). Crosses the
-    /// SQL_* sort-order table, the per-prefix tail-set patterns, and any
-    /// override-registry entries that fall outside those (rare). Ordering
+    /// SQL_* sort-order table and the per-prefix tail-set patterns. Ordering
     /// is the caller's responsibility.
     /// </summary>
     internal static IEnumerable<(string Name, string Description)> EnumerateRecognized()
@@ -121,33 +98,6 @@ private static void RegisterOverride(Collation specialized) =>
                     yield return (name, c.Description);
             }
         }
-
-        // Override entries whose names don't appear in either slice.
-        foreach (var (name, c) in overrides)
-        {
-            if (!SqlServerSortOrders.ContainsKey(name) && !IsInPatternCatalog(name))
-                yield return (name, c.Description);
-        }
-    }
-
-    /// <summary>
-    /// Tests whether <paramref name="name"/> falls in the per-prefix tail
-    /// catalog — used to avoid double-emitting an override that the
-    /// pattern enumeration would also produce.
-    /// </summary>
-    private static bool IsInPatternCatalog(string name)
-    {
-        foreach (var (prefix, patternIdx) in PrefixToPattern)
-        {
-            if (name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)
-                && name.Length > prefix.Length
-                && name[prefix.Length] == '_'
-                && GetPatternTails(patternIdx).Contains(name[prefix.Length..]))
-            {
-                return true;
-            }
-        }
-        return false;
     }
 
     /// <summary>
@@ -338,7 +288,14 @@ private static Collation CreateInstance(string name, string prefix, PrefixInfo p
         // SC behavior is engaged when the _SC_ flag is set explicitly or
         // when the version is v140+ (where SC is implicit / default).
         var scAware = flags.HasFlag(CollationFlags.SupplementaryCharacters) || version is >= 140;
-        return new CultureCollation(name, description, prefixInfo.CultureName, caseSensitive, kanaSensitive, widthSensitive, storageEncoding, scAware);
+        var cultureBody = new CultureCollation(name, description, prefixInfo.CultureName, caseSensitive, kanaSensitive, widthSensitive, storageEncoding, scAware);
+
+        // The default collation gets a byte-exact sort body wrapping the
+        // generic culture comparer (which still supplies metadata + the
+        // non-CP1252 fallback). See Collation.SqlLatin1Sort.cs.
+        return name.Equals(SqlLatin1Cp1CiAsCollation.CollationName, StringComparison.OrdinalIgnoreCase)
+            ? new SqlLatin1Cp1CiAsCollation(cultureBody)
+            : cultureBody;
     }
 
     /// <summary>