Added pattern-based implementations of all collations shipped with SQL Server 2025.

Author: RyanLamansky

SqlServerSimulator.Tests.Internal/CollationTests.cs

@@ -5,9 +5,9 @@ namespace SqlServerSimulator;
 /// <summary>
 /// Algorithm-contract tests for the <see cref="Collation"/> implementations
 /// that aren't routed through public SQL today. The default collation's
-/// behavior (<see cref="Collation.Default"/>) and the recognized-name
-/// surface (<see cref="Collation.Recognized"/> /
-/// <see cref="Collation.ByName"/>) are exercised in the public
+/// behavior (<see cref="Collation.Default"/>) and the parser-driven
+/// name-resolution surface (<see cref="Collation.TryGet"/> /
+/// <see cref="Collation.IsRecognized"/>) are exercised in the public
 /// <c>CollationBehaviorTests</c> / <c>CollationMetadataTests</c> /
 /// <c>LikeTests</c>; this file keeps only the dormant comparers
 /// (<see cref="Collation.Latin1General100CiAs"/>,

SqlServerSimulator.Tests/AggregateTests.cs

@@ -413,20 +413,17 @@ public void Max_BitColumn_RaisesMsg8117()
             "Operand data type bit is invalid for max operator.");
 
     /// <summary>
-    /// Under <c>SQL_Latin1_General_CP1_CI_AS</c> (the simulator's default),
-    /// apostrophe is meaningful in sort — its CP1252 code point 0x27 sorts
-    /// before all letters, so MIN of ('Aaronsburg', "'Aiea") is "'Aiea".
-    /// The Windows-style primary-weight-zero treatment that would push
-    /// "'Aiea" alongside "A…" entries is exclusive to
-    /// <c>Latin1_General_100_CI_AS</c> / <c>Latin1_General_CI_AS</c> — see
-    /// <c>SqlServerSimulator.Tests.Internal/CollationTests.cs</c> for the
-    /// direct exercise of that algorithm. Data routing still goes through
-    /// the database default regardless of declared column collation (see
-    /// <c>docs/claude/database-options.md</c>).
+    /// Probe-confirmed against SQL Server 2025: every recognized collation
+    /// (SQL_*, Windows-style, locale) applies <c>IgnoreSymbols</c> in sort
+    /// — apostrophe / hyphen drop out of the primary sort key, so MIN of
+    /// ('Aaronsburg', "'Aiea") returns 'Aaronsburg' because apostrophe is
+    /// stripped from "'Aiea" leaving "Aiea" > "Aaronsburg". Equality keeps
+    /// symbols significant; <see cref="Equality_String_DistinguishesApostrophe"/>
+    /// pins that asymmetry.
     /// </summary>
     [TestMethod]
-    public void Min_String_SqlCollation_ApostropheSortsBeforeLetters()
-        => AreEqual("'Aiea", new Simulation().ExecuteScalar(
+    public void Min_String_DefaultCollation_ApostropheIsIgnoredInSort()
+        => AreEqual("Aaronsburg", new Simulation().ExecuteScalar(
             "create table t (s nvarchar(40) not null); insert t values (N'Aaronsburg'), (N'''Aiea'); select min(s) from t"));
 
     /// <summary>

SqlServerSimulator.Tests/AlterDatabaseOptionsTests.cs

@@ -98,12 +98,20 @@ public void Collate_Default_Accepts()
         => AreEqual(-1, new Simulation().ExecuteNonQuery(
             "ALTER DATABASE claude COLLATE SQL_Latin1_General_CP1_CI_AS"));
 
+    /// <summary>
+    /// Names outside the catalog raise <c>NotSupportedException</c> with the
+    /// "recognized list" wording. Real SQL Server raises Msg 448; the
+    /// simulator's "honest about what's modeled" stance keeps the
+    /// distinction visible. The chosen name <c>MadeUp_Locale_CI_AS</c> has
+    /// a parseable grammar but isn't in the per-prefix tail-set catalog
+    /// (probed against SQL Server 2025).
+    /// </summary>
     [TestMethod]
     public void Collate_NonDefault_RaisesNotSupported()
     {
         var ex = Throws<NotSupportedException>(() =>
-            new Simulation().ExecuteNonQuery("ALTER DATABASE claude COLLATE Japanese_CI_AS"));
-        Contains("Japanese_CI_AS", ex.Message);
+            new Simulation().ExecuteNonQuery("ALTER DATABASE claude COLLATE MadeUp_Locale_CI_AS"));
+        Contains("MadeUp_Locale_CI_AS", ex.Message);
         Contains("recognized list", ex.Message);
     }
 

SqlServerSimulator.Tests/CollationBehaviorTests.cs

@@ -62,13 +62,14 @@ public void DefaultCollation_OrderBy_AsciiLowerVsUpper_IsCaseInsensitive()
     }
 
     /// <summary>
