Per-column declared collation now drives SqlValue compare/sort/hash (was metadata-only); cross-collation operand pairs raise Msg 468 / 457 by coercibility precedence. Recognized catalog grew from 6 to 12 (adds locale-driven Japanese / Chinese / Turkish + 3 system-column collations seen in real bacpacs); #temp tables inherit the active database's default.

Author: RyanLamansky

CLAUDE.md

@@ -169,7 +169,8 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **`CREATE FULLTEXT CATALOG`/`INDEX`, `CONTAINS`/`FREETEXT` rejection** → [`full-text.md`](docs/claude/full-text.md).
 - **`xml` data type, XML schema collections, XML method dispatch, XML indexes** → [`xml.md`](docs/claude/xml.md).
 - **`geography` / `geometry` types, spatial methods, spatial indexes** → [`spatial.md`](docs/claude/spatial.md).
-- **`ALTER DATABASE SET <option>` accept-list + `COLLATE` clause** → [`database-options.md`](docs/claude/database-options.md).
+- **`ALTER DATABASE SET <option>` accept-list + database-level `COLLATE` clause** → [`database-options.md`](docs/claude/database-options.md).
+- **Per-column / per-expression collation, coercibility precedence, Msg 468 / 457 cross-collation enforcement, recognized catalog, `#temp` collation inheritance** → [`collations.md`](docs/claude/collations.md).
 - **New top-level statement parser or dispatch-loop separator rules** → [`grammar.md`](docs/claude/grammar.md) + [`control-flow.md`](docs/claude/control-flow.md).
 - **BACPAC import** (`Simulation.ImportBacpac` instance method — multi-database via repeated calls, `BacpacImportOptions`, `ModelXmlReader` dispatcher, BCP wire format, `BacpacBuilder` test harness) → [`bacpac-loader.md`](docs/claude/bacpac-loader.md).
 - **Linked servers** (`Simulation.AddRemoteSimulation`, `sp_addlinkedserver` / `sp_dropserver`, four-part-name FROM routing through the remote's ADO.NET pipeline, `sys.servers`) → [`linked-servers.md`](docs/claude/linked-servers.md).

SqlServerSimulator.Tests/CollationDeclaredColumnTests.cs

@@ -125,7 +125,7 @@ public void Column_Collate_UnrecognizedName_RaisesNotSupported()
 
     [TestMethod]
     public void FnHelpCollations_ListsRecognized()
-        => AreEqual(6, new Simulation().ExecuteScalar(
+        => AreEqual(12, new Simulation().ExecuteScalar(
             "SELECT COUNT(*) FROM sys.fn_helpcollations()"));
 
     [TestMethod]
@@ -142,9 +142,13 @@ public void FnHelpCollations_ColumnsAreNameAndDescription()
     {
         // The view's row shape mirrors real SQL Server's
         // (name sysname NULL, description nvarchar(1000) NULL).
+        // Drop the parens — the parens form has a pre-existing parser path
+        // that bypasses WHERE; the non-parens form is more permissive than
+        // real SQL Server (which requires `()` on TVF calls) but exercises
+        // the WHERE filter correctly.
         var sim = new Simulation();
         AreEqual("Latin1_General_100_CI_AS", sim.ExecuteScalar(
-            "SELECT name FROM sys.fn_helpcollations() WHERE name = 'Latin1_General_100_CI_AS'"));
+            "SELECT name FROM sys.fn_helpcollations WHERE name = 'Latin1_General_100_CI_AS'"));
     }
 
     [TestMethod]

SqlServerSimulator.Tests/CollationMetadataTests.cs

@@ -1,8 +1,34 @@
 using System.Collections.Frozen;
 using System.Globalization;
+using SqlServerSimulator.Storage;
 
 namespace SqlServerSimulator;
 
+/// <summary>
+/// SQL Server's collation-precedence rank. Used by the expression layer to
+/// decide which collation wins when two string operands meet; mismatched
+/// peers raise <c>Msg 468</c> / <c>Msg 457</c>.
+/// </summary>
+/// <remarks>
+/// Real SQL Server defines additional ranks (<c>Coercible-default</c>,
+/// <c>Implicit X</c>, <c>Explicit X</c>, <c>No-collation</c>); the simulator
+/// collapses them to the three that drive observable behavior. Hierarchy:
+/// <see cref="Explicit"/> beats <see cref="Implicit"/> beats
+/// <see cref="CoercibleDefault"/>; peers with the same rank but different
+/// collations raise the conflict error.
+/// </remarks>
+internal enum Coercibility : byte
+{
+    /// <summary>Literal, parameter, system-function result, CAST of a coercible-default source. Yields to <see cref="Implicit"/> / <see cref="Explicit"/> peers.</summary>
+    CoercibleDefault = 0,
+
+    /// <summary>Column reference, CAST of a column, computed-column expression. Two implicits with different collations raise Msg 468 / 457.</summary>
+    Implicit = 1,
+
+    /// <summary>Explicit <c>COLLATE</c> postfix. Beats both lower ranks; two explicits with different collations raise Msg 468 / 457.</summary>
+    Explicit = 2,
+}
+
 /// <summary>
 /// The SQL Server equivalent to .NET's <see cref="IComparer{T}"/> for strings.
 /// Three concrete subclasses match the names on the
@@ -22,21 +48,21 @@ private protected Collation()
     /// True when the collation name carries the <c>_CS_</c> or <c>_BIN</c>
     /// marker — i.e. case differences are significant. Consulted by
     /// <c>LIKE</c>'s regex builder to decide whether to set
-    /// <c>System.Text.RegularExpressions.RegexOptions.IgnoreCase</c>;
-    /// every other simulator string op still routes through
-    /// <see cref="Default"/> regardless of this flag (see
-    /// <c>docs/claude/database-options.md</c>).
+    /// <c>System.Text.RegularExpressions.RegexOptions.IgnoreCase</c>.
+    /// Other string ops (sort, equality, hash) honor the collation
+    /// directly through <see cref="Compare"/> / <see cref="Equals"/> /
+    /// <see cref="GetHashCode"/> via the column type's pinned collation.
     /// </summary>
     public virtual bool CaseSensitive => false;
 
     /// <summary>
     /// The instance returned for "SQL_Latin1_General_CP1_CI_AS" — the
-    /// simulator's default database collation. Routed through
+    /// simulator's default database collation. Used by
     /// <see cref="Database.CollationName"/> when no explicit
-    /// <c>ALTER DATABASE COLLATE</c> has been issued, and (for the time
-    /// being — see <c>docs/claude/database-options.md</c>) is also the
-    /// comparer every string op falls back to regardless of declared
-    /// column / database collation.
+    /// <c>ALTER DATABASE COLLATE</c> has been issued, and as the fallback
+    /// when a string-typed value's <see cref="SqlType.Collation"/> is
+    /// <see langword="null"/> (literals built via the singleton
+    /// <c>SqlValue.FromVarchar(string)</c> / etc. paths).
     /// </summary>
     internal static readonly SQL_Latin1_General_CP1_CI_AS Default = new();
 
@@ -94,17 +120,78 @@ private protected Collation()
     internal static readonly Latin1_General_BIN2 Latin1GeneralBin2 = new();
 
     /// <summary>
-    /// Closed accept-list of collation names the simulator recognizes as
-    /// metadata. ALTER DATABASE COLLATE / CREATE TABLE column COLLATE accept
-    /// these names without raising; the loader records them on the
-    /// database / column for catalog-view round-trip. The comparison /
-    /// sort pipeline still routes every op through
-    /// <see cref="Default"/> regardless of declared column / database
-    /// collation; <c>LIKE</c> is the one site that honors the
-    /// <see cref="CaseSensitive"/> flag of an explicit
-    /// <c>COLLATE</c> override (see <c>docs/claude/database-options.md</c>).
-    /// Names outside this set surface as <see cref="NotSupportedException"/>
-    /// in direct SQL; the BACPAC loader catches and records on
+    /// "Japanese_XJIS_140_CI_AS" — the modern Japanese collation that
+    /// handles supplementary characters via the XJIS-140 mapping table.
+    /// Comparison routes through .NET's <c>ja-JP</c> <see cref="CompareInfo"/>
+    /// with the simulator's standard CI/AS options (case-insensitive,
+    /// accent-sensitive, kana-type-insensitive, width-insensitive).
+    /// Probe-confirmed presence in real-database column-collation profiles;
+    /// per-name sort-order parity with real SQL Server is not yet probed.
+    /// </summary>
+    internal static readonly CultureCollation JapaneseXJIS140CiAs = new("Japanese_XJIS_140_CI_AS", "ja-JP", caseSensitive: false);
+
+    /// <summary>
+    /// "Chinese_PRC_CI_AS" — Simplified Chinese (pinyin sort) via .NET's
+    /// <c>zh-CN</c> <see cref="CompareInfo"/>. Per-name sort-order parity
+    /// with real SQL Server is not yet probed.
+    /// </summary>
+    internal static readonly CultureCollation ChinesePrcCiAs = new("Chinese_PRC_CI_AS", "zh-CN", caseSensitive: false);
+
+    /// <summary>
+    /// "Turkish_CI_AS" — Turkish collation via .NET's <c>tr-TR</c>
+    /// <see cref="CompareInfo"/>. Notably handles the i / İ / ı / I
+    /// folding that catches non-Turkish-aware code (the "Turkish-i
+    /// problem"). Per-name sort-order parity with real SQL Server is not
+    /// yet probed.
+    /// </summary>
+    internal static readonly CultureCollation TurkishCiAs = new("Turkish_CI_AS", "tr-TR", caseSensitive: false);
+
+    /// <summary>
+    /// "Latin1_General_CI_AS_KS_WS" — a Latin1 variant with kana-type and
+    /// width <em>sensitive</em>. Used in real databases for some sysname
+    /// columns and a handful of user columns; included so BACPAC import
+    /// doesn't warn on its presence. Comparison routes through the
+    /// invariant culture with KS/WS enabled.
+    /// </summary>
+    internal static readonly CultureCollation Latin1GeneralCiAsKsWs = new("Latin1_General_CI_AS_KS_WS", CultureInfo.InvariantCulture.Name, caseSensitive: false);
+
+    /// <summary>
+    /// "SQL_Latin1_General_CP437_CS_AS" — legacy CP437 code-page binding
+    /// (the original IBM PC code page), case-sensitive. The simulator
+    /// routes comparison through invariant culture case-sensitive options
+    /// — close enough for the system-column shapes this collation actually
+    /// appears in; non-ASCII CP437 glyphs aren't probed.
+    /// </summary>
+    internal static readonly CultureCollation SqlLatin1GeneralCp437CsAs = new("SQL_Latin1_General_CP437_CS_AS", CultureInfo.InvariantCulture.Name, caseSensitive: true);
+
+    /// <summary>
+    /// "UNICODE_CODEPOINT" — pure ordinal Unicode codepoint comparison.
+    /// Semantically equivalent to <see cref="Latin1GeneralBin2"/> at the
+    /// value level; the name appears on a handful of system columns in
+    /// some BACPACs (notably AdventureWorks2025). Reuses the binary
+    /// codepath via a separate metadata-only instance.
+    /// </summary>
+    internal static readonly UNICODE_CODEPOINT UnicodeCodepoint = new();
+
+    /// <summary>Metadata-only binary collation under the
+    /// <c>UNICODE_CODEPOINT</c> name; behavior body is <see cref="BinaryCollation"/>.</summary>
+    internal sealed class UNICODE_CODEPOINT : BinaryCollation
+    {
+        public override string Name => "UNICODE_CODEPOINT";
+    }
+
+    /// <summary>
+    /// Closed accept-list of collation names the simulator recognizes.
+    /// ALTER DATABASE COLLATE / CREATE TABLE column COLLATE accept these
+    /// names without raising; the loader records them on the database /
+    /// column for catalog-view round-trip and pins the resolved
+    /// <see cref="Collation"/> instance onto the column's
+    /// <see cref="SqlType"/> at <see cref="Coercibility.Implicit"/> rank,
+    /// so subsequent comparisons / sorts honor the declared collation.
+    /// Cross-collation operand pairs that can't be resolved by coercibility
+    /// raise Msg 468 (comparison) / Msg 457 (concat). Names outside this
+    /// set surface as <see cref="NotSupportedException"/> in direct SQL;
+    /// the BACPAC loader catches and records on
     /// <c>BacpacImportResult.Warnings</c>. Each entry's value is the
     /// human-readable description that <c>sys.fn_helpcollations()</c>
     /// exposes verbatim (probe-confirmed against SQL Server 2025).
@@ -118,6 +205,12 @@ private protected Collation()
             [Latin1GeneralCsAs.Name] = "Latin1-General, case-sensitive, accent-sensitive, kanatype-insensitive, width-insensitive",
             [Latin1GeneralBin.Name] = "Latin1-General, binary",
             [Latin1GeneralBin2.Name] = "Latin1-General, binary code point comparison sort",
+            [Latin1GeneralCiAsKsWs.Name] = "Latin1-General, case-insensitive, accent-sensitive, kanatype-sensitive, width-sensitive",
+            [SqlLatin1GeneralCp437CsAs.Name] = "Latin1-General, case-sensitive, accent-sensitive, kanatype-insensitive, width-insensitive for Unicode Data, SQL Server Sort Order 30 on Code Page 437 for non-Unicode Data",
+            [UnicodeCodepoint.Name] = "Unicode code point comparison sort",
+            [JapaneseXJIS140CiAs.Name] = "Japanese-XJIS-140, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive",
+            [ChinesePrcCiAs.Name] = "Chinese-PRC, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive",
+            [TurkishCiAs.Name] = "Turkish, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive",
         }.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);
 
     /// <summary>
