Cross-category integer ↔ string Promote: returns the integer's specific subtype (tinyint+'3' → tinyint, bigint+'3' → bigint), with the string parsing through the integer's CAST path; bit + string raises Msg 402 (+/-/%) or Msg 8117 (*/) per SQL Server 2025. Coalesce now caches its Promote result type, BuildSynthesizedSqlRow runs Run-then-GetSqlType so mixed-type CASE / Coalesce in FROM-less SELECTs land at the joint type, and FromSqlInterpolated covers the EF Core integration end-to-end.

Author: RyanLamansky

CLAUDE.md

@@ -185,6 +185,15 @@ Top-level OFFSET/FETCH (post-set-op chain) attaches alongside the top-level ORDE
 ### Aggregates
 `COUNT(*)` / `COUNT(expr)` / `COUNT(DISTINCT expr)` / `COUNT_BIG`, `SUM` / `AVG` (integer-truncating; `decimal(38, max(s, 6))` widening for AVG over decimals), `MAX` / `MIN`, statistical (`STDEV` / `STDEVP` / `VAR` / `VARP`), `STRING_AGG`, `CHECKSUM_AGG`, `APPROX_COUNT_DISTINCT`. Standalone and inside `GROUP BY` / `HAVING`.
 
+### Integer ↔ string promotion
+Cross-category integer ↔ string promotion lands the integer's specific subtype (`tinyint + '3'` stays tinyint, `bigint + '3'` stays bigint — probe-confirmed against SQL Server 2025, 2026-05-08). The string side parses through the integer's existing CAST path at runtime — empty / whitespace-only → 0, `+`/`-` sign prefixes accepted, leading/trailing whitespace trimmed. **Decimal-shaped strings (`'5.5'`, `'5.0'`) raise Msg 245** rather than routing through decimal — SQL Server's int-target string parse rejects any non-integer literal. Hex notation (`'0x05'`) likewise rejected; the `0x` literal form is a different parse path.
+
+`PromoteFromInteger`'s `String => a` arm and `PromoteFromString`'s `Integer => b` arm are the static rule; `IntegerArithmetic` in `TwoSidedExpression` normalizes the string operand by `CoerceTo(integerType)` before dispatching to `PureIntegerArithmetic`. The bit asymmetry: `bit ↔ string` **comparison** works through string→bit CAST (with `'true'` / `'false'` / empty all accepted), but `bit + str` (and other bit-arithmetic with strings) is rejected — `+` / `-` / `%` raise **Msg 402** (`"The data types bit and varchar are incompatible in the {add|subtract|modulo} operator."`); `*` / `/` raise **Msg 8117** with the LEFT operand's type only (`"Operand data type bit is invalid for {multiply|divide} operator."`). The asymmetry mirrors SQL Server's same bit-arithmetic restriction with another bit, which is also rejected.
+
+WHERE on a varchar column compared against an int (or vice versa) halts the whole query on the first unparseable row — the failure isn't isolated as per-row UNKNOWN. SQL Server's lazy-IN quirk (where an unparseable value in an IN list is suppressed when any other value matches) isn't modeled — strict semantics: any conversion error in an IN-list propagates immediately.
+
+`BuildSynthesizedSqlRow` (the FROM-less SELECT path) runs each expression first to surface runtime-only errors with their operator-name wording, then calls `GetSqlType` to populate the projection schema and bridges any runtime/schema type mismatch via `CoerceTo` — required for mixed-type CASE / Coalesce expressions (`case when 1=0 then 5 else '99' end` lands as int 99 even without a FROM clause).
+
 ### Decimal arithmetic precision / scale
 SQL Server has per-operator scale rules for decimal that differ from the joint-envelope rule used for comparison / COALESCE / set-op type unification (probe-confirmed against SQL Server 2025, 2026-05-08):
 
