Null/conditional shorthand: ISNULL / IIF / NULLIF — three EF-Core-frequent expressions added in Parser/Expressions/. ISNULL fixes its result type to the first argument's type and coerces the fallback (distinct from 2-arg COALESCE's joint promotion); wrong arity → Msg 174. IIF is a searched-CASE shorthand with joint-promoted arms; NULLIF is CASE WHEN a = b THEN NULL ELSE a END with first-arg-typed result. NULLIF joins COALESCE / CONVERT / TRY_CONVERT in the reserved-keyword passthrough lists; ISNULL and IIF dispatch through the normal Reference-name path. Stale "rowversion" entry dropped from CLAUDE.md's "Not modeled" list (the dedicated rowversion subsection has described it as fully modeled since the rowversion bundle).

Author: RyanLamansky

CLAUDE.md

@@ -171,6 +171,14 @@ Bare `*` and qualified `<source>.*` both work. `*` expands to every column of ev
 ### CASE
 Searched (`CASE WHEN cond THEN ... [ELSE ...] END`) and simple (`CASE input WHEN val ...`). Branches evaluate in order; first true predicate wins. UNKNOWN excludes (matches WHERE); simple-form `CASE NULL WHEN NULL` falls through. Result type computed via `SqlType.Promote` across all THEN/ELSE, cached on first `GetSqlType`; `Run` coerces matched values to the common type. No-match-no-ELSE → typed NULL.
 
