Implemented char/nchar/binary.

Author: RyanLamansky

CLAUDE.md

@@ -12,7 +12,7 @@ High-fidelity SQL Server simulation, eventually including transactions, locks, M
 
 When SQL Server's actual behavior is quirky or lossy (CP1252's silent `?` replacement for out-of-codepage characters, ANSI trailing-space padding for `=`, `LEN` excluding trailing spaces), mirror it rather than "fixing" it — authenticity over desirability is what makes the simulator a faithful stand-in.
 
-A long arc replacing in-memory boxed-object row storage with page-format-aligned encoding completed before this file was written; the simulator now has a single backend with real 8KB pages. Transactions / locks / MVCC are the next phase.
+The overall plan is incremental and non-specific: pick the lowest-effort path that unlocks the most useful application compatibility next. Transactions / locks / MVCC, `LIKE` and `CONVERT`, identity columns, the `varchar(MAX)` family, the EF Core adapter — all of these are eventual targets, but the order is opportunistic, driven by what's blocking the user's actual application stand-ins. Over time, this accretion gets the simulator to "most apps just work"; near term, work flows to the smallest unlock for the biggest cohort of pain points.
 
 ## Public API surface
 
@@ -72,10 +72,10 @@ Heavy-hitters someone might assume work but don't. Source and `git log` are the
 - Transactions / locks / MVCC.
 - Row-overflow / LOB pages and the `varchar(MAX)` / `nvarchar(MAX)` / `varbinary(MAX)` types they enable.
 - `decimal` / `numeric` values are backed by .NET `decimal`, so values requiring more than 28 significant digits aren't modeled (the type declarations up through `decimal(38, *)` are accepted so storage byte-width still matches SQL Server). `float` text formatting uses .NET's `G15`/`G7` conventions rather than SQL Server's exact `1e+015`-style scientific layout. `money` / `smallmoney` are wired in raw SQL but unreachable through EF Core for the same `SqlParameter`-downcast reason as the date-only / time-only mappings — adding a money column to an EF entity breaks that entity's whole save path.
-- Fixed-length `char(N)` / `nchar(N)` / `binary(N)`, and identity columns.
+- Identity columns.
 - `NEWSEQUENTIALID()` (deferred until `DEFAULT`-clause support exists in `CREATE TABLE`; the function is only valid in that context).
 - Pattern matching (`LIKE`) and `CONVERT`.
-- Cross-category `Promote` for `varchar` ↔ `nvarchar` and integer ↔ string. Only CAST works for those pairs.
+- Cross-category `Promote` for integer ↔ string. Only CAST works for that pair.
 - EF Core compatibility: the SqlServer provider downcasts `DbParameter` to `SqlParameter` for some mappings — `DateTime → date`, `DateTime → smalldatetime`, `DateOnly`, `TimeOnly`, `TimeSpan`, and `decimal → money` / `decimal → smallmoney` (via `SqlServerDecimalTypeMapping`) all break at SaveChanges. See `SimulatedDbParameter` for the matrix; a `SqlServerSimulator.EFCore` adapter package is planned to close the gap.
 - CAST to a smaller `varchar`/`nvarchar` than the value renders: SQL Server silently truncates; the simulator returns the full string.
 - Heap allocation tracking (IAM/PFS): the page list is flat.

SqlServerSimulator.Tests.EFCore/EFCoreStrings.cs

@@ -244,6 +244,43 @@ public void StringFunction_Replace()
         Assert.AreEqual("heLLo", context.People.Select(p => p.Name.Replace("l", "L")).FirstOrDefault());
     }
 