@@ -300,7 +309,6 @@ Type-metadata accessors (`GetDataTypeName` / `GetFieldType`) read from `Simulate
 - `STRING_AGG`'s `WITHIN GROUP (ORDER BY ...)`.
 - `LIKE` with `COLLATE` override (default collation only — case-insensitive Latin1_General-shaped).
 - `CONVERT` / `TRY_CONVERT` style codes other than `0` / `120` / `121` for date-like → string. Other styles raise Msg 281; money / float / binary style codes and `CONVERT(date, str, 103)`-style date parsing not modeled.
-- Cross-category `Promote` for integer ↔ string. Only CAST works that pair.
 - `LEN(ntext)` raising Msg 8116 (function-level text/ntext/image restrictions); legacy `READTEXT` / `WRITETEXT` / `UPDATETEXT`.
 - `OUTPUT INTO @table_var`, `OUTPUT DELETED.*` / `INSERTED.*` star expansion. Per-column `OUTPUT INSERTED.<col>` / `OUTPUT DELETED.<col>` *is* supported (UPDATE / DELETE both); only the star-expansion form is missing. `OUTPUT INTO` (sending the projection to a table variable rather than the result set) isn't.
 - Joined-source UPDATE / DELETE FROM clauses (`UPDATE a SET ... FROM t AS a JOIN u AS b ON ...`). The single-source alias form (`UPDATE a SET ... FROM t AS a [WHERE ...]`, `DELETE FROM a FROM t AS a [WHERE ...]`) IS supported — that's what EF7+ `ExecuteUpdate` / `ExecuteDelete` emit, verified against real SQL Server 2025. Adding sources beyond the single aliased target raises `NotSupportedException` so the gap is visible.

SqlServerSimulator.Tests.EFCore/EFCoreFromSql.cs

@@ -0,0 +1,47 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// EF Core's raw-SQL entry points (<c>FromSqlInterpolated</c> /
+/// <c>FromSqlRaw</c>) bypass the LINQ translator and pass user-written SQL
+/// straight through to the simulator's parser, while still binding C#
+/// interpolated values as typed parameters. This is the realistic path
+/// where mixed-type comparisons (string parameter vs int column) actually
+/// emerge in app code — direct LINQ over strongly-typed entities never
+/// produces that shape.
+/// </summary>
+[TestClass]
+public class EFCoreFromSql
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private static TestDbContext SeededContext()
+    {
+        var context = new TestDbContext(TestDbContext.CreateCustomersSimulation());
+        context.Customers.AddRange(
+            new Customer { Name = "alpha" },
+            new Customer { Name = "beta" },
+            new Customer { Name = "gamma" });
+        _ = context.SaveChanges();
+        return context;
+    }
+
+    [TestMethod]
+    public void FromSqlInterpolated_StringParameterAgainstIntColumn_PromotesAndMatches()
+    {
+        // The C# string interpolation hands EF Core a string value, which
+        // SqlClient binds as nvarchar — so the server-side comparison is
+        // `int_column = nvarchar_param`. Cross-category int↔string Promote
+        // closes the loop: the parameter's nvarchar parses through the
+        // int column's CAST path, the row matches, and entity materialization
+        // proceeds normally.
+        using var context = SeededContext();
+        var idAsString = "2";
+        var customer = context.Customers
+            .FromSqlInterpolated($"select Id, Name from Customers where Id = {idAsString}")
+            .Single();
+        Assert.AreEqual(2, customer.Id);
+        Assert.AreEqual("beta", customer.Name);
+    }
+}

SqlServerSimulator.Tests/TypePromotionTests.cs

@@ -392,4 +392,215 @@ public void Arithmetic_DateTimeMinusInt_OperatorNameIsSubtract()
         var ex = Throws<System.Data.Common.DbException>(() => ExecuteScalar("select cast('2024-01-15' as datetime) - cast('2024-01-15' as date)"));
         AreEqual("The data types datetime and date are incompatible in the subtract operator.", ex.Message);
     }
+
+    // ─── Integer ↔ string Promote (probe-confirmed against SQL Server 2025) ───
+
+    [TestMethod]
+    [DataRow("int", "5", "'5'")]
+    [DataRow("int", "5", "'+5'")]      // sign prefix
+    [DataRow("int", "-5", "'-5'")]
+    [DataRow("int", "5", "' 5'")]      // leading whitespace
+    [DataRow("int", "5", "'5 '")]      // trailing whitespace
+    [DataRow("tinyint", "5", "'5'")]
+    [DataRow("smallint", "5", "'5'")]
+    [DataRow("bigint", "5", "'5'")]
+    public void Comparison_IntegerEqualsString_ParsesAndMatches(string columnType, string seed, string literal)
+    {
+        // Per probe (SQL Server 2025): integer wins, string parses to the
+        // integer's specific type. Whitespace trims; sign prefixes work.
+        AreEqual(1, ExecuteScalar<int>($"select case when cast({seed} as {columnType}) = {literal} then 1 else 0 end"));
+    }
+
+    [TestMethod]
+    public void Comparison_OperandOrderIndependent()
+    {
+        // 'lhs op rhs' must produce the same result as 'rhs op lhs'.
+        AreEqual(1, ExecuteScalar<int>("select case when '5' = 5 then 1 else 0 end"));
+        AreEqual(1, ExecuteScalar<int>("select case when 5 = '5' then 1 else 0 end"));
+    }
+
+    [TestMethod]
+    [DataRow("int", "5", "''")]        // empty string parses to 0
+    [DataRow("int", "0", "''")]        // 0 = '' is true (empty → 0)
+    public void Comparison_EmptyString_ParsesToZero(string columnType, string seed, string literal)
+    {
+        // SQL Server's string→int CAST treats empty / whitespace-only as 0.
+        var expectMatch = seed == "0";
+        AreEqual(expectMatch ? 1 : 0, ExecuteScalar<int>($"select case when cast({seed} as {columnType}) = {literal} then 1 else 0 end"));
+    }
+
+    [TestMethod]
+    [DataRow("'abc'")]
+    [DataRow("'5.5'")]   // decimal-shaped: SQL Server does NOT route through decimal
+    [DataRow("'5.0'")]   // decimal-shaped with trailing zero — still rejected
+    [DataRow("'0x05'")]  // hex notation: rejected (only `0x` literal accepts hex)
+    public void Comparison_UnparseableString_RaisesMsg245(string literal)
+    {
+        var ex = Throws<System.Data.Common.DbException>(() => ExecuteScalar($"select case when 5 = {literal} then 1 else 0 end"));
+        StartsWith("Conversion failed when converting the varchar value", ex.Message);
+        Contains("to data type int", ex.Message);
+    }
+
+    [TestMethod]
+    public void Comparison_NullIntegerVsString_IsUnknown()
+    {
+        // NULL on either side → UNKNOWN (the WHEN excludes; ELSE arm wins).
+        AreEqual(-1, ExecuteScalar<int>("select case when cast(null as int) = '5' then 1 when not (cast(null as int) = '5') then 0 else -1 end"));
+        AreEqual(-1, ExecuteScalar<int>("select case when 5 = cast(null as varchar(10)) then 1 when not (5 = cast(null as varchar(10))) then 0 else -1 end"));
+    }
+
+    [TestMethod]
+    public void Comparison_BitVsStringForms_AllWorkThroughCastPath()
+    {
+        // bit ↔ string COMPARISON works through string→bit CAST: '1', 'true'/'TRUE'
+        // map to true; '0', 'false', and empty map to false.
+        AreEqual(1, ExecuteScalar<int>("select case when cast(1 as bit) = '1' then 1 else 0 end"));
+        AreEqual(1, ExecuteScalar<int>("select case when cast(1 as bit) = 'true' then 1 else 0 end"));
+        AreEqual(1, ExecuteScalar<int>("select case when cast(1 as bit) = 'TRUE' then 1 else 0 end"));
+        AreEqual(1, ExecuteScalar<int>("select case when cast(0 as bit) = 'false' then 1 else 0 end"));
+        AreEqual(1, ExecuteScalar<int>("select case when cast(0 as bit) = '' then 1 else 0 end"));
+    }
+
+    [TestMethod]
+    [DataRow("+", 8)]
+    [DataRow("-", 2)]
+    [DataRow("*", 15)]
+    [DataRow("/", 1)]    // 5 / 3 = 1 (integer division)
+    [DataRow("%", 2)]    // 5 % 3 = 2
+    public void Arithmetic_IntegerWithString_ProducesIntegerResult(string op, int expected)
+    {
+        AreEqual(expected, ExecuteScalar<int>($"select 5 {op} '3'"));
+        AreEqual(expected, ExecuteScalar<int>($"select '5' {op} 3"));
+    }
+
+    [TestMethod]
+    public void Arithmetic_TinyintPlusString_StaysTinyint()
+    {
+        // The integer's specific type is preserved. Encoding the result as
+        // a wider int would mismatch the column's tinyint schema and the
+        // row encoder would reject the write.
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t ( v tinyint )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values (cast(5 as tinyint) + '3')").ExecuteNonQuery();
+        using var select = connection.CreateCommand();
+        select.CommandText = "select v from t";
+        AreEqual((byte)8, select.ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void Arithmetic_BigintWithStringRhs_StaysBigint()
+    {
+        // Mirror of the tinyint case for the wider integer end: bigint + str
+        // returns bigint (verified against SQL Server 2025), not widened
+        // through int. Insert into a bigint column to confirm the runtime
+        // value's type matches the declared schema.
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t ( v bigint )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values (cast(5 as bigint) + '3')").ExecuteNonQuery();
+        using var select = connection.CreateCommand();
+        select.CommandText = "select v from t";
+        AreEqual(8L, select.ExecuteScalar());
+    }
+
+    [TestMethod]
+    [DataRow("+", "add")]
+    [DataRow("-", "subtract")]
+    [DataRow("%", "modulo")]
+    public void Arithmetic_BitWithString_AdditiveAndModulo_RaiseMsg402(string op, string operatorName)
+    {
+        // Bit comparison with string works (string→bit CAST), but bit
+        // arithmetic with string is rejected: + / - / % use Msg 402 with
+        // both type names and the operator word.
+        var ex = Throws<System.Data.Common.DbException>(() => ExecuteScalar($"select cast(1 as bit) {op} '1'"));
+        AreEqual($"The data types bit and varchar are incompatible in the {operatorName} operator.", ex.Message);
+    }
+
+    [TestMethod]
+    [DataRow("*", "multiply")]
+    [DataRow("/", "divide")]
+    public void Arithmetic_BitWithString_MultiplicativeAndDivisive_RaiseMsg8117(string op, string operatorName)
+    {
+        // Multiplicative ops use the date-style Msg 8117 instead of Msg 402,
+        // naming only the LEFT operand's type.
+        var leftEx = Throws<System.Data.Common.DbException>(() => ExecuteScalar($"select cast(1 as bit) {op} '1'"));
+        AreEqual($"Operand data type bit is invalid for {operatorName} operator.", leftEx.Message);
+
+        // Operand-order matters for Msg 8117: the message names the LEFT side.
+        var rightEx = Throws<System.Data.Common.DbException>(() => ExecuteScalar($"select '1' {op} cast(1 as bit)"));
+        AreEqual($"Operand data type varchar is invalid for {operatorName} operator.", rightEx.Message);
+    }
+
+    [TestMethod]
+    public void Arithmetic_NullPropagation()
+    {
+        AreEqual(System.DBNull.Value, ExecuteScalar("select cast(null as int) + '3'"));
+        AreEqual(System.DBNull.Value, ExecuteScalar("select 5 + cast(null as varchar(10))"));
+    }
+
+    [TestMethod]
+    public void WhereClause_ColumnEqualsStringParameter_ParsesAndMatches()
+    {
+        // The EF Core / SqlClient pattern: bind a string parameter against
+        // an int column. With Promote landing int, the comparison runs
+        // through string→int CAST per row.
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t ( id int )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values (5), (10), (15)").ExecuteNonQuery();
+
+        using var select = connection.CreateCommand();
+        select.CommandText = "select id from t where id = @p";
+        var p = select.CreateParameter();
+        p.ParameterName = "@p";
+        p.DbType = System.Data.DbType.String;
+        p.Value = "10";
+        _ = select.Parameters.Add(p);
+
+        using var reader = select.ExecuteReader();
+        IsTrue(reader.Read()); AreEqual(10, reader[0]);
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void WhereClause_VarcharColumnComparedToInt_RaisesPerRowOnUnparseable()
+    {
+        // Reverse direction: varchar column compared to int literal. Per
+        // probe (SQL Server 2025): a single unparseable row halts the whole
+        // query — the failure isn't isolated to one UNKNOWN row.
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t ( s varchar(10) )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values ('5'), ('abc'), ('15')").ExecuteNonQuery();
+
+        using var select = connection.CreateCommand();
+        select.CommandText = "select s from t where s = 5";
+        var ex = Throws<System.Data.Common.DbException>(() =>
+        {
+            using var reader = select.ExecuteReader();
+            while (reader.Read()) { }
+        });
+        StartsWith("Conversion failed when converting the varchar value 'abc'", ex.Message);
+    }
+
+    [TestMethod]
+    public void InList_IntegerLhsWithStringValues_Works()
+    {
+        AreEqual(1, ExecuteScalar<int>("select case when 5 in ('1','5','9') then 1 else 0 end"));
+        AreEqual(0, ExecuteScalar<int>("select case when 5 in ('1','9') then 1 else 0 end"));
+    }
+
+    [TestMethod]
+    public void Coalesce_IntegerAndString_ResultIsInteger()
+    {
+        // coalesce(int, varchar) returns int — the first arg's type drives
+        // when it's non-null; the second is parsed to int if needed.
+        AreEqual(5, ExecuteScalar<int>("select coalesce(5, '99')"));
+        AreEqual(99, ExecuteScalar<int>("select coalesce(cast(null as int), '99')"));
+    }
+
+    [TestMethod]
+    public void Case_ThenIntegerElseString_ResultIsInteger()
+    {
+        AreEqual(5, ExecuteScalar<int>("select case when 1=1 then 5 else '99' end"));
+        AreEqual(99, ExecuteScalar<int>("select case when 1=0 then 5 else '99' end"));
+    }
+
 }

SqlServerSimulator/Parser/Expressions/Coalesce.cs

@@ -13,6 +13,7 @@ namespace SqlServerSimulator.Parser.Expressions;
 internal sealed class Coalesce : Expression
 {
     private readonly Expression[] arguments;
+    private SqlType? cachedResultType;
 
     public Coalesce(ParserContext context)
     {
@@ -34,7 +35,7 @@ public override SqlValue Run(Func<MultiPartName, SqlValue> getColumnValue)
         {
             value = this.arguments[i].Run(getColumnValue);
             if (!value.IsNull)
-                return value;
+                return this.cachedResultType is { } target && value.Type != target ? value.CoerceTo(target) : value;
         }
         return value; // all NULL — return the last (typed-NULL) result
     }
@@ -44,6 +45,7 @@ public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnTyp
         var t = this.arguments[0].GetSqlType(resolveColumnType);
         for (var i = 1; i < this.arguments.Length; i++)
             t = SqlType.Promote(t, this.arguments[i].GetSqlType(resolveColumnType));
+        this.cachedResultType = t;
         return t;
     }