+### Null / conditional shorthand: `ISNULL` / `IIF` / `NULLIF`
+EF Core 10 emission (probe-confirmed 2026-05-09): `ISNULL` is emitted for `?? <fallback>` only when a CAST is involved — e.g. `(decimal?)nullableInt ?? 0m` translates to `ISNULL(CAST([f].[NullableC] AS decimal(18,2)), 0.0)`; bare `nullableInt ?? 0` emits `COALESCE` instead. `IIF` and `NULLIF` aren't emitted by any natural LINQ shape we found — EF Core picks `CASE WHEN ... THEN ... ELSE ... END` for ternary projections and safe-divide. Both reach app code through `FromSqlInterpolated` / `FromSqlRaw` rather than the LINQ translator, so support is still load-bearing for raw-SQL consumers. Probe-confirmed against SQL Server 2025 (2026-05-09):
+- `ISNULL(check, replacement)` — returns `check` if non-NULL, else `replacement` coerced to `check`'s type. **Result type and length are fixed to the first argument** — `ISNULL(varchar(5), 'longerstring')` truncates the fallback to 5 characters; `ISNULL(int_null, 'abc')` raises Msg 245 at runtime through int's CAST path. Distinct from 2-arg `COALESCE` (joint promotion). Wrong arity (1 or 3+ arguments) → **Msg 174** `"The isnull function requires 2 argument(s)."`.
+- `IIF(condition, true_value, false_value)` — equivalent to `CASE WHEN condition THEN true_value ELSE false_value END`. Result type is the joint promotion of the two value arms (matching CASE's branch-unification rule); UNKNOWN condition routes to the false arm.
+- `NULLIF(a, b)` — equivalent to `CASE WHEN a = b THEN NULL ELSE a END`. Result type is fixed to `a`'s type. Equality uses simple-form CASE / `=` semantics (NULL on either side → UNKNOWN → ELSE arm returns `a`, which is itself NULL when the NULL is on the left).
+
+`IsNullExpression`, `Iif`, and `NullIf` (`Parser/Expressions/`) each cache the result type from `GetSqlType` and coerce the matched value at `Run` time, the same pattern as `Coalesce` / `CaseExpression`. `NullIf` reuses `BooleanExpression.CompareValuesPromoted` for its equality check. `NULLIF` is a reserved keyword (per the SQL Server reserved-words list) so it appears alongside `Coalesce` / `Convert` / `Try_Convert` in `Expression.Parse`'s and `Selection.cs`'s function-keyword passthrough lists; `ISNULL` and `IIF` are not reserved and dispatch through the standard `Reference`-name path. The simulator deliberately does *not* raise Msg 8133 for `IIF(c, NULL, NULL)` or Msg 4127 for `NULLIF(NULL, NULL)` — both inherit the existing CASE-deviation that returns typed NULL when SQL Server would reject the bare-NULL form.
+
 ### Subqueries
 - `EXISTS (SELECT ...)` / `NOT EXISTS` — boolean atom in WHERE/HAVING/CHECK. Multi-column inner allowed.
 - `expr [NOT] IN (SELECT ...)` — boolean atom; exactly one inner column (Msg 116). NULL semantics mirror literal-list IN (NULL row → UNKNOWN unless a non-NULL match wins first).
@@ -321,7 +329,7 @@ Type-metadata accessors (`GetDataTypeName` / `GetFieldType`) read from `Simulate
 - `PRIMARY KEY` / `UNIQUE` on a computed column (would need to evaluate the expression against every existing row at insert; `NotSupportedException`).
 - Heap allocation tracking: flat page list, no IAM/PFS.
 - Per-connection session state for some scopes: `SCOPE_IDENTITY()` / `@@IDENTITY`, `SET IDENTITY_INSERT`'s active table, `DBCC TRACEON(N)` flags all live on `Simulation` rather than the connection. (Transaction state already moved to per-connection in `SimulatedDbConnection.CurrentTransaction`.)
-- `hierarchyid`, `geography`, `geometry`, `rowversion`.
+- `hierarchyid`, `geography`, `geometry`.
 
 ---
 

SqlServerSimulator.Tests.EFCore/EFCoreNullConditional.cs

@@ -0,0 +1,66 @@
+namespace SqlServerSimulator;
+
+/// <summary>
+/// End-to-end coverage for the LINQ shapes EF Core 10 translates to
+/// <c>ISNULL</c>. Probe-confirmed against EF Core 10 (2026-05-09):
+/// <c>ISNULL</c> emission is gated on a CAST being involved in the
+/// <c>??</c> operands — <c>(decimal?)nullableInt ?? 0m</c> translates to
+/// <c>ISNULL(CAST([f].[NullableC] AS decimal(18,2)), 0.0)</c>, while
+/// plain <c>nullableInt ?? 0</c> picks <c>COALESCE</c> instead. <c>IIF</c>
+/// and <c>NULLIF</c> aren't emitted by any natural LINQ shape we found
+/// (EF Core picks <c>CASE</c> for ternary projections and safe-divide),
+/// so they don't have an EF Core integration story — direct simulator
+/// coverage in <c>IsNullIifNullIfTests</c> is the right surface.
+/// </summary>
+[TestClass]
+public class EFCoreNullConditional
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private static TestDbContext SeededFiltersContext()
+    {
+        var context = new TestDbContext(TestDbContext.CreateFiltersSimulation());
+        context.Filters.AddRange(
+            new Filter { A = 10, B = 2, NullableC = 5, IsActive = true, Status = "open" },
+            new Filter { A = 10, B = 0, NullableC = null, IsActive = false, Status = null },
+            new Filter { A = 20, B = 5, NullableC = 7, IsActive = true, Status = "open" });
+        _ = context.SaveChanges();
+        return context;
+    }
+
+    [TestMethod]
+    public void IsNull_DecimalCastNullCoalesce_ReplacesNullWithFallback()
+    {
+        // (decimal?)f.NullableC ?? 0m → ISNULL(CAST(... AS decimal(18,2)), 0.0)
+        using var context = SeededFiltersContext();
+        var values = context.Filters
+            .OrderBy(f => f.Id)
+            .Select(f => (decimal?)f.NullableC ?? 0m)
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 5m, 0m, 7m }, values);
+    }
+
+    [TestMethod]
+    public void IsNull_LongCastNullCoalesce_ReplacesNullWithFallback()
+    {
+        // (long?)f.NullableC ?? 0L → ISNULL(CAST(... AS bigint), CAST(0 AS bigint))
+        using var context = SeededFiltersContext();
+        var values = context.Filters
+            .OrderBy(f => f.Id)
+            .Select(f => (long?)f.NullableC ?? 0L)
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 5L, 0L, 7L }, values);
+    }
+
+    [TestMethod]
+    public void IsNull_ChainedCoalesce_FallsThroughToInnerCast()
+    {
+        // (decimal?)f.NullableC ?? (decimal?)f.A ?? 0m → ISNULL(CAST(NullableC), CAST(A))
+        using var context = SeededFiltersContext();
+        var values = context.Filters
+            .OrderBy(f => f.Id)
+            .Select(f => (decimal?)f.NullableC ?? (decimal?)f.A ?? 0m)
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 5m, 10m, 7m }, values);
+    }
+}

SqlServerSimulator.Tests/IsNullIifNullIfTests.cs

@@ -0,0 +1,212 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+[TestClass]
+public sealed class IsNullIifNullIfTests
+{
+    [TestMethod]
+    public void IsNull_NonNullFirst_ReturnsFirst()
+    {
+        AreEqual(5, ExecuteScalar<int>("select isnull(5, 99)"));
+        AreEqual("hello", ExecuteScalar("select isnull('hello', 'world')"));
+    }
+
+    [TestMethod]
+    public void IsNull_NullFirst_ReturnsSecondCoercedToFirstType()
+    {
+        AreEqual(42, ExecuteScalar<int>("select isnull(cast(null as int), '42')"));
+        AreEqual(99, ExecuteScalar<int>("select isnull(cast(null as int), 99)"));
+    }
+
+    [TestMethod]
+    public void IsNull_NullFirst_NonNumericString_RaisesMsg245()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select isnull(cast(null as int), 'abc')"));
+        StartsWith("Conversion failed when converting the varchar value 'abc'", ex.Message);
+    }
+
+    [TestMethod]
+    public void IsNull_BothNull_ReturnsTypedNull()
+    {
+        AreEqual(DBNull.Value, ExecuteScalar("select isnull(cast(null as int), cast(null as bigint))"));
+        AreEqual(DBNull.Value, ExecuteScalar("select isnull(null, null)"));
+    }
+
+    [TestMethod]
+    public void IsNull_OneArg_RaisesMsg174()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select isnull(5)"));
+        AreEqual("The isnull function requires 2 argument(s).", ex.Message);
+        AreEqual("174", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void IsNull_ThreeArgs_RaisesMsg174()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select isnull(null, null, 1)"));
+        AreEqual("The isnull function requires 2 argument(s).", ex.Message);
+        AreEqual("174", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void IsNull_FirstWins_NoCoercionOfFallback()
+    {
+        // 5 is non-null, so the second arg's parse is skipped — even though
+        // 'invalid' would fail to convert to int, it's never reached.
+        AreEqual(5, ExecuteScalar<int>("select isnull(cast(5 as int), cast('invalid' as varchar(20)))"));
+    }
+
+    [TestMethod]
+    public void IsNull_AggregateFallback()
+    {
+        // EF Core emits this shape constantly: SUM over an empty filter
+        // returns NULL; ISNULL substitutes a default.
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table t (v int)");
+        AreEqual(0, sim.ExecuteScalar<int>("select isnull(sum(v), 0) from t where 1=0"));
+    }
+
+    [TestMethod]
+    public void IsNull_Nested()
+    {
+        AreEqual(5, ExecuteScalar<int>("select isnull(isnull(cast(null as int), cast(null as int)), 5)"));
+    }
+
+    [TestMethod]
+    public void Iif_TrueBranch()
+    {
+        AreEqual("yes", ExecuteScalar("select iif(1=1, 'yes', 'no')"));
+        AreEqual(5, ExecuteScalar<int>("select iif(1=1, 5, 99)"));
+    }
+
+    [TestMethod]
+    public void Iif_FalseBranch()
+    {
+        AreEqual("no", ExecuteScalar("select iif(1=2, 'yes', 'no')"));
+        AreEqual(99, ExecuteScalar<int>("select iif(1=2, 5, 99)"));
+    }
+
+    [TestMethod]
+    public void Iif_UnknownConditionRoutesToFalse()
+    {
+        // UNKNOWN-condition CASE-equivalent semantics: not-true → ELSE arm.
+        AreEqual("else", ExecuteScalar("select iif(null=1, 'eq', 'else')"));
+        AreEqual("b", ExecuteScalar("select iif(cast(null as bit) = 1, 'a', 'b')"));
+    }
+
+    [TestMethod]
+    public void Iif_TypePromotion()
+    {
+        // int + decimal arms → decimal result.
+        var result = ExecuteScalar("select iif(1=1, cast(5 as int), cast(5.5 as decimal(10,2)))");
+        AreEqual(5m, result);
+        var resultFalse = ExecuteScalar("select iif(1=2, cast(5 as int), cast(5.5 as decimal(10,2)))");
+        AreEqual(5.5m, resultFalse);
+    }
+
+    [TestMethod]
+    public void Iif_NullArm_PropagatesNull()
+    {
+        AreEqual(DBNull.Value, ExecuteScalar("select iif(1=1, null, 5)"));
+        AreEqual(5, ExecuteScalar<int>("select iif(1=2, null, 5)"));
+    }
+
+    [TestMethod]
+    public void Iif_FromTableRow()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table t (id int, name varchar(20))");
+        _ = sim.ExecuteNonQuery("insert into t (id, name) values (1, 'a'), (-1, 'b')");
+        using var reader = sim.ExecuteReader("select iif(id > 0, name, 'none') from t order by id");
+        IsTrue(reader.Read());
+        AreEqual("none", reader.GetString(0));
+        IsTrue(reader.Read());
+        AreEqual("a", reader.GetString(0));
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void Iif_TwoArgs_RaisesSyntax()
+    {
+        _ = Throws<DbException>(() => ExecuteScalar("select iif(1=1, 'a')"));
+    }
+
+    [TestMethod]
+    public void Iif_FourArgs_RaisesSyntax()
+    {
+        _ = Throws<DbException>(() => ExecuteScalar("select iif(1=1, 'a', 'b', 'c')"));
+    }
+
+    [TestMethod]
+    public void NullIf_Equal_ReturnsNull()
+    {
+        AreEqual(DBNull.Value, ExecuteScalar("select nullif(5, 5)"));
+        AreEqual(DBNull.Value, ExecuteScalar("select nullif('abc', 'abc')"));
+    }
+
+    [TestMethod]
+    public void NullIf_NotEqual_ReturnsFirst()
+    {
+        AreEqual(5, ExecuteScalar<int>("select nullif(5, 3)"));
+        AreEqual("abc", ExecuteScalar("select nullif('abc', 'def')"));
+    }
+
+    [TestMethod]
+    public void NullIf_FirstNull_ReturnsNull()
+    {
+        // a is NULL → equality is UNKNOWN → ELSE branch returns a (NULL).
+        AreEqual(DBNull.Value, ExecuteScalar("select nullif(cast(null as int), 5)"));
+    }
+
+    [TestMethod]
+    public void NullIf_SecondNull_ReturnsFirst()
+    {
+        // a non-null, b NULL → equality is UNKNOWN → ELSE branch returns a.
+        AreEqual(5, ExecuteScalar<int>("select nullif(5, cast(null as int))"));
+    }
+
+    [TestMethod]
+    public void NullIf_TypeMix_PromotedEquality_ReturnsNull()
+    {
+        // 5 (int) compared against 5.0 (decimal) — equality holds via promote;
+        // result is NULL, typed as int (first-arg type).
+        AreEqual(DBNull.Value, ExecuteScalar("select nullif(cast(5 as int), cast(5.0 as decimal(10,2)))"));
+    }
+
+    [TestMethod]
+    public void NullIf_TypeMix_NotEqual_ReturnsFirstAtFirstType()
+    {
+        // 5 (int) != 5.5 (decimal) — returns 5 as int.
+        AreEqual(5, ExecuteScalar<int>("select nullif(cast(5 as int), cast(5.5 as decimal(10,2)))"));
+    }
+
+    [TestMethod]
+    public void NullIf_OneArg_RaisesSyntax()
+    {
+        _ = Throws<DbException>(() => ExecuteScalar("select nullif(5)"));
+    }
+
+    [TestMethod]
+    public void NullIf_ThreeArgs_RaisesSyntax()
+    {
+        _ = Throws<DbException>(() => ExecuteScalar("select nullif(1, 2, 3)"));
+    }
+
+    [TestMethod]
+    public void NullIf_FromTableRow_EfCoreSafeDividePattern()
+    {
+        // EF Core emits NULLIF for safe-divide: a / NULLIF(b, 0).
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table t (a int, b int)");
+        _ = sim.ExecuteNonQuery("insert into t (a, b) values (10, 2), (10, 0)");
+        using var reader = sim.ExecuteReader("select a / nullif(b, 0) from t order by b");
+        IsTrue(reader.Read());
+        IsTrue(reader.IsDBNull(0));
+        IsTrue(reader.Read());
+        AreEqual(5, reader.GetInt32(0));
+        IsFalse(reader.Read());
+    }
+}

SqlServerSimulator/Errors/SimulatedSqlException.QueryErrors.cs

@@ -86,6 +86,15 @@ internal static SimulatedSqlException FetchMustBeGreaterThanZero() =>
 
     internal static SimulatedSqlException UnrecognizedBuiltInFunction(string name) => new($"'{name}' is not a recognized built-in function name.", 195, 15, 10);
 
+    /// <summary>
+    /// Mimics SQL Server's Msg 174 — fired when a built-in function is called
+    /// with the wrong number of arguments (e.g. <c>ISNULL(x)</c> or
+    /// <c>ISNULL(a, b, c)</c>). The function name is rendered lowercase in
+    /// the message regardless of source casing — probe-confirmed.
+    /// </summary>
+    internal static SimulatedSqlException FunctionRequiresNArguments(string functionLowerName, int argumentCount) =>
+        new($"The {functionLowerName} function requires {argumentCount} argument(s).", 174, 15, 1);
+
     /// <summary>
     /// Mimics SQL Server error 155: the first argument to <c>DATEPART</c> /
     /// <c>DATEADD</c> / <c>DATEDIFF</c> / etc. wasn't a recognized datepart

SqlServerSimulator/Parser/Expression.cs

@@ -70,10 +70,11 @@ public static Expression Parse(ParserContext context)
             },
             ReservedKeyword { Keyword: Keyword.Null } => new Value(),
             ReservedKeyword { Keyword: Keyword.Case } => CaseExpression.ParseCase(context),
-            // LEFT, RIGHT, CONVERT, and TRY_CONVERT are reserved keywords
-            // but dispatch as function calls when followed by '(' — the
-            // surrounding loop hands the call shape off to ResolveBuiltIn.
-            ReservedKeyword { Keyword: Keyword.Left or Keyword.Right or Keyword.Convert or Keyword.Try_Convert or Keyword.Coalesce } reserved => new Reference(reserved.ToString()),
+            // LEFT, RIGHT, CONVERT, TRY_CONVERT, COALESCE, and NULLIF are
+            // reserved keywords but dispatch as function calls when followed
+            // by '(' — the surrounding loop hands the call shape off to
+            // ResolveBuiltIn.
+            ReservedKeyword { Keyword: Keyword.Left or Keyword.Right or Keyword.Convert or Keyword.Try_Convert or Keyword.Coalesce or Keyword.NullIf } reserved => new Reference(reserved.ToString()),
             Name name => new Reference(name),
             Operator { Character: '(' } => ParseGroupedExpression(context),
             _ => throw SimulatedSqlException.SyntaxErrorNear(context)
@@ -237,6 +238,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
             {
                 "ABS" => new AbsoluteValue(context),
                 "AVG" => AggregateExpression.Parse(context, AggregateKind.Avg),
+                "IIF" => new Iif(context),
                 "LEN" => new Length(context),
                 "MAX" => AggregateExpression.Parse(context, AggregateKind.Max),
                 "MIN" => AggregateExpression.Parse(context, AggregateKind.Min),
@@ -266,6 +268,8 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
             },
             6 => uppercaseName switch
             {
+                "ISNULL" => new IsNullExpression(context),
+                "NULLIF" => new NullIf(context),
                 "STDEVP" => AggregateExpression.Parse(context, AggregateKind.StdevP),
                 _ => null
             },