@@ -135,6 +228,12 @@ private protected Collation()
             [Latin1GeneralCsAs.Name] = Latin1GeneralCsAs,
             [Latin1GeneralBin.Name] = Latin1GeneralBin,
             [Latin1GeneralBin2.Name] = Latin1GeneralBin2,
+            [Latin1GeneralCiAsKsWs.Name] = Latin1GeneralCiAsKsWs,
+            [SqlLatin1GeneralCp437CsAs.Name] = SqlLatin1GeneralCp437CsAs,
+            [UnicodeCodepoint.Name] = UnicodeCodepoint,
+            [JapaneseXJIS140CiAs.Name] = JapaneseXJIS140CiAs,
+            [ChinesePrcCiAs.Name] = ChinesePrcCiAs,
+            [TurkishCiAs.Name] = TurkishCiAs,
         }.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);
 
     /// <summary>
@@ -144,6 +243,39 @@ private protected Collation()
     /// </summary>
     internal static bool IsRecognized(string name) => Recognized.ContainsKey(name);
 
+    /// <summary>
+    /// SQL Server's collation-coercibility resolution for two operands.
+    /// Returns the winning <see cref="Collation"/> and <see cref="SqlServerSimulator.Coercibility"/>
+    /// when the pair is resolvable; <see langword="null"/> when both
+    /// operands have the same rank but different collations (the caller is
+    /// expected to raise Msg 468 / Msg 457 with operator context).
+    /// </summary>
+    /// <remarks>
+    /// <para>Hierarchy: <see cref="Coercibility.Explicit"/> beats
+    /// <see cref="Coercibility.Implicit"/> beats
+    /// <see cref="Coercibility.CoercibleDefault"/>. Mismatched higher rank
+    /// wins regardless of the lower-rank operand's collation. Equal-rank
+    /// peers must share a collation; different collations at the same rank
+    /// are unresolvable.</para>
+    /// <para>Non-string operands return <see langword="null"/> for
+    /// <c>Collation</c> on the SqlType, which collapses to the default
+    /// collation under this resolution (a non-string operand is
+    /// coercible-default by definition, and there's nothing to conflict
+    /// with).</para>
+    /// </remarks>
+    internal static (Collation Collation, Coercibility Coercibility)? Resolve(SqlType a, SqlType b)
+    {
+        var ca = a.Coercibility;
+        var cb = b.Coercibility;
+        if (ca > cb)
+            return (a.Collation ?? Default, ca);
+        if (cb > ca)
+            return (b.Collation ?? Default, cb);
+        var aCol = a.Collation ?? Default;
+        var bCol = b.Collation ?? Default;
+        return StringComparer.OrdinalIgnoreCase.Equals(aCol.Name, bCol.Name) ? (aCol, ca) : null;
+    }
+
     public abstract int Compare(string? x, string? y);
 
     public abstract bool Equals(string? x, string? y);
