Continued improvement of collation fidelity by passing BatchContext through Expression.GetSqlType, allowing proper collation information to reach places that were using Collation.Default.

Author: RyanLamansky

CLAUDE.md

@@ -56,7 +56,7 @@ Readonly struct, up to 4 inline slots (SQL Server's grammar limit). API: `Leaf`,
 `SimulatedSqlException` constructor is private; each error case is an `internal static` factory in a topical partial (`TypeErrors`, `SchemaErrors`, `ConstraintErrors`, `ResolutionErrors`, `QueryErrors`, `SyntaxErrors`). The number lands in `Data["HelpLink.EvtID"]`. **Grep for an existing factory before adding a new one.**
 
 ### Expression evaluation
-`Expression.Run(RuntimeContext runtime)` (runtime) and `Expression.GetSqlType(...)` (static, for projection schema) must agree on result type — drift breaks union/CASE/coalesce schema. `RuntimeContext` bundles `ResolveColumn` (per-row column lookup) and `Batch` (the executing `BatchContext`); expressions that need batch / session / database state read `runtime.Batch.*` directly. `BooleanExpression.Run` returns `bool?` (three-valued); WHERE/MERGE-ON exclude UNKNOWN, CHECK passes UNKNOWN. Aggregates: subclass `Aggregator` (`Add(SqlValue)` / `Result()`), register in `AggregateExpression`'s dispatch.
+`Expression.Run(RuntimeContext runtime)` (runtime) and `Expression.GetSqlType(BatchContext batch, ...)` (static, for projection schema) must agree on result type — drift breaks union/CASE/coalesce schema. Both take a `BatchContext` so result types that depend on the active database (notably the collation of literal / CAST / function-result string types) stay in parity between the parse-time schema and the runtime value. `RuntimeContext` bundles `ResolveColumn` (per-row column lookup) and `Batch` (the executing `BatchContext`); expressions that need batch / session / database state read `runtime.Batch.*` directly. `BooleanExpression.Run` returns `bool?` (three-valued); WHERE/MERGE-ON exclude UNKNOWN, CHECK passes UNKNOWN. Aggregates: subclass `Aggregator` (`Add(SqlValue)` / `Result()`), register in `AggregateExpression`'s dispatch.
 
 ### Context layering
 Six scopes, one home each. **Add new state to whichever class matches its true scope** — when in doubt, ask who outlives whom. The field roster on each class lives in the source XML docs; this section captures only the identity + load-bearing contracts.

SqlServerSimulator.Tests.Internal/Storage/PromoteStringConcatTests.cs

@@ -13,50 +13,55 @@ public sealed class PromoteStringConcatTests
 {
     [TestMethod]
     public void Varchar_Plus_Varchar_SumsLengths() =>
-        AreEqual(30, ((VarcharSqlType)SqlType.PromoteForArithmetic(VarcharSqlType.Get(10), VarcharSqlType.Get(20), '+')).length);
+        AreEqual(30, ((VarcharSqlType)SqlType.PromoteForArithmetic(VarcharSqlType.Get(10, Collation.Default, Coercibility.CoercibleDefault), VarcharSqlType.Get(20, Collation.Default, Coercibility.CoercibleDefault), '+')).length);
 
     [TestMethod]
     public void Varchar_Plus_Varchar_CapsAt8000() =>
-        AreEqual(8000, ((VarcharSqlType)SqlType.PromoteForArithmetic(VarcharSqlType.Get(8000), VarcharSqlType.Get(100), '+')).length);
+        AreEqual(8000, ((VarcharSqlType)SqlType.PromoteForArithmetic(VarcharSqlType.Get(8000, Collation.Default, Coercibility.CoercibleDefault), VarcharSqlType.Get(100, Collation.Default, Coercibility.CoercibleDefault), '+')).length);
 
     [TestMethod]
     public void NVarchar_Plus_NVarchar_SumsLengths_CapsAt4000() =>
-        AreEqual(4000, ((NVarcharSqlType)SqlType.PromoteForArithmetic(NVarcharSqlType.Get(3000), NVarcharSqlType.Get(2000), '+')).length);
+        AreEqual(4000, ((NVarcharSqlType)SqlType.PromoteForArithmetic(NVarcharSqlType.Get(3000, Collation.Default, Coercibility.CoercibleDefault), NVarcharSqlType.Get(2000, Collation.Default, Coercibility.CoercibleDefault), '+')).length);
 
     [TestMethod]
     public void Char_Plus_Varchar_DropsToVarcharOfCombinedLength() =>
-        AreEqual(15, ((VarcharSqlType)SqlType.PromoteForArithmetic(SqlType.GetChar(5), VarcharSqlType.Get(10), '+')).length);
+        AreEqual(15, ((VarcharSqlType)SqlType.PromoteForArithmetic(SqlType.GetChar(5), VarcharSqlType.Get(10, Collation.Default, Coercibility.CoercibleDefault), '+')).length);
 
     [TestMethod]
     public void NChar_Plus_Varchar_PromotesToNVarcharOfCombinedLength() =>
-        AreEqual(15, ((NVarcharSqlType)SqlType.PromoteForArithmetic(SqlType.GetNChar(5), VarcharSqlType.Get(10), '+')).length);
+        AreEqual(15, ((NVarcharSqlType)SqlType.PromoteForArithmetic(SqlType.GetNChar(5), VarcharSqlType.Get(10, Collation.Default, Coercibility.CoercibleDefault), '+')).length);
 
     [TestMethod]
     public void Varchar_Plus_NVarchar_PromotesToNVarcharOfCombinedLength() =>
-        AreEqual(30, ((NVarcharSqlType)SqlType.PromoteForArithmetic(VarcharSqlType.Get(10), NVarcharSqlType.Get(20), '+')).length);
+        AreEqual(30, ((NVarcharSqlType)SqlType.PromoteForArithmetic(VarcharSqlType.Get(10, Collation.Default, Coercibility.CoercibleDefault), NVarcharSqlType.Get(20, Collation.Default, Coercibility.CoercibleDefault), '+')).length);
 
     [TestMethod]
     public void Unspecified_Plus_BoundedVarchar_DropsToUnspecified()
     {
         // Length 0 means "we don't know"; the result can't reliably claim
         // a sum, so it falls back to the length-unspecified form.
-        var result = SqlType.PromoteForArithmetic(VarcharSqlType.Unspecified, VarcharSqlType.Get(10), '+');
-        AreSame(VarcharSqlType.Unspecified, result);
+        var result = SqlType.PromoteForArithmetic(VarcharSqlType.Get(0, Collation.Default, Coercibility.CoercibleDefault), VarcharSqlType.Get(10, Collation.Default, Coercibility.CoercibleDefault), '+');
+        AreSame(VarcharSqlType.Get(0, Collation.Default, Coercibility.CoercibleDefault), result);
     }
 
     [TestMethod]
     public void Text_Plus_Varchar_DropsToVarcharUnspecified()
     {
         // LOB family operands have no per-cell width to add — the fall-back
-        // is the unspecified-length form of the right family.
-        var result = SqlType.PromoteForArithmetic(SqlType.Text, VarcharSqlType.Get(10), '+');
-        AreSame(VarcharSqlType.Unspecified, result);
+        // is the unspecified-length form of the right family. Text carries
+        // Implicit coercibility (it's a column-typed family), so the
+        // Collation.Resolve hand-off yields Implicit rather than
+        // CoercibleDefault.
+        var result = SqlType.PromoteForArithmetic(SqlType.Text, VarcharSqlType.Get(10, Collation.Default, Coercibility.CoercibleDefault), '+');
+        AreSame(VarcharSqlType.Get(0, Collation.Default, Coercibility.Implicit), result);
     }
 
     [TestMethod]
     public void NText_Plus_Char_DropsToNVarcharUnspecified()
     {
+        // NText carries Implicit; the char(5) bridge is also Implicit (via
+        // SqlType.GetChar's static helper), so the resolved rank is Implicit.
         var result = SqlType.PromoteForArithmetic(SqlType.NText, SqlType.GetChar(5), '+');
-        AreSame(NVarcharSqlType.Unspecified, result);
+        AreSame(NVarcharSqlType.Get(0, Collation.Default, Coercibility.Implicit), result);
     }
 }

SqlServerSimulator.Tests/NameComparisonRegimeTests.cs

@@ -312,4 +312,27 @@ public void ServerCollationName_SeededDatabase_CreateSchemaDBO_CoexistsWithDbo()
         AreEqual(2, sim.ExecuteScalar("SELECT COUNT(*) FROM sys.schemas WHERE name IN (N'dbo', N'DBO')"));
     }
 