+    [TestMethod]
+    public void Insert_FixedLengthChar_RoundTripsWithPadding()
+    {
+        // char(5) is the simulator's fixed-length CP1252 type. EF Core maps
+        // strings to it via Column(TypeName="char(5)"); SaveChanges goes through
+        // SqlServerStringTypeMapping which sets SqlDbType.Char on the parameter.
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+
+        _ = context.People.Add(new Person { Id = 1, Name = "Iris", Tag = "hi" });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual("hi   ", context.People.Select(p => p.Tag).FirstOrDefault());
+    }
+
+    [TestMethod]
+    public void Insert_FixedLengthNChar_RoundTripsWithPadding()
+    {
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+
+        _ = context.People.Add(new Person { Id = 1, Name = "Jane", Initials = "JD" });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual("JD ", context.People.Select(p => p.Initials).FirstOrDefault());
+    }
+
+    [TestMethod]
+    public void Insert_FixedLengthBinary_RoundTripsWithZeroPadding()
+    {
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+
+        _ = context.People.Add(new Person { Id = 1, Name = "Karl", Stamp = [0xCA, 0xFE] });
+        _ = context.SaveChanges();
+
+        var read = context.People.Select(p => p.Stamp).FirstOrDefault();
+        CollectionAssert.AreEqual(new byte[] { 0xCA, 0xFE, 0, 0 }, read);
+    }
+
     [TestMethod]
     public void Insert_MultipleRows_RoundTripsBothColumns()
     {

SqlServerSimulator.Tests.EFCore/TestDbContext.cs

@@ -26,6 +26,15 @@ internal class Person
 
     [Column(TypeName = "varbinary(64)")]
     public byte[]? Avatar { get; set; }
+
+    [Column(TypeName = "char(5)")]
+    public string? Tag { get; set; }
+
+    [Column(TypeName = "nchar(3)")]
+    public string? Initials { get; set; }
+
+    [Column(TypeName = "binary(4)")]
+    public byte[]? Stamp { get; set; }
 }
 
 /// <summary>