-    /// Apostrophe is significant in the default collation's sort key, so
-    /// <c>'Aaronsburg' &lt; '''Aiea'</c> — apostrophe (0x27) sorts before
-    /// 'a' (0x61). Distinct from the Windows-100 CI_AS variant where the
-    /// apostrophe drops out of the primary sort key.
+    /// Probe-confirmed against SQL Server 2025: the default collation
+    /// applies <c>IgnoreSymbols</c> in sort — apostrophe drops out of the
+    /// primary sort key, so "'Aiea" sorts as "Aiea" which is greater than
+    /// "Aaronsburg". Equality keeps symbols significant — the direct
+    /// asymmetry probe lives in <c>CollationTests</c>.
     /// </summary>
     [TestMethod]
-    public void DefaultCollation_OrderBy_ApostropheIsSignificant()
+    public void DefaultCollation_OrderBy_ApostropheIsIgnored()
     {
         var sim = new Simulation();
         _ = sim.ExecuteNonQuery(
@@ -77,7 +78,7 @@ public void DefaultCollation_OrderBy_ApostropheIsSignificant()
         var rows = new List<string>();
         while (reader.Read())
             rows.Add(reader.GetString(0));
-        CollectionAssert.AreEqual(new[] { "'Aiea", "Aaronsburg" }, rows);
+        CollectionAssert.AreEqual(new[] { "Aaronsburg", "'Aiea" }, rows);
     }
 
     /// <summary>

SqlServerSimulator.Tests/CollationDeclaredColumnTests.cs

@@ -369,16 +369,19 @@ insert dflt values (N'istanbul')
 
     /// <summary>
     /// Unknown collation name raises a clear NotSupportedException (it's
-    /// not on the simulator's recognized whitelist). Probes confirm this
+    /// not on the simulator's recognized catalog). Probes confirm this
     /// is the simulator's "honest about what's modeled" stance, distinct
-    /// from real SQL Server's Msg 448.
+    /// from real SQL Server's Msg 448. <c>Pashto_CI_AS</c> doesn't ship
+    /// (only the v100 form does): the prefix is known, the suffix
+    /// grammar is valid, but the specific combination is absent from
+    /// the per-prefix tail-set catalog.
     /// </summary>
     [TestMethod]
     public void UnknownCollationName_RaisesNotSupported()
     {
         var ex = Throws<NotSupportedException>(() => new Simulation().ExecuteNonQuery(
-            "create table t (s varchar(20) collate Hungarian_CI_AS)"));
-        Contains("Hungarian_CI_AS", ex.Message);
+            "create table t (s varchar(20) collate Pashto_CI_AS)"));
+        Contains("Pashto_CI_AS", ex.Message);
     }
 
     /// <summary>

SqlServerSimulator.Tests/CollationMetadataTests.cs

@@ -114,18 +114,33 @@ public void Column_WithCollate_RoundTripsViaInformationSchema()
             "SELECT COLLATION_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE COLUMN_NAME = 'b'"));
     }
 
+    /// <summary>
+    /// Names structurally valid but absent from the catalog raise
+    /// <c>NotSupportedException</c>. <c>Mapudungan_BIN</c> has a known
+    /// prefix and a recognized suffix grammar but the specific pair
+    /// doesn't ship in real SQL Server (probed 2026-05-21: Mapudungan is
+    /// v100-only).
+    /// </summary>
     [TestMethod]
     public void Column_Collate_UnrecognizedName_RaisesNotSupported()
     {
         var ex = Throws<NotSupportedException>(() => new Simulation().ExecuteNonQuery(
-            "CREATE TABLE t (a nvarchar(50) COLLATE Japanese_CI_AS)"));
-        Contains("Japanese_CI_AS", ex.Message);
+            "CREATE TABLE t (a nvarchar(50) COLLATE Mapudungan_BIN)"));
+        Contains("Mapudungan_BIN", ex.Message);
         Contains("recognized list", ex.Message);
     }
 
+    /// <summary>
+    /// The simulator's catalog matches real SQL Server's
+    /// <c>sys.fn_helpcollations()</c> count — 77 SQL_* names + 5463
+    /// non-SQL_* names = 5540 total, probed against SQL Server 2025 on
+    /// 2026-05-21. The parser validates names against the per-prefix
+    /// tail-set catalog so phantom combinations (grammar-valid but never
+    /// shipped) are rejected.
+    /// </summary>
     [TestMethod]
     public void FnHelpCollations_ListsRecognized()