+    // ===== Scalar-function result types carry the active DB collation =====
+    // CHAR(N) / NCHAR(N) result types pin the active database's collation
+    // rather than the storage-baseline Collation.Default, so a CS-DB
+    // compare between two function-returned strings goes through the
+    // CS comparer. Probe-confirmed against real SQL Server CS database
+    // (2026-05-22): CHAR(65) = CHAR(97) returns 'neq' (literals don't
+    // case-fold under CS).
+
+    [TestMethod]
+    public void CsDatabase_CharFunctionResultUsesActiveCollation()
+        => AreEqual("neq",
+            new Simulation { ServerCollationName = "SQL_Latin1_General_CP1_CS_AS" }
+                .ExecuteScalar("SELECT IIF(CHAR(65) = CHAR(97), 'eq', 'neq')"));
+
+    [TestMethod]
+    public void CsDatabase_NCharFunctionResultUsesActiveCollation()
+        => AreEqual("neq",
+            new Simulation { ServerCollationName = "SQL_Latin1_General_CP1_CS_AS" }
+                .ExecuteScalar("SELECT IIF(NCHAR(65) = NCHAR(97), 'eq', 'neq')"));
+
+    [TestMethod]
+    public void CiDatabase_CharFunctionResult_StillEqualsUnderCi()
+        => AreEqual("eq", new Simulation().ExecuteScalar("SELECT IIF(CHAR(65) = CHAR(97), 'eq', 'neq')"));
 }

