Added CASE expression support (searched + simple forms, type-promoted result coercion); implemented SimulatedDbDataReader.GetBoolean.

Author: RyanLamansky

CLAUDE.md

@@ -77,6 +77,7 @@ Heavy-hitters someone might assume work but don't. Source and `git log` are the
 - `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.
 - `CONVERT` / `TRY_CONVERT` style-code coverage. Only styles `0`, `120`, and `121` are wired up for date-like sources targeting a character string (the EF Core code-generation defaults). Other style numbers raise Msg 281; money / float / binary style codes and `CONVERT(date, str, 103)`-style date-parsing styles aren't modeled.
 - Boolean combinators in WHERE / MERGE-ON / CHECK predicates: `AND` / `OR` / `NOT`, parenthesized groupings, `IS [NOT] NULL`, and `[NOT] IN (literal, literal, ...)` all parse with standard SQL precedence (AND > OR; NOT highest). The pattern `where (arith_expr) cmp rhs` (parens-around-arithmetic as the left side of a comparison) is the one shape the simulator's parser doesn't accept; SQL Server does. `BooleanExpression.Run` returns `bool?` (three-valued: true / false / UNKNOWN); WHERE / MERGE-ON treat UNKNOWN as exclude, CHECK treats UNKNOWN as pass — matching SQL Server. `IS NULL` definitively resolves UNKNOWN to true/false (it's the canonical way to test nullability without falling through tri-state).
+- `CASE` expressions: both searched (`CASE WHEN cond THEN ... [ELSE ...] END`) and simple (`CASE input WHEN val THEN ... [ELSE ...] END`) forms parse anywhere an expression is allowed. Branches evaluate in source order; first true predicate wins. UNKNOWN is treated as exclude (matching WHERE), so the simple form's NULL-vs-NULL `WHEN` falls through (`CASE NULL WHEN NULL` → no match). Result type is computed via `SqlType.Promote` across all THEN / ELSE branches and cached on the first `GetSqlType` call; `Run` then coerces matched values to that common type so projection schema stays consistent. No-match-no-ELSE → typed NULL. **Not enforced**: Msg 8133 (real SQL Server raises this when every branch is a bare `NULL` literal — the simulator returns NULL of `int`).
 - Subqueries: `EXISTS (SELECT ...)` / `[NOT] EXISTS` and `expr [NOT] IN (SELECT ...)` parse as boolean atoms in WHERE / HAVING / CHECK; scalar subqueries `(SELECT col FROM ...)` parse anywhere an expression is allowed (projection, WHERE comparison, arithmetic operand). All forms work both correlated and non-correlated, with arbitrary outer-scope nesting depth. EXISTS counts rows only (multi-column inner allowed); `IN (SELECT ...)` and scalar subqueries require exactly one inner column (Msg 116). Scalar subqueries also enforce single-row cardinality at runtime (Msg 512, fired per outer row for correlated cases); empty result → NULL of the inner's projected type. NULL semantics in `IN (SELECT ...)` mirror the literal-list IN (NULL row → UNKNOWN unless a non-NULL match wins first). Column resolution honors qualifiers (`alias.col` / `tableName.col`) so a correlated reference to an outer column with the same name as an inner column works correctly. The inner plan re-executes per outer row (no result caching yet — fidelity over performance for now). `Selection.Parse` returns a deferred plan; `Selection.Execute(outerResolver)` materializes results, so the same plan re-runs against different outer rows. **Not modeled**: `ANY` / `SOME` / `ALL` quantifiers, `UNION` / `UNION ALL` inside a subquery body, row-constructor `IN ((1,2), (3,4))`. Derived tables in FROM (already supported) don't see outer scope (no APPLY / lateral).
 - `LIKE` `COLLATE` override. The default collation (case-insensitive, Latin1_General-shaped) is what every `LIKE` runs under; explicit `COLLATE` clauses on the predicate aren't parsed yet.
 - Cross-category `Promote` for integer ↔ string. Only CAST works for that pair.

SqlServerSimulator.Tests.EFCore/EFCoreCase.cs

@@ -0,0 +1,63 @@
+namespace SqlServerSimulator;
+
+/// <summary>
+/// End-to-end tests for the LINQ projection / WHERE shapes EF Core's
+/// SqlServer provider emits as <c>CASE</c> expressions: ternary
+/// projections, <c>Any()</c> in projection (wraps EXISTS in
+/// <c>CASE WHEN ... THEN CAST(1 AS bit) ELSE CAST(0 AS bit) END</c>), and
+/// boolean conditional projections.
+/// </summary>
+[TestClass]
+public class EFCoreCase
+{
+    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();
+        context.CustomerOrders.AddRange(
+            new CustomerOrder { CustomerId = 1, Amount = 10m },
+            new CustomerOrder { CustomerId = 2, Amount = 30m });
+        _ = context.SaveChanges();
+        return context;
+    }
+
+    [TestMethod]
+    public void Projection_Ternary_EmitsCase()
+    {
+        // EF Core translates `c.Id > 1 ? "big" : "small"` to
+        // `SELECT CASE WHEN [c].[Id] > 1 THEN N'big' ELSE N'small' END`.
+        using var context = SeededContext();
+        var labels = context.Customers
+            .OrderBy(c => c.Id)
+            .Select(c => c.Id > 1 ? "big" : "small")
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { "small", "big", "big" }, labels);
+    }
+
+    [TestMethod]
+    public void Projection_AnyCorrelated_EmitsCaseWithExists()
+    {
+        // EF Core translates `Any` in a projection slot to
+        // `SELECT CASE WHEN EXISTS (...) THEN CAST(1 AS bit) ELSE CAST(0 AS bit) END`.
+        // Customers with at least one order: 1 and 2.
+        using var context = SeededContext();
+        var rows = context.Customers
+            .OrderBy(c => c.Id)
+            .Select(c => new
+            {
+                c.Id,
+                HasOrder = context.CustomerOrders.Any(o => o.CustomerId == c.Id)
+            })
+            .ToArray();
+        Assert.HasCount(3, rows);
+        Assert.IsTrue(rows[0].HasOrder);
+        Assert.IsTrue(rows[1].HasOrder);
+        Assert.IsFalse(rows[2].HasOrder);
+    }
+}

SqlServerSimulator.Tests/CaseExpressionTests.cs

@@ -0,0 +1,171 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Behavioral tests for SQL Server's <c>CASE</c> expression in both forms:
+/// searched (<c>CASE WHEN cond THEN ... [ELSE ...] END</c>) and simple
+/// (<c>CASE input WHEN val THEN ... [ELSE ...] END</c>). NULL handling,
+/// type promotion across branches, and composability with other expression
+/// contexts (WHERE, arithmetic, scalar subqueries) are sourced from probes
+/// against SQL Server 2025.
+/// </summary>
+[TestClass]
+public sealed class CaseExpressionTests
+{
+    // === Searched form ===
+
+    [TestMethod]
+    public void Searched_FirstMatchingWhenWins()
+    {
+        AreEqual("a", new Simulation().ExecuteScalar("select case when 1=1 then 'a' when 1=1 then 'b' end"));
+    }
+
+    [TestMethod]
+    public void Searched_NoMatchNoElse_ReturnsNull()
+    {
+        // ExecuteScalar returns the value of the first column of the first row.
+        // For a single row with a NULL column, that's DBNull.Value.
+        AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select case when 1=0 then 'a' end"));
+    }
+
+    [TestMethod]
+    public void Searched_NoMatch_FallsBackToElse()
+    {
+        AreEqual("z", new Simulation().ExecuteScalar("select case when 1=0 then 'a' else 'z' end"));
+    }
+
+    [TestMethod]
+    public void Searched_UnknownPredicate_TreatedAsExclude()
+    {
+        // `null = 1` evaluates to UNKNOWN; UNKNOWN is not a match (same as WHERE).
+        AreEqual("unmatched", new Simulation().ExecuteScalar("select case when null = 1 then 'matched' else 'unmatched' end"));
+    }
+
+    [TestMethod]
+    public void Searched_MultipleWhens_FirstTrueWins()
+    {
+        AreEqual("second", new Simulation().ExecuteScalar(
+            "select case when 1=0 then 'first' when 2=2 then 'second' when 3=3 then 'third' end"));
+    }
+
+    // === Simple form ===
+
+    [TestMethod]
+    public void Simple_InputMatchesWhen_ReturnsThen()
+    {
+        AreEqual("two", new Simulation().ExecuteScalar("select case 2 when 1 then 'one' when 2 then 'two' else 'other' end"));
+    }
+
+    [TestMethod]
+    public void Simple_NullInputVsNullWhen_NotAMatch()
+    {
+        // `case null when null` follows `=` semantics: NULL = NULL is UNKNOWN, not a match.
+        AreEqual("unmatched", new Simulation().ExecuteScalar(
+            "select case cast(null as int) when null then 'matched' else 'unmatched' end"));
+    }
+
+    [TestMethod]
+    public void Simple_NoMatch_FallsBackToElse()
+    {
+        AreEqual("other", new Simulation().ExecuteScalar(
+            "select case 99 when 1 then 'one' when 2 then 'two' else 'other' end"));
+    }
+
+    [TestMethod]
+    public void Simple_NoMatchNoElse_ReturnsNull()
+    {
+        AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select case 99 when 1 then 'one' when 2 then 'two' end"));
+    }
+
+    // === Composition ===
+
+    [TestMethod]
+    public void Case_InArithmetic_FlowsThroughOperator()
+    {
+        AreEqual(15, new Simulation().ExecuteScalar("select case when 1=1 then 10 else 20 end + 5"));
+    }
+
+    [TestMethod]
+    public void Case_InWhereClause_FiltersByDecision()
+    {
+        // Note: outer parens around the CASE are NOT used here — the
+        // simulator's parser doesn't accept `(arith) cmp rhs` (a known
+        // limitation). Bare `case ... end = 1` parses fine.
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int, name nvarchar(20))");
+        _ = simulation.ExecuteNonQuery("insert into t values (1, 'one'), (2, 'two'), (3, 'three')");
+
+        using var connection = simulation.CreateOpenConnection();
+        using var reader = connection.CreateCommand(
+            "select id from t where case when name='two' then 1 else 0 end = 1").ExecuteReader();
+        var ids = new List<int>();
+        while (reader.Read())
+            ids.Add(reader.GetInt32(0));
+        CollectionAssert.AreEqual(new[] { 2 }, ids);
+    }
+
+    [TestMethod]
+    public void Case_WithColumnReference_ResolvesPerRow()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int, name nvarchar(20))");
+        _ = simulation.ExecuteNonQuery("insert into t values (1, 'one'), (2, 'two'), (3, 'three')");
+
+        using var connection = simulation.CreateOpenConnection();
+        using var reader = connection.CreateCommand(
+            "select case when id = 2 then name else 'other' end from t").ExecuteReader();
+        var labels = new List<string>();
+        while (reader.Read())
+            labels.Add(reader.GetString(0));
+        CollectionAssert.AreEqual(new[] { "other", "two", "other" }, labels);
+    }
+
+    [TestMethod]
+    public void Case_Nested_OuterAndInnerEvaluateCorrectly()
+    {
+        AreEqual("inner-yes", new Simulation().ExecuteScalar(
+            "select case when 1=1 then case when 2=2 then 'inner-yes' else 'inner-no' end else 'outer-no' end"));
+    }
+
+    [TestMethod]
+    public void Case_WithNullElse_ReturnsThenWhenMatched()
+    {
+        AreEqual(5, new Simulation().ExecuteScalar("select case when 1=1 then 5 else null end"));
+    }
+
+    [TestMethod]
+    public void Case_WithNullThen_ReturnsNullWhenMatched()
+    {
+        AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select case when 1=1 then null else 5 end"));
+    }
+
+    [TestMethod]
+    public void Case_InScalarSubquery_ProjectsValue()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int)");
+        _ = simulation.ExecuteNonQuery("insert into t values (1)");
+
+        AreEqual("hit", simulation.ExecuteScalar(
+            "select (select case when t.id = 1 then 'hit' else 'miss' end from t)"));
+    }
+
+    // === Syntax errors ===
+
+    [TestMethod]
+    public void Case_EmptyNoWhen_RaisesSyntaxError()
+    {
+        // `case end` has no WHEN clauses; SQL Server raises Msg 156 near `end`.
+        var ex = Throws<DbException>(() => _ = new Simulation().ExecuteScalar("select case end"));
+        AreEqual("102", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void Case_MissingEnd_RaisesSyntaxError()
+    {
+        var ex = Throws<DbException>(() => _ = new Simulation().ExecuteScalar("select case when 1=1 then 'a'"));
+        AreEqual("102", ex.Data["HelpLink.EvtID"]);
+    }
+}

SqlServerSimulator/Parser/Expression.cs

@@ -66,6 +66,7 @@ public static Expression Parse(ParserContext context)
                 ? new LastIdentityExpression(context.Simulation)
                 : new Value(doubleAtPrefixedString),
             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.