@@ -158,7 +167,10 @@ create table People (
                     Id int,
                     Name nvarchar(50) not null,
                     Code varchar(10) null,
-                    Avatar varbinary(64) null
+                    Avatar varbinary(64) null,
+                    Tag char(5) null,
+                    Initials nchar(3) null,
+                    Stamp binary(4) null
                 )
                 """)
             .ExecuteNonQuery();

SqlServerSimulator.Tests/FixedLengthStringTests.cs

@@ -0,0 +1,241 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Behavioral tests for the fixed-length string and binary types
+/// (<c>char(N)</c>, <c>nchar(N)</c>, <c>binary(N)</c>): right-padding semantics,
+/// silent CAST truncation, INSERT-time truncation errors (Msg 2628 / 8152),
+/// trailing-space-aware comparison, and width-validation error variants.
+/// </summary>
+[TestClass]
+public sealed class FixedLengthStringTests
+{
+    [TestMethod]
+    public void Cast_String_PadsToDeclaredLength()
+    {
+        AreEqual("abc  ", ExecuteScalar("select cast('abc' as char(5))"));
+    }
+
+    [TestMethod]
+    public void Cast_NString_PadsNcharToDeclaredCodeUnits()
+    {
+        AreEqual("abc  ", ExecuteScalar("select cast(N'abc' as nchar(5))"));
+    }
+
+    [TestMethod]
+    public void Cast_Varbinary_PadsBinaryWithZeros()
+    {
+        var value = ExecuteScalar("select cast(0xCAFE as binary(5))") as byte[];
+        IsNotNull(value);
+        CollectionAssert.AreEqual(new byte[] { 0xCA, 0xFE, 0, 0, 0 }, value);
+    }
+
+    [TestMethod]
+    public void Cast_OversizeString_SilentlyTruncatesInCast()
+    {
+        // Verified against SQL Server 2025: CAST silently truncates without
+        // raising — the truncation error is reserved for INSERT/UPDATE.
+        AreEqual("hello", ExecuteScalar("select cast('hello world' as char(5))"));
+    }
+
+    [TestMethod]
+    public void Cast_OversizeBinary_SilentlyTruncatesInCast()
+    {
+        var value = ExecuteScalar("select cast(0x0102030405060708 as binary(5))") as byte[];
+        IsNotNull(value);
+        CollectionAssert.AreEqual(new byte[] { 1, 2, 3, 4, 5 }, value);
+    }
+
+    [TestMethod]
+    public void Cast_EmptyString_PadsToFullWidth()
+    {
+        AreEqual("   ", ExecuteScalar("select cast('' as char(3))"));
+    }
+
+    [TestMethod]
+    public void Comparison_CharWithVarchar_StripsTrailingSpaces()
+    {
+        // ANSI trailing-space padding is part of the equality semantics shared
+        // by every string-family type, so char(5) 'abc  ' equals varchar 'abc'.
+        AreEqual(1, ExecuteScalar("select 1 where cast('abc' as char(5)) = 'abc'"));
+        AreEqual(1, ExecuteScalar("select 1 where cast('abc' as char(5)) = 'abc  '"));
+    }
+
+    [TestMethod]
+    public void Comparison_DifferentDeclaredLengths_StillEqualByContent()
+    {
+        AreEqual(1, ExecuteScalar("select 1 where cast('abc' as char(5)) = cast('abc' as char(10))"));
+    }
+
+    [TestMethod]
+    public void CreateTable_InsertSelect_RoundTripsPaddedValue()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (c char(5))");
+        _ = simulation.ExecuteNonQuery("insert into t values ('hi')");
+        AreEqual("hi   ", simulation.ExecuteScalar("select c from t"));
+    }
+
+    [TestMethod]
+    public void CreateTable_NCharRoundTrip_PadsToDeclaredCodeUnits()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (c nchar(5))");
+        _ = simulation.ExecuteNonQuery("insert into t values (N'hi')");
+        AreEqual("hi   ", simulation.ExecuteScalar("select c from t"));
+    }
+
+    [TestMethod]
+    public void CreateTable_BinaryRoundTrip_PadsWithZeros()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (b binary(5))");
+        _ = simulation.ExecuteNonQuery("insert into t values (0xCAFE)");
+        var value = simulation.ExecuteScalar("select b from t") as byte[];
+        IsNotNull(value);
+        CollectionAssert.AreEqual(new byte[] { 0xCA, 0xFE, 0, 0, 0 }, value);
+    }
+
+    [TestMethod]
+    public void Insert_OversizeString_RaisesTruncationError()
+    {
+        // Default compatibility level is 170 (SQL Server 2025), so the verbose
+        // Msg 2628 fires with the column-name and truncated-prefix detail.
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (c char(5))");
+        var ex = Throws<DbException>(() => simulation.ExecuteNonQuery("insert into t values ('toolong')"));
+        AreEqual("String or binary data would be truncated in table 't', column 'c'. Truncated value: 'toolo'.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Insert_OversizeNChar_RaisesTruncationError()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (c nchar(5))");
+        var ex = Throws<DbException>(() => simulation.ExecuteNonQuery("insert into t values (N'toolong')"));
+        AreEqual("String or binary data would be truncated in table 't', column 'c'. Truncated value: 'toolo'.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Insert_OversizeBinary_RaisesTruncationError()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (b binary(5))");
+        var ex = Throws<DbException>(() => simulation.ExecuteNonQuery("insert into t values (0x010203040506)"));
+        StringAssert.StartsWith(ex.Message, "String or binary data would be truncated in table 't', column 'b'.");
+    }
+
+    [TestMethod]
+    public void Cast_CharZero_RaisesMsg1001()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast('a' as char(0))"));
+        AreEqual("Line 1: Length or precision specification 0 is invalid.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_CharOversize_RaisesMsg131WithTypeWording()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast('a' as char(8001))"));
+        AreEqual("The size (8001) given to the type 'char' exceeds the maximum allowed for any data type (8000).", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_NCharOversize_RaisesMsg131WithConvertSpecificationWording()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast(N'a' as nchar(4001))"));
+        AreEqual("The size (4001) given to the convert specification 'nchar' exceeds the maximum allowed for any data type (4000).", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_BinaryOversize_RaisesMsg131WithBinaryWording()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast(0xab as binary(8001))"));
+        AreEqual("The size (8001) given to the type 'binary' exceeds the maximum allowed for any data type (8000).", ex.Message);
+    }
+
+    [TestMethod]
+    public void CreateTable_CharOversize_RaisesMsg131WithColumnWording()
+    {
+        var simulation = new Simulation();
+        var ex = Throws<DbException>(() => simulation.ExecuteNonQuery("create table t (c char(8001))"));
+        AreEqual("The size (8001) given to the column 'c' exceeds the maximum allowed for any data type (8000).", ex.Message);
+    }
+
+    [TestMethod]
+    public void CreateTable_NCharOversize_RaisesMsg2717ParameterWording()
+    {
+        var simulation = new Simulation();
+        var ex = Throws<DbException>(() => simulation.ExecuteNonQuery("create table t (c nchar(4001))"));
+        AreEqual("The size (4001) given to the parameter 'c' exceeds the maximum allowed (4000).", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_Default_NoParensInCastIs30()
+    {
+        // Verified against SQL Server 2025: CAST without parens defaults to 30,
+        // matching SQL Server's documented "30 in CAST, 1 in column declaration"
+        // split. Confirm via DATALENGTH.
+        AreEqual(30, ExecuteScalar("select datalength(cast('abc' as char))"));
+    }
+
+    [TestMethod]
+    public void CreateTable_DefaultIsOne()
+    {
+        // Column declaration default is 1 — SQL Server's documented split from
+        // CAST's default of 30. INSERT a 1-char value to verify it round trips
+        // without truncation; 'hello' would truncate.
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (c char)");
+        _ = simulation.ExecuteNonQuery("insert into t values ('a')");
+        AreEqual("a", simulation.ExecuteScalar("select c from t"));
+        // 'hello' wouldn't fit char(1).
+        _ = Throws<DbException>(() => simulation.ExecuteNonQuery("insert into t values ('hello')"));
+    }
+
+    [TestMethod]
+    public void Cast_UidToCharBelow36_RaisesMsg8170()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast(NEWID() as char(35))"));
+        AreEqual("Insufficient result space to convert uniqueidentifier value to char.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_UidToNCharBelow36_RaisesMsg8115WithNvarcharText()
+    {
+        // Verified against SQL Server 2025: nchar's overflow message names
+        // "nvarchar" rather than "nchar" — same shared text path as nvarchar.
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast(NEWID() as nchar(35))"));
+        AreEqual("Arithmetic overflow error converting expression to data type nvarchar.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_VarcharToNvarchar_PreservesValue()
+    {
+        // String → string crossings now work in CAST (varchar ↔ nvarchar ↔
+        // char(N) ↔ nchar(N)). This was a known gap before fixed-length types
+        // were added; fixing it fell out of the same string→string code path.
+        AreEqual("abc", ExecuteScalar("select cast('abc' as nvarchar(10))"));
+    }
+
+    [TestMethod]
+    public void Insert_WithLegacyCompatibility_RaisesMsg8152NoColumnDetail()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("alter database current set compatibility_level = 150");
+        _ = simulation.ExecuteNonQuery("create table t (c char(5))");
+        var ex = Throws<DbException>(() => simulation.ExecuteNonQuery("insert into t values ('toolong')"));
+        AreEqual("String or binary data would be truncated.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_CharToVarchar_TrailingSpacesPreservedInString()
+    {
+        // The padded form is part of the value, so casting to varchar carries
+        // the trailing spaces through (verified: varchar comparison still
+        // strips them via ANSI padding).
+        AreEqual(1, ExecuteScalar("select 1 where cast(cast('abc' as char(5)) as varchar(10)) = 'abc'"));
+    }
+}

SqlServerSimulator/Parser/Expressions/Cast.cs

@@ -81,15 +81,17 @@ public override SqlValue Run(Func<List<string>, SqlValue> getColumnValue)
         // uniqueidentifier → too-narrow string: SQL Server raises a target-
         // specific error rather than silently truncating. char/varchar use
         // Msg 8170 with its dedicated text; nchar/nvarchar use the generic
-        // arithmetic-overflow Msg 8115. NULLs pass through silently.
+        // arithmetic-overflow Msg 8115 (verified against SQL Server 2025: the
+        // message names "nvarchar" for both nchar and nvarchar targets).
+        // NULLs pass through silently.
         if (!value.IsNull
             && value.Type == SqlType.UniqueIdentifier
             && this.targetMaxLength is int max
             && max < 36)
         {
-            if (this.targetType == SqlType.Varchar)
+            if (this.targetType == SqlType.Varchar || this.targetType is CharSqlType)
                 throw SimulatedSqlException.InsufficientResultSpaceForUniqueIdentifier();
-            if (this.targetType == SqlType.NVarchar)
+            if (this.targetType == SqlType.NVarchar || this.targetType is NCharSqlType)
                 throw SimulatedSqlException.ArithmeticOverflow("nvarchar");
         }
 

SqlServerSimulator/SimulatedSqlException.cs

@@ -143,11 +143,15 @@ internal static SimulatedSqlException SizeExceedsMaximumColumn(string columnName
         new($"The size ({requested}) given to the column '{columnName}' exceeds the maximum allowed for any data type ({max}).", 131, 15, 2);
 
     /// <summary>
-    /// Mimics SQL Server error 131 in CAST form for
-    /// <c>varchar</c> / <c>varbinary</c>. Class 15 / State 3.
+    /// Mimics SQL Server error 131 in CAST form for <c>varchar</c> /
+    /// <c>varbinary</c> / <c>char</c> / <c>binary</c>. Class 15 / State 3.
+    /// The message always names the family root (no <c>(N)</c> suffix); callers
+    /// of parameterized types must pass the bare name explicitly because the
+    /// resolved <see cref="SqlType"/>'s <see cref="object.ToString"/> renders
+    /// the suffix for debug contexts.
     /// </summary>
-    internal static SimulatedSqlException SizeExceedsMaximumCast(SqlType type, int requested, int max) =>
-        new($"The size ({requested}) given to the type '{type}' exceeds the maximum allowed for any data type ({max}).", 131, 15, 3);
+    internal static SimulatedSqlException SizeExceedsMaximumCast(string typeName, int requested, int max) =>
+        new($"The size ({requested}) given to the type '{typeName}' exceeds the maximum allowed for any data type ({max}).", 131, 15, 3);
 
     /// <summary>
     /// Mimics SQL Server error 2717: an <c>nvarchar</c> column exceeds the
@@ -159,11 +163,13 @@ internal static SimulatedSqlException NVarcharSizeExceedsMaximumColumn(string co
         new($"The size ({requested}) given to the parameter '{columnName}' exceeds the maximum allowed (4000).", 2717, 16, 2);
 
     /// <summary>
-    /// Mimics SQL Server error 131 in CAST form for <c>nvarchar</c>. Class 16
-    /// / State 1; uses "convert specification" wording.
+    /// Mimics SQL Server error 131 in CAST form for <c>nvarchar</c> /
+    /// <c>nchar</c>. Class 16 / State 1; uses "convert specification" wording.
+    /// The type name is parameterized so <c>nchar(N)</c> casts produce the
+    /// matching <c>'nchar'</c> wording (verified against SQL Server 2025).
     /// </summary>
-    internal static SimulatedSqlException NVarcharSizeExceedsMaximumCast(int requested) =>
-        new($"The size ({requested}) given to the convert specification 'nvarchar' exceeds the maximum allowed for any data type (4000).", 131, 16, 1);
+    internal static SimulatedSqlException NVarcharSizeExceedsMaximumCast(string typeName, int requested) =>
+        new($"The size ({requested}) given to the convert specification '{typeName}' exceeds the maximum allowed for any data type (4000).", 131, 16, 1);
 
     /// <summary>
     /// Mimics SQL Server's verbose truncation error (Msg 2628): a string value