Collation information is now carried into string literals. Minor documentation cleanup.

Author: RyanLamansky

SqlServerSimulator.Tests.Internal/Parser/TokenLineNumberTests.cs

@@ -77,7 +77,7 @@ public void NewlineWithinACommentToken_PushesLaterTokensDown()
     private static IEnumerable<Token> TokenizeMeaningful(string command)
     {
         var index = 0;
-        while (Tokenizer.NextToken(command, ref index) is Token t)
+        while (Tokenizer.NextToken(command, ref index, Collation.Default) is Token t)
         {
             if (t is Whitespace or Comment)
                 continue;

SqlServerSimulator.Tests/NameComparisonRegimeTests.cs

@@ -335,4 +335,26 @@ public void CsDatabase_NCharFunctionResultUsesActiveCollation()
     [TestMethod]
     public void CiDatabase_CharFunctionResult_StillEqualsUnderCi()
         => AreEqual("eq", new Simulation().ExecuteScalar("SELECT IIF(CHAR(65) = CHAR(97), 'eq', 'neq')"));
+
+    // ===== String literals carry the active DB collation =====
+    // Tokenizer.NextToken receives the executing database's collation and
+    // tags every 'foo' / N'foo' literal with it at CoercibleDefault, so
+    // literal-vs-literal comparisons in a CS database evaluate
+    // case-sensitively without needing a column to anchor the rank.
+
+    [TestMethod]
+    public void CsDatabase_TwoVarcharLiteralsCompareCaseSensitively()
+        => AreEqual("neq",
+            new Simulation { ServerCollationName = "SQL_Latin1_General_CP1_CS_AS" }
+                .ExecuteScalar("SELECT IIF('A' = 'a', 'eq', 'neq')"));
+
+    [TestMethod]
+    public void CsDatabase_TwoNVarcharLiteralsCompareCaseSensitively()
+        => AreEqual("neq",
+            new Simulation { ServerCollationName = "SQL_Latin1_General_CP1_CS_AS" }
+                .ExecuteScalar("SELECT IIF(N'A' = N'a', 'eq', 'neq')"));
+
+    [TestMethod]
+    public void CiDatabase_TwoVarcharLiterals_StillEqualUnderCi()
+        => AreEqual("eq", new Simulation().ExecuteScalar("SELECT IIF('A' = 'a', 'eq', 'neq')"));
 }

SqlServerSimulator/Collation.cs

@@ -172,7 +172,7 @@ internal static (Collation Collation, Coercibility Coercibility)? Resolve(SqlTyp
 
     /// <summary>
     /// Generic culture-driven collation. Pins a
-    /// <see cref="System.Globalization.CompareInfo"/> and a flag-derived
+    /// <see cref="CompareInfo"/> and a flag-derived
     /// <see cref="CompareOptions"/> set; routes <see cref="Compare"/> /
     /// <see cref="Equals"/> / <see cref="GetHashCode"/> through them.
     /// Sort options layer <see cref="CompareOptions.IgnoreSymbols"/> on

SqlServerSimulator/Parser/ParserContext.cs

@@ -266,7 +266,7 @@ public void MoveNextRequired<T>()
     [MemberNotNullWhen(true, nameof(Token))]
     public bool MoveNext()
     {
-        while (Tokenizer.NextToken(commandText, ref index) is Token token)
+        while (Tokenizer.NextToken(commandText, ref index, this.CurrentDatabase.Collation) is Token token)
         {
             if (token is Whitespace or Comment)
                 continue;

SqlServerSimulator/Parser/Tokenizer.cs

@@ -22,6 +22,15 @@ namespace SqlServerSimulator.Parser;
 /// while characters match, stop at the first that doesn't, return — the
 /// natural exit position of that loop is already correct.
 /// </para>
+/// <para>
+/// <b>Active collation.</b> String literals (<c>'foo'</c>, <c>N'foo'</c>)
+/// produce <see cref="SqlValue"/>s tagged with the active database
+/// collation at <see cref="Coercibility.CoercibleDefault"/>, matching
+/// real SQL Server's rule that a string literal inherits the executing
+/// database's collation. Callers thread <see cref="ParserContext.CurrentDatabase"/>'s
+/// collation into <see cref="NextToken"/>; other literal kinds (varbinary,
+/// money) don't carry collation and ignore the parameter.
+/// </para>
 /// </remarks>
 static class Tokenizer
 {
@@ -30,17 +39,18 @@ static class Tokenizer
     /// </summary>
     /// <param name="command">The command from which a token is produced.</param>
     /// <param name="index">The position of the next un-read character (0 to begin); updated to the next un-read position past the returned token.</param>
+    /// <param name="activeCollation">Collation tagged onto string-literal <see cref="SqlValue"/>s; supplied by the caller's active <see cref="Database"/>.</param>
     /// <returns>The next token, or null if the end of <paramref name="command"/> has been reached.</returns>
     /// <exception cref="SimulatedSqlException">Incorrect or unsupported syntax.</exception>
-    public static Token? NextToken(string command, ref int index) =>
+    public static Token? NextToken(string command, ref int index, Collation activeCollation) =>
         index >= command.Length ? null : command[index] switch
         {
             ' ' or '\r' or '\n' or '\t' => ParseWhitespace(command, ref index),
-            'N' or 'n' when index + 1 < command.Length && command[index + 1] == '\'' => ParseNPrefixedStringLiteral(command, ref index),
+            'N' or 'n' when index + 1 < command.Length && command[index + 1] == '\'' => ParseNPrefixedStringLiteral(command, ref index, activeCollation),
             '_' or (>= 'A' and <= 'Z') or (>= 'a' and <= 'z') => ParseUnquotedStringOrReservedKeyword(command, ref index),
             '0' when index + 1 < command.Length && (command[index + 1] == 'x' || command[index + 1] == 'X') => ParseHexLiteral(command, ref index),
             >= '0' and <= '9' => ParseNumeric(command, ref index),
-            '\'' => ParseStringLiteral(command, ref index),
+            '\'' => ParseStringLiteral(command, ref index, activeCollation),
             '@' => ParseAtOrDoubleAtPrefixedString(command, ref index),
             '#' => ParseHashPrefixedName(command, ref index),
             '-' => ParseMinusOrComment(command, ref index),
@@ -195,9 +205,11 @@ private static Token ParseForwardSlashOrComment(string command, ref int index)
     /// <summary>
     /// Parses a SQL string literal: <c>'foo'</c>, with <c>''</c> as the
     /// embedded-apostrophe escape. The opening quote is at <paramref name="index"/>;
-    /// returns a <see cref="Literal"/> typed as <see cref="SqlType.Varchar"/>.
+    /// returns a <see cref="Literal"/> typed as <see cref="SqlType.Varchar"/>
+    /// tagged with <paramref name="activeCollation"/> at
+    /// <see cref="Coercibility.CoercibleDefault"/>.
     /// </summary>
-    private static Literal ParseStringLiteral(string command, ref int index)
+    private static Literal ParseStringLiteral(string command, ref int index, Collation activeCollation)
     {
         var start = index;
         var builder = new StringBuilder();
@@ -217,7 +229,8 @@ private static Literal ParseStringLiteral(string command, ref int index)
                 continue;
             }
 
-            return new Literal(SqlValue.FromVarchar(builder.ToString()), command, start, ++index - start);
+            var literalType = VarcharSqlType.Get(0, activeCollation, Coercibility.CoercibleDefault);
+            return new Literal(SqlValue.FromVarchar(literalType, builder.ToString()), command, start, ++index - start);
         }
 
         throw SimulatedSqlException.UnclosedStringLiteral();
@@ -227,9 +240,11 @@ private static Literal ParseStringLiteral(string command, ref int index)
     /// Parses an N-prefixed Unicode string literal: <c>N'foo'</c>. The leading
     /// N (or n) is at <paramref name="index"/>; the body uses the same
     /// <c>''</c>-escape rules as a plain string literal but the result is
-    /// typed as <see cref="SqlType.NVarchar"/>.
+    /// typed as <see cref="SqlType.NVarchar"/> tagged with
+    /// <paramref name="activeCollation"/> at
+    /// <see cref="Coercibility.CoercibleDefault"/>.
     /// </summary>
-    private static Literal ParseNPrefixedStringLiteral(string command, ref int index)
+    private static Literal ParseNPrefixedStringLiteral(string command, ref int index, Collation activeCollation)
     {
         var start = index;
         index++; // skip the N
@@ -250,7 +265,8 @@ private static Literal ParseNPrefixedStringLiteral(string command, ref int index
                 continue;
             }
 
-            return new Literal(SqlValue.FromNVarchar(builder.ToString()), command, start, ++index - start);
+            var literalType = NVarcharSqlType.Get(0, activeCollation, Coercibility.CoercibleDefault);
+            return new Literal(SqlValue.FromNVarchar(literalType, builder.ToString()), command, start, ++index - start);
         }
 
         throw SimulatedSqlException.UnclosedStringLiteral();

SqlServerSimulator/Storage/Bacpac/ModelXmlReader.cs

@@ -248,12 +248,14 @@ private static void EmitDatabaseOptions(XElement element, DbConnection connectio
         using var command = connection.CreateCommand();
 
         // Collation: emit ALTER DATABASE COLLATE when the name is on the
-        // recognized whitelist; the simulator stores it as metadata on
-        // Database.CollationName for catalog-view round-trip. Comparison /
-        // sort / LIKE still route through Collation.Default — see
-        // docs/claude/database-options.md COLLATE-clause caveat. An
-        // unrecognized name lands on Warnings rather than aborting the load
-        // (the loader's best-effort contract).
+        // recognized catalog. The statement lands on Database.Collation, so
+        // subsequent column declarations without their own COLLATE clause
+        // inherit it and route compare / sort / hash through the chosen
+        // collation. An unrecognized name lands on Warnings rather than
+        // aborting the load (the loader's best-effort contract); the
+        // database keeps its construction-time server collation, and any
+        // columns the bacpac declares with explicit COLLATE clauses still
+        // pin those collations independently.
         var collation = element.Elements(Ns + "Property")
             .FirstOrDefault(p => p.Attribute("Name")?.Value == "Collation")
             ?.Attribute("Value")?.Value;
@@ -268,7 +270,7 @@ private static void EmitDatabaseOptions(XElement element, DbConnection connectio
             }
             else
             {
-                result.AddWarning($"Database declares Collation '{collation}' which isn't on the simulator's recognized list — stored as metadata, but comparison semantics fall back to the default. Add it to Collation.Recognized to surface in catalog views.");
+                result.AddWarning($"Database declares Collation '{collation}' which the simulator's catalog doesn't recognize — the database keeps its server-default collation; columns declared with their own COLLATE clauses still pin those collations.");
             }
         }
 

docs/claude/collations.md

@@ -73,13 +73,18 @@ Sites routed through the active DB collation:
 
 Probe-confirmed fidelity (real SQL Server CS database, 2026-05-22): `SELECT IIF(CHAR(65) = CHAR(97), 'eq', 'neq')` returns `'neq'` (literals don't case-fold under CS). The simulator now matches; the `CsDatabase_*CharFunctionResultUsesActiveCollation` tests in `NameComparisonRegimeTests.cs` lock the behavior in.
 
-Sites that intentionally stay on `Collation.Default` (~34 references):
+Sites that intentionally stay on `Collation.Default`:
 - System catalog schemas in `BuiltInResources.cs` — process-wide statics, no per-Simulation affinity.
 - `SqlType.Varchar` / `NVarchar` pseudo-singletons and `SqlType.GetChar` / `GetNChar` static bridges — type-identity placeholders.
 - `text` / `ntext` / `sysname` `Collation` overrides — server-default-only types.
 - Error-message type placeholders, dynamic-SQL string extraction, PRINT formatting — collation irrelevant to the surfaced value.
 - `Simulation.ServerCollation` initializer — the deliberate anchor for "what does the simulator's hardcoded baseline resolve to."
-- **String literals via the tokenizer** (`Value` / `Literal`) — literals like `'A'` and `N'foo'` still carry `Collation.Default` because the tokenizer materializes the `SqlValue` without batch context. Closing this would require threading `BatchContext` through `Tokenizer.NextToken` — deferred. The gap surfaces as: `SELECT 'A' = 'a'` on a CS database returns `1` (CI compare) instead of `0` (CS compare). Real workloads typically have a column on at least one side, and the column's `Implicit`-rank collation wins via `Collation.Resolve`, so this gap is unobservable in EF Core workloads.
+
+## String literals carry the active DB collation
+
+`Tokenizer.NextToken` takes a `Collation activeCollation` parameter; `ParserContext.MoveNext` threads `context.CurrentDatabase.Collation` in. The two string-literal entry points (`ParseStringLiteral` for `'foo'`, `ParseNPrefixedStringLiteral` for `N'foo'`) construct `VarcharSqlType.Get(0, activeCollation, Coercibility.CoercibleDefault)` / `NVarcharSqlType` and tag the resulting `SqlValue` with it. Other literal kinds (varbinary `0xHEX`, currency `$1.23`) don't carry collation and ignore the parameter.
+
+Effect: `SELECT IIF('A' = 'a', 'eq', 'neq')` on a CS database returns `'neq'` (case-sensitive), matching real SQL Server. The `CsDatabase_TwoVarcharLiteralsCompareCaseSensitively` / `CsDatabase_TwoNVarcharLiteralsCompareCaseSensitively` tests in `NameComparisonRegimeTests.cs` lock the behavior in. The earlier deferral framing (literal pairs falling through to the CI baseline because the tokenizer was stateless) is closed.
 
 `ALTER COLUMN` without an explicit `COLLATE` clause preserves the existing column's collation (probe-aligned). With an explicit `COLLATE`, the new collation pins at `Implicit` rank.