String concatenation: CONCAT, CONCAT_WS, and string + operator. Variadic NULL-skipping CONCAT/CONCAT_WS via Msg 189; string + via NULL-propagating Add.Run branch with text/ntext rejected as Msg 402; PromoteForArithmetic preserves char(N)+char(M)→char(N+M) and nchar/char-mix→nchar fidelity, drops to length-less varchar/nvarchar for variable-pair where the simulator doesn't track length on the SqlType.

Author: RyanLamansky

CLAUDE.md

@@ -231,6 +231,33 @@ Result types (probe-confirmed 2026-05-09 via `SELECT INTO` + `tempdb.information
 
 `CurrentTimeFunction` (`Parser/Expressions/`) is a single class with a `CurrentTimeKind` discriminator; result-type rules and the SqlValue construction live in one place. The class holds a `Simulation` reference like `LastIdentityExpression` does, and reads `CurrentStatementUtcNow` per `Run` call.
 
+### Variadic string concatenation: `CONCAT` / `CONCAT_WS`
+Both functions stringify each argument via the standard CAST-to-varchar/nvarchar path, **skip NULL arguments** (rather than propagating), and **never return NULL** — an all-NULL input returns `''`, NOT NULL. Result type is `nvarchar` if any argument has a national-string type (`nvarchar` / `nchar` / `ntext`); otherwise `varchar`. Probe-confirmed 2026-05-09.
+
+Argument-count rules raise **Msg 189** with lowercase function name and per-function minimum: `CONCAT` requires 2-254 args (`"The concat function requires 2 to 254 arguments."`); `CONCAT_WS` requires 3-254 args — separator + at least two values (`"The concat_ws function requires 3 to 254 arguments."`).
+
+`CONCAT_WS` quirks worth knowing:
+- **NULL separator silently degrades to empty string** — `concat_ws(NULL, 'a', 'b')` returns `'ab'`, not NULL. Probe-confirmed; doesn't match common documentation that asserts NULL propagation.
+- **NULL values are skipped entirely** — no double separator next to a missing value: `concat_ws(',', 'a', NULL, 'b')` → `'a,b'`, not `'a,,b'`.
+- **Single-value form errors** — `concat_ws(',', 'a')` raises Msg 189; the function refuses to act as a no-op stringifier.
+
+The result type is computed from runtime argument types in `Run` (not just from `GetSqlType`'s static cache) because the function is reachable when its outer wrapper's `GetSqlType` doesn't cascade — e.g. `select datalength(concat(N'a', N'b'))` runs `Concat.Run` without `Concat.GetSqlType` being called, and the inner function still needs to settle on nvarchar based on the actual operand types.
+
+**EF Core 10 doesn't emit `CONCAT` from `string.Concat`** — `string.Concat(a, b, c)` translates to `[a] + N'-' + [b] + N'-' + [c]` (the `+` operator), which is NULL-propagating, distinct from CONCAT's NULL-skipping semantics. The simulator's CONCAT/CONCAT_WS support is reachable from raw SQL (`FromSqlInterpolated` / direct command text); the LINQ-side `string.Concat` path goes through string `+` (covered immediately below).
+
+`StringConcat` (`Parser/Expressions/`) is a single class with a `StringConcatKind` discriminator (`Concat` / `ConcatWs`); both share the same per-arg stringify + NULL-skip + nvarchar-promotion path, with the only branch in `Run` being whether the first argument is consumed as a separator.
+
+### String `+` operator (concatenation)
+String concatenation via `+` is **NULL-propagating** (matches default `CONCAT_NULL_YIELDS_NULL ON`; the simulator doesn't model the OFF setting). Result type is `nvarchar` when either operand is a national-string type (`nvarchar` / `nchar` / `ntext`), otherwise `varchar`. EF Core 10 emits this from `string.Concat(a, b, c)` server-side, from `+`-chains in LINQ, and as the dominant string-concat path for application code.
+
+`text` / `ntext` / `image` / `varbinary` operands raise **Msg 402** (`"The data types {a} and {b} are incompatible in the add operator."`) matching SQL Server's restriction on LOB-string and binary types in arithmetic operators. Trailing-space preservation falls out for free: fixed-length `char(N)` storage carries its padding, so `cast('a' as char(5)) + cast('b' as char(5))` → `'a    b    '`.
+
+**Bare-NULL handling has a minor divergence**: simulator's untyped `NULL` literal carries `SqlType.Int32` (the simulator has no truly untyped NULL sentinel), so `'a' + NULL` and `'a' + cast(NULL as int)` are indistinguishable at runtime. The simulator treats both as string concatenation (returning NULL of the result string type), which matches real SQL Server's behavior on bare NULL but diverges from `cast(NULL as int) + 'a'` (real raises Msg 245 from a string-to-int parse). The bare-NULL case dominates in practice; the typed-null-int edge case is a rare hand-written-SQL shape EF Core never emits.
+
+**Result-type fidelity**: pure char/nchar pairs preserve fixed-length-ness with combined lengths capped at the type's max — `char(5) + char(5)` → `char(10)`, `nchar(5) + nchar(5)` → `nchar(10)`, `char(5) + nchar(5)` → `nchar(10)`, `char(8000) + char(100)` → `char(8000)`. Mixed fixed/variable string pairs (`char + varchar`, `nchar + nvarchar`, etc.) drop to length-less `varchar` / `nvarchar` because the simulator stores variable-length string length at the column level rather than on the SqlType — so length metadata for `varchar(10) + varchar(20)` (real: `varchar(30)`) isn't tracked. `PromoteForArithmetic` short-circuits the joint-envelope `Promote` rule for string-`+` so the static schema and the runtime value type agree.
+
+`Subtract` / `Multiply` / etc. on string operands still raise `NotSupportedException` (real SQL Server: Msg 402 for `-`, Msg 8117 for `*` / `/` / `%`). Not a fidelity priority — apps don't use those shapes intentionally.
+
 ### Constraints
 - `CHECK`: inline single-column and table-level forms; Msg 547 per row on definitely-false predicate.
 - `PRIMARY KEY` / `UNIQUE`: linear scan (O(N) per insert); no B-tree.

SqlServerSimulator.Tests.EFCore/EFCoreStrings.cs

@@ -240,4 +240,16 @@ public void StringFunction_IndexOf()
         using var fresh = new TestDbContext(context.Simulation);
         Assert.AreEqual(6, fresh.People.Select(p => p.Name.IndexOf("world", StringComparison.Ordinal)).Single());
     }
+
+    [TestMethod]
+    public void StringFunction_ConcatViaPlus()
+    {
+        // EF Core 10 emits `[Name] + N'-' + [Code]` for `string.Concat(p.Name, "-", p.Code)`
+        // — the `+` operator, not the CONCAT function. Both sides non-null.
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation()).WithSaved(new Person { Id = 1, Name = "Alice", Code = "A1" });
+
+        using var fresh = new TestDbContext(context.Simulation);
+        Assert.AreEqual("Alice-A1", fresh.People.Select(p => string.Concat(p.Name, "-", p.Code)).Single());
+    }
+
 }

SqlServerSimulator.Tests/ConcatTests.cs

@@ -0,0 +1,237 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// <c>CONCAT</c> and <c>CONCAT_WS</c>: variadic string-concatenation scalars
+/// that skip NULL inputs (rather than propagating). Probe-anchored against
+/// SQL Server 2025 (2026-05-09).
+/// </summary>
+[TestClass]
+public sealed class ConcatTests
+{
+    [TestMethod]
+    [DataRow("concat('a', 'b')", "ab")]
+    [DataRow("concat('a', 'b', 'c')", "abc")]
+    [DataRow("concat('a', '', 'c')", "ac")]
+    [DataRow("concat(1, 2)", "12")]
+    [DataRow("concat('a', 1)", "a1")]
+    [DataRow("concat(1, 2, 3, 4, 5)", "12345")]
+    [DataRow("concat('x=', cast(3.14 as decimal(10,2)))", "x=3.14")]
+    [DataRow("concat('today: ', cast('2026-05-09' as date))", "today: 2026-05-09")]
+    [DataRow("concat('t=', cast('2026-05-09T12:34:56' as datetime2(7)))", "t=2026-05-09 12:34:56.0000000")]
+    [DataRow("concat('z=', cast('2026-05-09T12:34:56+05:00' as datetimeoffset(7)))", "z=2026-05-09 12:34:56.0000000 +05:00")]
+    [DataRow("concat('b=', cast(1 as bit))", "b=1")]
+    [DataRow("concat('m=', cast(123.45 as money))", "m=123.45")]
+    public void Concat_Basic(string expression, string expected) =>
+        AreEqual(expected, ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    [DataRow("concat('a', null, 'b')", "ab")]
+    [DataRow("concat(null, 'a', null, 'b', null)", "ab")]
+    [DataRow("concat(null, null)", "")]
+    [DataRow("concat(null, null, null)", "")]
+    [DataRow("concat('a', null)", "a")]
+    [DataRow("concat(null, 'a')", "a")]
+    public void Concat_SkipsNulls(string expression, string expected) =>
+        AreEqual(expected, ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    [DataRow("concat()")]
+    [DataRow("concat('a')")]
+    public void Concat_TooFewArguments_RaisesMsg189(string expression) =>
+        AssertSqlError($"select {expression}", 189, "The concat function requires 2 to 254 arguments.");
+
+    [TestMethod]
+    [DataRow("concat_ws(',', 'a', 'b', 'c')", "a,b,c")]
+    [DataRow("concat_ws('-', 'a', 'b')", "a-b")]
+    [DataRow("concat_ws('', 'a', 'b')", "ab")]
+    [DataRow("concat_ws('-', 1, 2, 3)", "1-2-3")]
+    [DataRow("concat_ws('-', 'a', 1, cast('2026-05-09' as date))", "a-1-2026-05-09")]
+    public void ConcatWs_Basic(string expression, string expected) =>
+        AreEqual(expected, ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    [DataRow("concat_ws(',', 'a', null, 'b')", "a,b")]
+    [DataRow("concat_ws(',', null, 'a', 'b')", "a,b")]
+    [DataRow("concat_ws(',', 'a', 'b', null)", "a,b")]
+    [DataRow("concat_ws(',', null, null, null)", "")]
+    [DataRow("concat_ws(',', 'a', null, null, 'b')", "a,b")]
+    public void ConcatWs_SkipsNullValues(string expression, string expected) =>
+        AreEqual(expected, ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    [DataRow("concat_ws(null, 'a', 'b')", "ab")]
+    [DataRow("concat_ws(null, 'a', 'b', 'c')", "abc")]
+    [DataRow("concat_ws(null, null, null)", "")]
+    public void ConcatWs_NullSeparator_DegradesToEmpty(string expression, string expected) =>
+        AreEqual(expected, ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    [DataRow("concat_ws()")]
+    [DataRow("concat_ws(',')")]
+    [DataRow("concat_ws(',', 'a')")]
+    [DataRow("concat_ws(',', null)")]
+    public void ConcatWs_TooFewArguments_RaisesMsg189(string expression) =>
+        AssertSqlError($"select {expression}", 189, "The concat_ws function requires 3 to 254 arguments.");
+
+    [TestMethod]
+    public void Concat_ResultIsVarcharByDefault()
+    {
+        // All-ASCII string args → varchar; round-trip through DataLength
+        // (varchar = 1 byte/char) confirms no nvarchar promotion.
+        AreEqual(3, ExecuteScalar("select datalength(concat('a', 'b', 'c'))"));
+    }
+
+    [TestMethod]
+    public void Concat_AnyNVarcharArg_PromotesToNVarchar()
+    {
+        // nvarchar = 2 bytes/char in CP1252 / UTF-16; presence of N'...'
+        // on any arg promotes the result.
+        AreEqual(6, ExecuteScalar("select datalength(concat('a', 'b', N'c'))"));
+    }
+
+    [TestMethod]
+    public void Concat_NullsOnly_ReturnsEmptyString_NotNull()
+    {
+        // Probe-confirmed SQL Server quirk: typed metadata says NOT NULL
+        // even when every input is NULL; runtime returns ''.
+        AreEqual("", ExecuteScalar("select concat(null, null)"));
+    }
+
+    [TestMethod]
+    public void ConcatWs_NullsOnly_ReturnsEmptyString_NotNull() =>
+        AreEqual("", ExecuteScalar("select concat_ws(',', null, null, null)"));
+
+    [TestMethod]
+    public void Concat_OfColumns_FromTable() =>
+        AreEqual("foobar", new Simulation().ExecuteScalar("""
+            create table t (a varchar(10), b varchar(10), c varchar(10));
+            insert t values ('foo', null, 'bar');
+            select concat(a, b, c) from t
+            """));
+
+    [TestMethod]
+    public void ConcatWs_OfColumns_FromTable() =>
+        AreEqual("foo|bar", new Simulation().ExecuteScalar("""
+            create table t (a varchar(10), b varchar(10), c varchar(10));
+            insert t values ('foo', null, 'bar');
+            select concat_ws('|', a, b, c) from t
+            """));
+}
+
+/// <summary>
+/// String <c>+</c> operator: NULL-propagating concatenation distinct from
+/// CONCAT's NULL-skipping. EF Core 10 emits this for <c>string.Concat</c> and
+/// <c>+</c>-chains over server-evaluated string operands. Probe-anchored
+/// against SQL Server 2025 (2026-05-09).
+/// </summary>
+[TestClass]
+public sealed class StringPlusOperatorTests
+{
+    [TestMethod]
+    [DataRow("'a' + 'b'", "ab")]
+    [DataRow("'' + 'a'", "a")]
+    [DataRow("'a' + ''", "a")]
+    [DataRow("'a' + 'b' + 'c'", "abc")]
+    [DataRow("'a' + 'b' + 'c' + 'd'", "abcd")]
+    [DataRow("N'a' + N'b'", "ab")]
+    [DataRow("'a' + N'b'", "ab")]
+    [DataRow("N'a' + 'b'", "ab")]
+    public void Plus_StringConcat(string expression, string expected) =>
+        AreEqual(expected, ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    [DataRow("'a' + null")]
+    [DataRow("null + 'a'")]
+    [DataRow("'a' + null + 'b'")]
+    [DataRow("cast(null as varchar(10)) + 'a'")]
+    [DataRow("'a' + cast(null as nvarchar(10))")]
+    public void Plus_PropagatesNull(string expression) =>
+        IsInstanceOfType<DBNull>(ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    public void Plus_VarcharVarchar_StaysVarchar() =>
+        AreEqual(2, ExecuteScalar("select datalength('a' + 'b')"));
+
+    [TestMethod]
+    [DataRow("'a' + N'b'")]
+    [DataRow("N'a' + 'b'")]
+    public void Plus_NVarcharOnEitherSide_PromotesToNVarchar(string expression) =>
+        AreEqual(4, ExecuteScalar($"select datalength({expression})"));
+
+    /// <summary>
+    /// <c>char(5) + char(5)</c> → <c>char(10)</c> (probe-confirmed). Trailing-space
+    /// padding on each operand survives the concat as a side-effect of the storage rep.
+    /// </summary>
+    [TestMethod]
+    public void Plus_CharPair_PreservesFixedLengthAndCombinesLengths() =>
+        AreEqual("a    b    ", new Simulation().ExecuteScalar("""
+            create table t (a char(5), b char(5));
+            insert t values ('a', 'b');
+            select a + b from t
+            """));
+
+    /// <summary><c>char(5)+char(3)</c> → <c>char(8)</c>, one byte per char.</summary>
+    [TestMethod]
+    public void Plus_CharPair_DataLength_MatchesCombinedLength() =>
+        AreEqual(8, new Simulation().ExecuteScalar("""
+            create table t (a char(5), b char(3));
+            insert t values ('x', 'y');
+            select datalength(a + b) from t
+            """));
+
+    /// <summary><c>nchar(5)+nchar(5)</c> → <c>nchar(10)</c>, two bytes per char → datalength = 20.</summary>
+    [TestMethod]
+    public void Plus_NCharPair_PromotesToNCharWithCombinedLength() =>
+        AreEqual(20, new Simulation().ExecuteScalar("""
+            create table t (a nchar(5), b nchar(5));
+            insert t values (N'x', N'y');
+            select datalength(a + b) from t
+            """));
+
+    /// <summary><c>char(5) + nchar(5)</c> → <c>nchar(10)</c>, datalength 20.</summary>
+    [TestMethod]
+    public void Plus_CharNCharMix_PromotesToNCharWithCombinedLength() =>
+        AreEqual(20, new Simulation().ExecuteScalar("""
+            create table t (a char(5), b nchar(5));
+            insert t values ('x', N'y');
+            select datalength(a + b) from t
+            """));
+
+    [TestMethod]
+    public void Plus_TextOperand_RaisesMsg402() =>
+        AssertSqlError("select cast('a' as text) + 'b'", 402,
+            "The data types text and varchar are incompatible in the add operator.");
+
+    [TestMethod]
+    public void Plus_NTextOperand_RaisesMsg402() =>
+        AssertSqlError("select 'a' + cast(N'b' as ntext)", 402,
+            "The data types varchar and ntext are incompatible in the add operator.");
+
+    /// <summary>
+    /// <c>'5'</c> parses to int via existing integer↔string promotion; result is int.
+    /// </summary>
+    [TestMethod]
+    [DataRow("'5' + 1", 6)]
+    [DataRow("1 + '5'", 6)]
+    public void Plus_StringPlusInteger_RoutesThroughIntegerArithmetic(string expression, int expected) =>
+        AreEqual(expected, ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    public void Plus_OfColumns_FromTable() =>
+        AreEqual("foobar", new Simulation().ExecuteScalar("""
+            create table t (a varchar(10), b varchar(10));
+            insert t values ('foo', 'bar');
+            select a + b from t
+            """));
+
+    [TestMethod]
+    public void Plus_ColumnAndNull_PropagatesNull() =>
+        IsInstanceOfType<DBNull>(new Simulation().ExecuteScalar("""
+            create table t (a varchar(10), b varchar(10));
+            insert t values ('foo', null);
+            select a + b from t
+            """));
+}

SqlServerSimulator/Errors/SimulatedSqlException.SyntaxErrors.cs

@@ -22,6 +22,16 @@ internal static SimulatedSqlException UnclosedStringLiteral() =>
 
     internal static SimulatedSqlException SyntaxErrorNear(char c) => new($"Incorrect syntax near '{c}'.", 102, 15, 1);
 
+    /// <summary>
+    /// Mimics SQL Server error 189: a built-in function received the wrong
+    /// number of arguments. Wording uses the lowercase function name and the
+    /// per-function minimum (e.g. <c>"The concat function requires 2 to 254
+    /// arguments."</c>). Probe-confirmed against SQL Server 2025 (2026-05-09)
+    /// for <c>CONCAT</c> (min 2) and <c>CONCAT_WS</c> (min 3).
+    /// </summary>
+    internal static SimulatedSqlException FunctionArgumentCount(string lowercaseFunctionName, int min) =>
+        new($"The {lowercaseFunctionName} function requires {min} to 254 arguments.", 189, 15, 1);
+
     /// <summary>
     /// Mimics SQL Server error 3902: a <c>COMMIT</c> was issued with no
     /// active transaction. Probe-confirmed against SQL Server 2025

SqlServerSimulator/Parser/Expression.cs

@@ -359,6 +359,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
             },
             6 => uppercaseName switch
             {
+                "CONCAT" => new StringConcat(context, StringConcatKind.Concat),
                 "ISNULL" => new IsNullExpression(context),
                 "NULLIF" => new NullIf(context),
                 "STDEVP" => AggregateExpression.Parse(context, AggregateKind.StdevP),
@@ -384,6 +385,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
             9 => uppercaseName switch
             {
                 "CHARINDEX" => new CharIndex(context),
+                "CONCAT_WS" => new StringConcat(context, StringConcatKind.ConcatWs),
                 "COUNT_BIG" => AggregateExpression.Parse(context, AggregateKind.CountBig),
                 "SUBSTRING" => new Substring(context),
                 _ => null