-        => AreEqual(26, new Simulation().ExecuteScalar(
+        => AreEqual(5540, new Simulation().ExecuteScalar(
             "SELECT COUNT(*) FROM sys.fn_helpcollations()"));
 
     [TestMethod]
@@ -151,6 +166,39 @@ public void FnHelpCollations_ColumnsAreNameAndDescription()
             "SELECT name FROM sys.fn_helpcollations WHERE name = 'Latin1_General_100_CI_AS'"));
     }
 
+    /// <summary>
+    /// Parser-driven catalog accepts the full breadth of real SQL Server
+    /// 2025 names — locale × version × flag combinations beyond the 26
+    /// hand-tuned entries the prior implementation maintained. Probed
+    /// names from each pattern bucket: a v100-only locale (Pattern_0), a
+    /// versioned-and-unversioned locale (Pattern_1), a SQL_* CP1250
+    /// variant, and a v140 + VSS combo (Pattern_6).
+    /// </summary>
+    [TestMethod]
+    [DataRow("Albanian_100_CI_AS", "Albanian-100, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive")]
+    [DataRow("Greek_BIN2", "Greek, binary code point comparison sort")]
+    [DataRow("SQL_Polish_CP1250_CS_AS", "Polish, case-sensitive, accent-sensitive, kanatype-insensitive, width-insensitive for Unicode Data, SQL Server Sort Order 87 on Code Page 1250 for non-Unicode Data")]
+    [DataRow("Japanese_XJIS_140_CI_AS_KS_WS_VSS", "Japanese-XJIS-140, case-insensitive, accent-sensitive, kanatype-sensitive, width-sensitive, supplementary characters, variation selector sensitive")]
+    [DataRow("German_PhoneBook_100_CI_AS_KS_WS_SC_UTF8", "German-PhoneBook-100, case-insensitive, accent-sensitive, kanatype-sensitive, width-sensitive, supplementary characters, UTF8")]
+    public void FnHelpCollations_Description_MatchesProbedSqlServer(string name, string description)
+        => AreEqual(description, new Simulation().ExecuteScalar(
+            $"SELECT description FROM sys.fn_helpcollations WHERE name = '{name}'"));
+
+    /// <summary>
+    /// Grammar-valid but never-shipped name combinations reject — the
+    /// parser validates against the per-prefix tail-set catalog, not just
+    /// the suffix grammar. <c>Pashto_CI_AS</c> (unversioned form of a
+    /// v100-only locale) and <c>Latin1_General_140_BIN</c> (v140 doesn't
+    /// have BIN/BIN2) are both phantom; both reject.
+    /// </summary>
+    [TestMethod]
+    [DataRow("Pashto_CI_AS")]
+    [DataRow("Latin1_General_140_BIN")]
+    [DataRow("Albanian_BIN2_UTF8")]
+    public void PhantomCollationName_RejectedByParser(string name)
+        => Throws<NotSupportedException>(() => new Simulation().ExecuteNonQuery(
+            $"CREATE TABLE t (a nvarchar(50) COLLATE {name})"));
+
     [TestMethod]
     public void SysDatabases_RowShape_CarriesCompatibilityAndIsolation()
     {

SqlServerSimulator/BuiltInResources.cs

@@ -2348,7 +2348,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysServers(Parser.BatchContext b
 
     /// <summary>
     /// Rows for <c>sys.fn_helpcollations()</c>. Emits one row per entry in
-    /// <see cref="Collation.Recognized"/> — the simulator's whitelist of
+    /// <see cref="Collation.IsRecognized"/> — the simulator's whitelist of
     /// metadata-accepted collation names. Real SQL Server returns ~5540
     /// rows here; the simulator's shorter list is honest about which
     /// collation names round-trip through <see cref="Database.CollationName"/>
@@ -2357,8 +2357,8 @@ private static IEnumerable<SqlValue[]> EnumerateSysServers(Parser.BatchContext b
     private static IEnumerable<SqlValue[]> EnumerateFnHelpCollations(Parser.BatchContext batch, Database database)
     {
         _ = batch;
-        foreach (var entry in Collation.Recognized.OrderBy(e => e.Key, StringComparer.Ordinal))
-            yield return [SqlValue.FromSystemName(entry.Key), SqlValue.FromNVarchar(entry.Value)];
+        foreach (var (entryName, entryDesc) in Collation.EnumerateRecognized().OrderBy(e => e.Name, StringComparer.Ordinal))
+            yield return [SqlValue.FromSystemName(entryName), SqlValue.FromNVarchar(entryDesc)];
     }
 
     private static IEnumerable<SqlValue[]> EnumerateSysSequences(Parser.BatchContext batch, Database database)