Char-code scalars: ASCII / UNICODE / CHAR / NCHAR — basic conversions between a character and its code point that virtually every other string-manipulation built-in presupposes. ASCII / UNICODE return int; CHAR returns char(1); NCHAR returns nchar(1) (probe-confirmed via sql_variant_property basetype against SQL Server 2025 — CHAR's result is char not varchar, mirroring the docs but contrary to the Space.cs precedent). All four implementations live as one-file-per-scalar partials under Parser/Expressions/ (Ascii.cs / UnicodeCodepoint.cs / CharFromCode.cs / NCharFromCode.cs) — same pattern as existing simple scalars like Lower / Space. Wired into Expression.cs's length-keyed ResolveBuiltIn dispatch: CHAR at length-4, ASCII + NCHAR at length-5, UNICODE at length-7. ASCII implementation routes through CharSqlType.Cp1252Encoder for the .NET-string-to-CP1252-byte conversion, so probe-confirmed quirks fall out for free: ASCII(N'€') = 128 (the CP1252 byte for €), ASCII(N'😀') = 63 (encoder's ?' fallback for non-CP1252 chars), ASCII('é') = 233. NULL inputs return NULL; empty-string inputs return NULL for both ASCII and UNICODE (probe-confirmed — Microsoft's docs got it right; the "empty -> 0" claims floating around were wrong). Non-string inputs implicitly stringify before the first-char read, so ASCII(65) returns 54 (the byte for '6', the first char of "65") rather than 65 — implemented via SqlValue.CoerceTo(SqlType.Varchar) when the runtime type isn't in the string category. UNICODE returns the first .NET char's UTF-16 code unit value; supplementary code points like N'😀' return the high surrogate (55357 for 😀) under the non-SC default collation, matching probe + the simulator's "default collation only" stance — an SC-aware variant returning 128512 would need explicit collation modeling. CHAR(0..255) maps through Cp1252Encoder.GetString for the byte-to-char direction; CHAR(0) returns the NUL character (DATALENGTH = 1, ASCII round-trips back to 0) — not NULL, common idiom for embedding NUL bytes. CHAR / NCHAR out-of-range inputs (negative / > 255 for CHAR, > 65535 for NCHAR) return NULL; non-integer inputs (decimal / float / numeric string) implicitly truncate-to-int through CoerceTo(Int32). NCHAR > 65535 (including supplementary code points like 128512 for emoji) returns NULL under non-SC default collation matching probe — an SC-aware variant returning a 2-char surrogate-pair nvarchar(2) is deferred. 32 new CharScalarTests cover every probe-confirmed case verbatim including the PRINT-bundle-motivating CHAR(13)+CHAR(10) embedded-CRLF idiom, plus DATALENGTH parity for both CHAR(N) and NCHAR(N) result widths. docs/claude/scalars.md gains a dedicated "Char-code scalars" section above the EF.Functions-driven string scalars; CLAUDE.md Feature reference trigger entry adds the four function names to the scalar bundle. No new error factories (every edge case is silent NULL-or-coerce, matching probed behavior).

RyanLamansky · RyanLamansky · commit 3efc41e44a2d · 2026-05-14T06:47:23.000-05:00
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -133,7 +133,7 @@ Full `DbDataReader` contract. Typed accessors read `SqlValue` directly via the c
 
 Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger: read the linked file on demand when working in the matching area.
 
-- **Adding or modifying a built-in scalar** (math, date, current-time, `*FROMPARTS`/EOMONTH, AT TIME ZONE, CONCAT/CONCAT_WS, string `+`, PATINDEX/STUFF/QUOTENAME/REPLICATE/SPACE/FORMAT, ISNUMERIC/ISDATE/RAND, STRING_SPLIT) → [`docs/claude/scalars.md`](docs/claude/scalars.md).
+- **Adding or modifying a built-in scalar** (math, date, current-time, `*FROMPARTS`/EOMONTH, AT TIME ZONE, CONCAT/CONCAT_WS, string `+`, ASCII/UNICODE/CHAR/NCHAR char-code, PATINDEX/STUFF/QUOTENAME/REPLICATE/SPACE/FORMAT, ISNUMERIC/ISDATE/RAND, STRING_SPLIT) → [`docs/claude/scalars.md`](docs/claude/scalars.md).
 - **Touching `SqlType.Promote` / `PromoteForArithmetic` / decimal precision-scale formulas / int↔string promotion** → [`docs/claude/arithmetic.md`](docs/claude/arithmetic.md).
 - **Touching `Cast` or coercion error paths** (CAST/CONVERT narrow targets, TRY_CAST/TRY_CONVERT swallow set) → [`docs/claude/casting.md`](docs/claude/casting.md).
 - **Changing `Selection`, aggregates, window functions, set ops, CASE, OFFSET/FETCH** → [`docs/claude/query.md`](docs/claude/query.md).
diff --git a/SqlServerSimulator.Tests/CharScalarTests.cs b/SqlServerSimulator.Tests/CharScalarTests.cs
@@ -0,0 +1,174 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// <c>ASCII</c> / <c>UNICODE</c> / <c>CHAR</c> / <c>NCHAR</c> char-code
+/// scalars. Probe-confirmed verbatim against SQL Server 2025 (2026-05-14);
+/// every test below corresponds to a probe entry.
+/// </summary>
+[TestClass]
+public sealed class CharScalarTests
+{
+    [TestMethod]
+    public void Ascii_Letter_ReturnsCode()
+        => AreEqual(65, new Simulation().ExecuteScalar("select ASCII('A')"));
+
+    [TestMethod]
+    public void Ascii_MultiChar_ReturnsFirstByte()
+        => AreEqual(65, new Simulation().ExecuteScalar("select ASCII('Abc')"));
+
+    [TestMethod]
+    public void Ascii_EmptyString_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select ASCII('')"));
+
+    [TestMethod]
+    public void Ascii_Null_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select ASCII(NULL)"));
+
+    [TestMethod]
+    public void Ascii_Space_Returns32()
+        => AreEqual(32, new Simulation().ExecuteScalar("select ASCII(' ')"));
+
+    /// <summary>
+    /// N'€' is U+20AC, representable in CP1252 as 0x80 = 128.
+    /// </summary>
+    [TestMethod]
+    public void Ascii_Cp1252Representable_Returns128()
+        => AreEqual(128, new Simulation().ExecuteScalar("select ASCII(N'€')"));
+
+    /// <summary>
+    /// 'é' is U+00E9 = 233 in CP1252.
+    /// </summary>
+    [TestMethod]
+    public void Ascii_LatinE_Returns233()
+        => AreEqual(233, new Simulation().ExecuteScalar("select ASCII('é')"));
+
+    /// <summary>
+    /// ASCII(65) stringifies 65 to "65" first, then returns ASCII of '6' = 54.
+    /// </summary>
+    [TestMethod]
+    public void Ascii_IntInput_ImplicitStringifies()
+        => AreEqual(54, new Simulation().ExecuteScalar("select ASCII(65)"));
+
+    [TestMethod]
+    public void Unicode_Letter_Returns65()
+        => AreEqual(65, new Simulation().ExecuteScalar("select UNICODE(N'A')"));
+
+    [TestMethod]
+    public void Unicode_EmptyString_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select UNICODE(N'')"));
+
+    [TestMethod]
+    public void Unicode_Null_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select UNICODE(NULL)"));
+
+    [TestMethod]
+    public void Unicode_EuroSign_Returns8364()
+        => AreEqual(8364, new Simulation().ExecuteScalar("select UNICODE(N'€')"));
+
+    /// <summary>
+    /// 😀 (U+1F600) is the high surrogate 0xD83D = 55357 + low surrogate 0xDE00.
+    /// Non-SC default collation returns the high surrogate, not the full code point.
+    /// </summary>
+    [TestMethod]
+    public void Unicode_Supplementary_ReturnsHighSurrogate()
+        => AreEqual(55357, new Simulation().ExecuteScalar("select UNICODE(N'😀')"));
+
+    [TestMethod]
+    public void Unicode_IntInput_ImplicitStringifies()
+        => AreEqual(54, new Simulation().ExecuteScalar("select UNICODE(65)"));
+
+    [TestMethod]
+    public void Char_65_ReturnsA()
+        => AreEqual("A", new Simulation().ExecuteScalar("select CHAR(65)"));
+
+    [TestMethod]
+    public void Char_0_ReturnsNulByte()
+    {
+        // CHAR(0) is a valid character — the NUL byte — not NULL. DATALENGTH
+        // confirms a single byte; ASCII round-trips back to 0.
+        var sim = new Simulation();
+        AreEqual(1, sim.ExecuteScalar("select datalength(CHAR(0))"));
+        AreEqual(0, sim.ExecuteScalar("select ASCII(CHAR(0))"));
+    }
+
+    [TestMethod]
+    public void Char_256_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select CHAR(256)"));
+
+    [TestMethod]
+    public void Char_Negative_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select CHAR(-1)"));
+
+    [TestMethod]
+    public void Char_Null_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select CHAR(NULL)"));
+
+    [TestMethod]
+    public void Char_DecimalInput_TruncatesToInt()
+        => AreEqual("A", new Simulation().ExecuteScalar("select CHAR(65.7)"));
+
+    [TestMethod]
+    public void Char_StringInput_ParsesAsInt()
+        => AreEqual("A", new Simulation().ExecuteScalar("select CHAR('65')"));
+
+    /// <summary>
+    /// CHAR(128) maps to € under CP1252.
+    /// </summary>
+    [TestMethod]
+    public void Char_Cp1252EuroByte_Returns()
+        => AreEqual("€", new Simulation().ExecuteScalar("select CHAR(128)"));
+
+    [TestMethod]
+    public void NChar_65_ReturnsA()
+        => AreEqual("A", new Simulation().ExecuteScalar("select NCHAR(65)"));
+
+    [TestMethod]
+    public void NChar_EuroCodepoint_ReturnsEuro()
+        => AreEqual("€", new Simulation().ExecuteScalar("select NCHAR(8364)"));
+
+    /// <summary>
+    /// Default non-SC collation: NCHAR > 65535 returns NULL rather than
+    /// emitting a surrogate pair. Documented in CLAUDE.md as a deliberate
+    /// alignment with the simulator's default-collation-only stance.
+    /// </summary>
+    [TestMethod]
+    public void NChar_Supplementary_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select NCHAR(65536)"));
+
+    [TestMethod]
+    public void NChar_Emoji_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select NCHAR(128512)"));
+
+    [TestMethod]
+    public void NChar_Negative_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select NCHAR(-1)"));
+
+    [TestMethod]
+    public void NChar_Null_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select NCHAR(NULL)"));
+
+    [TestMethod]
+    public void NChar_StringInput_ParsesAsInt()
+        => AreEqual("A", new Simulation().ExecuteScalar("select NCHAR('65')"));
+
+    [TestMethod]
+    public void Char_Width_IsOneByte()
+        => AreEqual(1, new Simulation().ExecuteScalar("select datalength(CHAR(65))"));
+
+    [TestMethod]
+    public void NChar_Width_IsTwoBytes()
+        => AreEqual(2, new Simulation().ExecuteScalar("select datalength(NCHAR(65))"));
+
+    [TestMethod]
+    public void Char13Plus10_EmbedsCRLF()
+    {
+        // The PRINT-bundle observation that drove this feature: CHAR(13) +
+        // CHAR(10) is the idiomatic way to embed CR+LF in T-SQL string
+        // literals.
+        var sim = new Simulation();
+        AreEqual(2, sim.ExecuteScalar("select len(CHAR(13)+CHAR(10))"));
+        AreEqual("a\nb", sim.ExecuteScalar("select 'a'+CHAR(10)+'b'"));
+    }
+}
diff --git a/SqlServerSimulator/Parser/Expression.cs b/SqlServerSimulator/Parser/Expression.cs
@@ -444,6 +444,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
                 "ATAN" => new TrigFunction(context, TrigKind.Atan),
                 "ATN2" => new Atn2(context),
                 "CAST" => new Cast(context),
+                "CHAR" => new CharFromCode(context),
                 "LEAD" => WindowExpression.ParseLead(context),
                 "LEFT" => new Left(context),
                 "RAND" => new Rand(context),
@@ -456,11 +457,13 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
             },
             5 => uppercaseName switch
             {
+                "ASCII" => new Ascii(context),
                 "COUNT" => AggregateExpression.Parse(context, AggregateKind.Count),
                 "FLOOR" => new Floor(context),
                 "LOG10" => new Log10(context),
                 "LOWER" => new Lower(context),
                 "LTRIM" => new LeftTrim(context),
+                "NCHAR" => new NCharFromCode(context),
                 "NEWID" => new NewId(context),
                 "NTILE" => WindowExpression.ParseNTile(context),
                 "POWER" => new Power(context),
@@ -496,6 +499,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
                 "REPLACE" => new Replace(context),
                 "REVERSE" => new Reverse(context),
                 "TYPE_ID" => new TypeId(context),
+                "UNICODE" => new UnicodeCodepoint(context),
                 _ => null
             },
             8 => uppercaseName switch
diff --git a/SqlServerSimulator/Parser/Expressions/Ascii.cs b/SqlServerSimulator/Parser/Expressions/Ascii.cs
@@ -0,0 +1,38 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// SQL <c>ASCII(character_expression)</c>: returns the CP1252 byte value
+/// of the first character of the input.
+/// </summary>
+/// <remarks>
+/// Probe-confirmed against SQL Server 2025 (2026-05-14):
+/// <list type="bullet">
+/// <item>NULL input → NULL.</item>
+/// <item>Empty string → NULL.</item>
+/// <item>Unicode input (<c>N'…'</c>) is converted to CP1252 before the byte is read; representable characters like <c>N'€'</c> return their CP1252 byte (128 for €); unrepresentable Unicode (emoji etc.) returns 63 via CP1252's <c>'?'</c> replacement fallback (matches the simulator's existing CP1252 collation quirk).</item>
+/// <item>Non-string inputs (int / decimal / etc.) are implicitly converted to <c>varchar</c> first, so <c>ASCII(65)</c> returns 54 (the ASCII byte for <c>'6'</c>, the first char of the string <c>"65"</c>) — not 65.</item>
+/// </list>
+/// </remarks>
+internal sealed class Ascii(ParserContext context) : Expression
+{
+    private readonly Expression source = Parse(context);
+
+    public override SqlValue Run(RuntimeContext runtime)
+    {
+        var v = source.Run(runtime);
+        if (v.IsNull)
+            return SqlValue.Null(SqlType.Int32);
+        var s = SqlType.IsStringCategory(v.Type) ? v.AsString : v.CoerceTo(SqlType.Varchar).AsString;
+        if (s.Length == 0)
+            return SqlValue.Null(SqlType.Int32);
+        Span<byte> firstByte = stackalloc byte[1];
+        _ = CharSqlType.Cp1252Encoder.GetBytes(s.AsSpan(0, 1), firstByte);
+        return SqlValue.FromInt32(firstByte[0]);
+    }
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => SqlType.Int32;
+
+    internal override string DebugDisplay() => $"ASCII({this.source.DebugDisplay()})";
+}
diff --git a/SqlServerSimulator/Parser/Expressions/CharFromCode.cs b/SqlServerSimulator/Parser/Expressions/CharFromCode.cs
@@ -0,0 +1,39 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// SQL <c>CHAR(integer_expression)</c>: returns the single CP1252 character
+/// corresponding to the input byte code (0–255), as <c>char(1)</c>.
+/// </summary>
+/// <remarks>
+/// Probe-confirmed against SQL Server 2025 (2026-05-14):
+/// <list type="bullet">
+/// <item>Result type is <c>char(1)</c>, not <c>varchar(1)</c> — <c>sql_variant_property(CHAR(65), 'basetype')</c> returns <c>'char'</c>.</item>
+/// <item>NULL input → NULL.</item>
+/// <item>Out-of-range input (negative or &gt; 255) → NULL.</item>
+/// <item>Non-integer inputs (decimal / float / string of digits) are implicitly converted to int with truncation, so <c>CHAR(65.7)</c> and <c>CHAR('65')</c> both return <c>'A'</c>.</item>
+/// <item><c>CHAR(0)</c> returns a single <c>0x00</c> byte (the NUL character), not NULL — common idiom for embedding null bytes.</item>
+/// </list>
+/// </remarks>
+internal sealed class CharFromCode(ParserContext context) : Expression
+{
+    private static readonly CharSqlType Char1 = CharSqlType.Get(1);
+    private readonly Expression code = Parse(context);
+
+    public override SqlValue Run(RuntimeContext runtime)
+    {
+        var v = code.Run(runtime);
+        if (v.IsNull)
+            return SqlValue.Null(Char1);
+        var n = v.CoerceTo(SqlType.Int32).AsInt32;
+        if (n is < 0 or > 255)
+            return SqlValue.Null(Char1);
+        ReadOnlySpan<byte> oneByte = [(byte)n];
+        return SqlValue.FromChar(Char1, CharSqlType.Cp1252Encoder.GetString(oneByte));
+    }
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => Char1;
+
+    internal override string DebugDisplay() => $"CHAR({this.code.DebugDisplay()})";
+}
diff --git a/SqlServerSimulator/Parser/Expressions/NCharFromCode.cs b/SqlServerSimulator/Parser/Expressions/NCharFromCode.cs
@@ -0,0 +1,38 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// SQL <c>NCHAR(integer_expression)</c>: returns the single UTF-16 character
+/// corresponding to the input code unit (0–65535), as <c>nchar(1)</c>.
+/// Mirror of <see cref="CharFromCode"/>'s range / coercion / NULL rules,
+/// scaled to BMP code units.
+/// </summary>
+/// <remarks>
+/// Probe-confirmed against SQL Server 2025 (2026-05-14):
+/// <list type="bullet">
+/// <item>Result type is <c>nchar(1)</c> — <c>sql_variant_property</c> returns <c>'nchar'</c>; <c>datalength</c> is 2 (one UTF-16 code unit).</item>
+/// <item>Out-of-range inputs (negative, or above 65535) return NULL under the default non-SC collation. Supplementary code points like <c>NCHAR(128512)</c> (😀) return NULL rather than the surrogate pair — matches the simulator's "default collation only" stance; an SC-collation-aware variant returning <c>nvarchar(2)</c> would need explicit collation modeling.</item>
+/// <item>Non-integer inputs implicitly truncate-to-int (<c>NCHAR('65')</c> → 'A').</item>
+/// </list>
+/// </remarks>
+internal sealed class NCharFromCode(ParserContext context) : Expression
+{
+    private static readonly NCharSqlType NChar1 = NCharSqlType.Get(1);
+    private readonly Expression code = Parse(context);
+
+    public override SqlValue Run(RuntimeContext runtime)
+    {
+        var v = code.Run(runtime);
+        if (v.IsNull)
+            return SqlValue.Null(NChar1);
+        var n = v.CoerceTo(SqlType.Int32).AsInt32;
+        return n is < 0 or > 65535
+            ? SqlValue.Null(NChar1)
+            : SqlValue.FromNChar(NChar1, ((char)n).ToString());
+    }
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => NChar1;
+
+    internal override string DebugDisplay() => $"NCHAR({this.code.DebugDisplay()})";
+}
diff --git a/SqlServerSimulator/Parser/Expressions/UnicodeCodepoint.cs b/SqlServerSimulator/Parser/Expressions/UnicodeCodepoint.cs
@@ -0,0 +1,35 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// SQL <c>UNICODE(ncharacter_expression)</c>: returns the UTF-16 code-unit
+/// value of the first character of the input. Mirror of <see cref="Ascii"/>
+/// in input-handling shape; the only divergence is the byte vs code-unit
+/// extraction step.
+/// </summary>
+/// <remarks>
+/// Probe-confirmed against SQL Server 2025 (2026-05-14):
+/// <list type="bullet">
+/// <item>NULL → NULL; empty string → NULL.</item>
+/// <item>Non-string inputs implicitly stringify, so <c>UNICODE(65)</c> returns 54 (<c>'6'</c>) not 65.</item>
+/// <item>Supplementary code points (above U+FFFF, e.g. <c>N'😀'</c>) under the default non-SC collation return the high surrogate value (55357 for 😀), not the full Unicode code point — matches the simulator's "default collation only" stance documented in CLAUDE.md. An SC-collation-aware variant returning 128512 would need explicit collation modeling.</item>
+/// </list>
+/// </remarks>
+internal sealed class UnicodeCodepoint(ParserContext context) : Expression
+{
+    private readonly Expression source = Parse(context);
+
+    public override SqlValue Run(RuntimeContext runtime)
+    {
+        var v = source.Run(runtime);
+        if (v.IsNull)
+            return SqlValue.Null(SqlType.Int32);
+        var s = SqlType.IsStringCategory(v.Type) ? v.AsString : v.CoerceTo(SqlType.Varchar).AsString;
+        return s.Length == 0 ? SqlValue.Null(SqlType.Int32) : SqlValue.FromInt32(s[0]);
+    }
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => SqlType.Int32;
+
+    internal override string DebugDisplay() => $"UNICODE({this.source.DebugDisplay()})";
+}
diff --git a/docs/claude/scalars.md b/docs/claude/scalars.md
@@ -59,6 +59,14 @@ Zone-name resolution via `TimeZoneInfo.FindSystemTimeZoneById` (accepts both Win
 
 **Precedence**: `AT TIME ZONE` binds tighter than `+`. The zone-name slot parses as a primary expression only — literals, `@variables`, single-segment column refs, or parenthesized full expressions. Multi-part dotted refs and binary chains in the zone slot aren't modeled; wrap in parens. `AT`/`TIME`/`ZONE` are contextual keywords (still valid identifiers).
 
+## Char-code scalars: `ASCII` / `UNICODE` / `CHAR` / `NCHAR`
+Basic one-arg conversions between a character and its code point.
+
+- **`ASCII(input)`** returns `int`. Reads the first character of `input` and returns its CP1252 byte value. NULL → NULL; empty string → NULL. Unicode input is CP1252-encoded first, so `ASCII(N'€')` returns 128 (CP1252's `€`); unrepresentable Unicode (emoji etc.) returns 63 via the encoder's `'?'` replacement fallback. Non-string inputs implicitly stringify *before* the first-char read, so `ASCII(65)` is 54 (the byte for `'6'`, the first char of `"65"`), not 65.
+- **`UNICODE(input)`** returns `int`. Same input-handling shape as `ASCII`, but reads the .NET `char` directly rather than CP1252-encoding it. Supplementary code points (above U+FFFF, e.g. `N'😀'`) return the high surrogate value (55357 for 😀) under the non-SC default collation — not the full Unicode code point. An SC-aware variant returning 128512 would need explicit collation modeling; matches the simulator's "default collation only" stance.
+- **`CHAR(code)`** returns `char(1)` (not `varchar(1)` — probe-confirmed via `sql_variant_property(CHAR(65), 'basetype')`). NULL → NULL; out-of-range (negative / > 255) → NULL. Non-integer inputs truncate-to-int (`CHAR(65.7)` → `'A'`, `CHAR('65')` → `'A'`). `CHAR(0)` is a valid NUL character with `DATALENGTH = 1`, not NULL.
+- **`NCHAR(code)`** returns `nchar(1)`. NULL / out-of-range (negative, > 65535) → NULL. Supplementary code points like `NCHAR(128512)` (😀) return NULL rather than emitting a surrogate pair — non-SC collation behavior.
+
 ## EF.Functions-driven string scalars: `PATINDEX` / `STUFF` / `QUOTENAME` / `REPLICATE` / `SPACE` / `FORMAT`
 Bundle that fills out the raw-SQL string surface that EF's `FromSqlInterpolated` and `DefaultValueSql` workloads commonly reach. None of these are exposed as `EF.Functions.X` LINQ extensions; coverage targets raw-SQL paths.
 