SqlServerSimulator/BuiltInResources.cs

@@ -139,7 +139,7 @@ private static Dictionary<string, CatalogView> BuildCatalogViews()
         // Real SQL Server has many more columns; the shipped subset covers
         // the dominant query shapes. type is char(2) with trailing space
         // ('U ') — probe-confirmed.
-        var charTwo = CharSqlType.Get(2);
+        var charTwo = CharSqlType.Get(2, Collation.Default, Coercibility.CoercibleDefault);
         var tableType = SqlValue.FromChar(charTwo, "U ");
         var tableTypeDesc = SqlValue.FromNVarchar("USER_TABLE");
         var notMsShipped = SqlValue.FromBoolean(false);
@@ -826,7 +826,7 @@ private static Dictionary<string, CatalogView> BuildCatalogViews()
             new("major_id", SqlType.Int32, null, false),
             new("minor_id", SqlType.Int32, null, false),
             new("name", SqlType.SystemName, 128, false),
-            new("value", NVarcharSqlType.MaxForm, SqlType.MaxLengthSentinel, true),
+            new("value", NVarcharSqlType.Get(-1, Collation.Default, Coercibility.CoercibleDefault), SqlType.MaxLengthSentinel, true),
         };
         var extendedPropertiesView = new CatalogView("extended_properties", extendedPropertiesColumns, EnumerateSysExtendedProperties);
 
@@ -866,7 +866,7 @@ private static Dictionary<string, CatalogView> BuildCatalogViews()
             new("grantee_principal_id", SqlType.Int32, null, false),
             new("grantor_principal_id", SqlType.Int32, null, false),
             new("type", charTwo, 2, false),
-            new("permission_name", NVarcharSqlType.Get(128), 128, true),
+            new("permission_name", NVarcharSqlType.Get(128, Collation.Default, Coercibility.CoercibleDefault), 128, true),
             new("state", charOne, 1, false),
             new("state_desc", SqlType.NVarchar, 60, true),
         };
@@ -1000,7 +1000,7 @@ private static Dictionary<string, CatalogView> BuildCatalogViews()
             new("spatial_index_type_desc", SqlType.NVarchar, 60, true),
             new("tessellation_scheme", SqlType.NVarchar, 60, true),
             new("has_filter", SqlType.Bit, null, false),
-            new("filter_definition", NVarcharSqlType.MaxForm, null, true),
+            new("filter_definition", NVarcharSqlType.Get(-1, Collation.Default, Coercibility.CoercibleDefault), null, true),
             new("auto_created", SqlType.Bit, null, true),
         };
         var spatialIndexesView = new CatalogView("spatial_indexes", spatialIndexesColumns, EnumerateSysSpatialIndexes);
@@ -1249,7 +1249,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysExtendedProperties(Parser.Bat
                 SqlValue.FromInt32(key.MajorId),
                 SqlValue.FromInt32(key.MinorId),
                 SqlValue.FromSystemName(key.Name),
-                kvp.Value.IsNull ? SqlValue.Null(NVarcharSqlType.MaxForm) : kvp.Value.CoerceTo(NVarcharSqlType.MaxForm),
+                kvp.Value.IsNull ? SqlValue.Null(NVarcharSqlType.Get(-1, Collation.Default, Coercibility.CoercibleDefault)) : kvp.Value.CoerceTo(NVarcharSqlType.Get(-1, Collation.Default, Coercibility.CoercibleDefault)),
             ];
         }
     }