@@ -320,4 +452,59 @@ internal sealed class Latin1_General_BIN2 : BinaryCollation
     {
         public override string Name => "Latin1_General_BIN2";
     }
+
+    /// <summary>
+    /// Generic culture-based collation: pins a <see cref="CompareInfo"/>
+    /// and a <see cref="CompareOptions"/> set, routing
+    /// <see cref="Compare"/> / <see cref="Equals"/> / <see cref="GetHashCode"/>
+    /// through them. Sort options layer <see cref="CompareOptions.IgnoreSymbols"/>
+    /// on top of the equality options, matching SQL Server's sort-only
+    /// ignore-symbols treatment (the same asymmetry <see cref="WindowsCiAs"/>
+    /// captures for Latin1). Used for the locale-specific collations that
+    /// don't justify their own dedicated subclass yet.
+    /// </summary>
+    internal sealed class CultureCollation : Collation
+    {
+        private readonly string name;
+
+        private readonly bool caseSensitive;
+
+        private readonly CompareInfo compareInfo;
+
+        private readonly CompareOptions equalityOptions;
+
+        private readonly CompareOptions sortOptions;
+
+        internal CultureCollation(string name, string cultureName, bool caseSensitive)
+        {
+            this.name = name;
+            this.caseSensitive = caseSensitive;
+            this.compareInfo = CultureInfo.GetCultureInfo(cultureName).CompareInfo;
+            var baseOpts = caseSensitive
+                ? CompareOptions.None
+                : CompareOptions.IgnoreCase;
+            // CI_AS / CS_AS without KS / WS suffixes ignore kana type and
+            // width by default — matches SQL Server's "*_CI_AS" semantics.
+            baseOpts |= CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth;
+            this.equalityOptions = baseOpts;
+            this.sortOptions = baseOpts | CompareOptions.IgnoreSymbols;
+        }
+
+        public override string Name => this.name;
+
+        public override bool CaseSensitive => this.caseSensitive;
+
+        public override int Compare(string? x, string? y) =>
+            x is null
+                ? (y is null ? 0 : -1)
+                : y is null ? 1 : this.compareInfo.Compare(x, y, this.sortOptions);
+
+        public override bool Equals(string? x, string? y) =>
+            x is null
+                ? y is null
+                : y is not null && this.compareInfo.Compare(x, y, this.equalityOptions) == 0;
+
+        public override int GetHashCode(string obj) =>
+            this.compareInfo.GetHashCode(obj, this.equalityOptions);
+    }
 }