@@ -1301,7 +1301,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysForeignKeys(Parser.BatchConte
         var trueBit = SqlValue.FromBoolean(true);
         var falseBit = SqlValue.FromBoolean(false);
         var nullPrincipal = SqlValue.Null(SqlType.Int32);
-        var fkType = SqlValue.FromChar(CharSqlType.Get(2), "F ");
+        var fkType = SqlValue.FromChar(CharSqlType.Get(2, Collation.Default, Coercibility.CoercibleDefault), "F ");
         var fkTypeDesc = SqlValue.FromNVarchar("FOREIGN_KEY_CONSTRAINT");
         // key_index_id is the index id on the referenced table that satisfies
         // the FK — the simulator doesn't model indexes so report 1 (the
@@ -1395,7 +1395,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysCheckConstraints(Parser.Batch
         var trueBit = SqlValue.FromBoolean(true);
         var falseBit = SqlValue.FromBoolean(false);
         var nullPrincipal = SqlValue.Null(SqlType.Int32);
-        var ckType = SqlValue.FromChar(CharSqlType.Get(2), "C ");
+        var ckType = SqlValue.FromChar(CharSqlType.Get(2, Collation.Default, Coercibility.CoercibleDefault), "C ");
         var ckTypeDesc = SqlValue.FromNVarchar("CHECK_CONSTRAINT");
         var falseDbCollation = SqlValue.FromBoolean(false);
         foreach (var schema in database.Schemas.Values)
@@ -1454,7 +1454,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysKeyConstraints(Parser.BatchCo
         var trueBit = SqlValue.FromBoolean(true);
         var falseBit = SqlValue.FromBoolean(false);
         var nullPrincipal = SqlValue.Null(SqlType.Int32);
-        var charTwo = CharSqlType.Get(2);
+        var charTwo = CharSqlType.Get(2, Collation.Default, Coercibility.CoercibleDefault);
         var pkType = SqlValue.FromChar(charTwo, "PK");
         var uqType = SqlValue.FromChar(charTwo, "UQ");
         var pkTypeDesc = SqlValue.FromNVarchar("PRIMARY_KEY_CONSTRAINT");
@@ -1507,7 +1507,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysDefaultConstraints(Parser.Bat
         var trueBit = SqlValue.FromBoolean(true);
         var falseBit = SqlValue.FromBoolean(false);
         var nullPrincipal = SqlValue.Null(SqlType.Int32);
-        var dfType = SqlValue.FromChar(CharSqlType.Get(2), "D ");
+        var dfType = SqlValue.FromChar(CharSqlType.Get(2, Collation.Default, Coercibility.CoercibleDefault), "D ");
         var dfTypeDesc = SqlValue.FromNVarchar("DEFAULT_CONSTRAINT");
         foreach (var schema in database.Schemas.Values)
         {
@@ -1996,7 +1996,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysFullTextCatalogs(Parser.Batch
     /// </summary>
     private static IEnumerable<SqlValue[]> EnumerateSysFullTextIndexes(Parser.BatchContext batch, Database database)
     {
-        var charOneType = CharSqlType.Get(1);
+        var charOneType = CharSqlType.Get(1, Collation.Default, Coercibility.CoercibleDefault);
         var trueBit = SqlValue.FromBoolean(true);
         var autoCode = SqlValue.FromChar(charOneType, "A");
         var autoDesc = SqlValue.FromNVarchar("AUTO");
@@ -2094,7 +2094,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysXmlSchemaCollections(Parser.B
     /// </summary>
     private static IEnumerable<SqlValue[]> EnumerateSysXmlIndexes(Parser.BatchContext batch, Database database)
     {
-        var charOneType = CharSqlType.Get(1);
+        var charOneType = CharSqlType.Get(1, Collation.Default, Coercibility.CoercibleDefault);
         var typeCode = SqlValue.FromByte(3);
         var typeDesc = SqlValue.FromNVarchar("XML");
         var falseBit = SqlValue.FromBoolean(false);
@@ -2168,7 +2168,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysSpatialIndexes(Parser.BatchCo
         var falseBit = SqlValue.FromBoolean(false);
         var zeroByte = SqlValue.FromByte(0);
         var oneInt = SqlValue.FromInt32(1);
-        var nullDesc = SqlValue.Null(NVarcharSqlType.MaxForm);
+        var nullDesc = SqlValue.Null(NVarcharSqlType.Get(-1, Collation.Default, Coercibility.CoercibleDefault));
         var geometryTypeDesc = SqlValue.FromNVarchar("GEOMETRY");
         var geographyTypeDesc = SqlValue.FromNVarchar("GEOGRAPHY");
         foreach (var schema in database.Schemas.Values)

SqlServerSimulator/Parser/Expression.cs

@@ -393,12 +393,19 @@ private static void ParseWithinGroupOrderBy(AggregateExpression aggregate, Parse
 
     /// <summary>
     /// Static type-of resolver for projection planning: returns the
-    /// <see cref="SqlType"/> this expression will produce, given a
-    /// resolver that maps column-name parts to their declared types. Lets a
-    /// SELECT plan its output schema before any rows are read.
+    /// <see cref="SqlType"/> this expression will produce, given the active
+    /// batch (for database-affine state — in particular the database
+    /// collation that result-type defaults should carry) and a resolver that
+    /// maps column-name parts to their declared types. Lets a SELECT plan
+    /// its output schema before any rows are read; the batch parameter must
+    /// agree with the one passed to <see cref="Run"/> so the
+    /// projection-schema type and the produced value's <see cref="SqlValue.Type"/>
+    /// stay in parity (drift breaks union / CASE / coalesce schema and the
+    /// row-encoder's type validation).
     /// </summary>
+    /// <param name="batch">The active batch context, used to resolve database-affine defaults like the active collation.</param>
     /// <param name="resolveColumnType">Callback that, given a multi-part column name, returns its declared type or throws if unresolvable.</param>
-    public abstract SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType);
+    public abstract SqlType GetSqlType(BatchContext batch, Func<MultiPartName, SqlType> resolveColumnType);
 
     /// <summary>
     /// Diagnostic-only string rendering, surfaced to debuggers via

SqlServerSimulator/Parser/Expressions/AbsoluteValue.cs

@@ -41,8 +41,8 @@ public override SqlValue Run(RuntimeContext runtime)
         };
     }
 
-    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType)
-        => MathScalars.WidenForResult(this.source.GetSqlType(resolveColumnType));
+    public override SqlType GetSqlType(BatchContext batch, Func<MultiPartName, SqlType> resolveColumnType)
+        => MathScalars.WidenForResult(this.source.GetSqlType(batch, resolveColumnType));
 
     /// <remarks>
     /// .NET's <c>Math.Abs(long)</c> throws <c>OverflowException</c> on

SqlServerSimulator/Parser/Expressions/AggregateExpression.cs

@@ -126,15 +126,15 @@ internal void BindResult(SqlValue value)
     public override SqlValue Run(RuntimeContext runtime) =>
         this.resultBound ? this.cachedResult : throw new InvalidOperationException("AggregateExpression.Run was called before its result was bound; this indicates the Selection executor didn't recognize it as an aggregate.");
 
-    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => this.Kind switch
+    public override SqlType GetSqlType(BatchContext batch, Func<MultiPartName, SqlType> resolveColumnType) => this.Kind switch
     {
         AggregateKind.Count => SqlType.Int32,
         AggregateKind.CountBig or AggregateKind.ApproxCountDistinct => SqlType.BigInt,
         AggregateKind.ChecksumAgg => SqlType.Int32,
         AggregateKind.Stdev or AggregateKind.StdevP or AggregateKind.Var or AggregateKind.VarP => SqlType.Float,
-        AggregateKind.Max or AggregateKind.Min or AggregateKind.StringAgg => this.Operand!.GetSqlType(resolveColumnType),
-        AggregateKind.Sum => DeriveSumResultType(this.Operand!.GetSqlType(resolveColumnType)),
-        AggregateKind.Avg => DeriveAvgResultType(this.Operand!.GetSqlType(resolveColumnType)),
+        AggregateKind.Max or AggregateKind.Min or AggregateKind.StringAgg => this.Operand!.GetSqlType(batch, resolveColumnType),
+        AggregateKind.Sum => DeriveSumResultType(this.Operand!.GetSqlType(batch, resolveColumnType)),
+        AggregateKind.Avg => DeriveAvgResultType(this.Operand!.GetSqlType(batch, resolveColumnType)),
         _ => throw new InvalidOperationException($"Unknown aggregate kind {this.Kind}."),
     };
 

SqlServerSimulator/Parser/Expressions/Ascii.cs

@@ -32,7 +32,7 @@ public override SqlValue Run(RuntimeContext runtime)
         return SqlValue.FromInt32(firstByte[0]);
     }
 
-    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => SqlType.Int32;
+    public override SqlType GetSqlType(BatchContext batch, Func<MultiPartName, SqlType> resolveColumnType) => SqlType.Int32;
 
     internal override string DebugDisplay() => $"ASCII({this.source.DebugDisplay()})";
 }