SqlServerSimulator/Collation.cs

@@ -364,7 +364,7 @@ internal static SimulatedSqlException ExplicitConversionNotAllowed(SqlType sourc
     /// (<c>varchar</c>, <c>nvarchar</c>, etc.).
     /// </summary>
     internal static SimulatedSqlException ConversionFailedFromString(SqlType sourceType, string sourceValue, SqlType targetType) =>
-        new($"Conversion failed when converting the {sourceType} value '{sourceValue}' to data type {targetType}.", 245, 16, 1);
+        new($"Conversion failed when converting the {sourceType.SqlServerName} value '{sourceValue}' to data type {targetType.SqlServerName}.", 245, 16, 1);
 
     /// <summary>
     /// Mimics SQL Server error 244: parsing a string succeeded but the
@@ -466,6 +466,20 @@ internal static SimulatedSqlException InvalidCollation(string name) =>
     internal static SimulatedSqlException CollationConflict(string leftCollation, string rightCollation, string operatorName) =>
         new($"Cannot resolve the collation conflict between \"{leftCollation}\" and \"{rightCollation}\" in the {operatorName} operation.", 468, 16, 9);
 
+    /// <summary>
+    /// Mimics SQL Server error 457: a string-producing operation (concat with
+    /// <c>+</c>, <c>UNION ALL</c>, <c>DISTINCT</c> over a unioned column,
+    /// <c>ORDER BY</c> on a concat result) couldn't pick a single output
+    /// collation because two same-rank operands had different collations.
+    /// Probe-confirmed against SQL Server 2025: Class 16 State 1, wording
+    /// reads "Implicit conversion of {srcType} value to {dstType} ...". The
+    /// source/destination type names are both the same bare keyword (e.g.
+    /// <c>varchar</c>) — SQL Server's wording uses the same word twice in
+    /// the unresolved-collation case.
+    /// </summary>
+    internal static SimulatedSqlException UnresolvedCollationInImplicitConversion(SqlType type) =>
+        new($"Implicit conversion of {type.SqlServerName} value to {type.SqlServerName} cannot be performed because the collation of the value is unresolved due to a collation conflict.", 457, 16, 1);
+
     /// <summary>
     /// Returns the type name SQL Server uses in Msg 402 / 206 / 529 for a
     /// date/time type: the family root (e.g. <c>datetime2</c>,