Added scalar subquery support; rerouted Expression.Parse's grouped-expression dispatch to detect SELECT after '(', enforcing Msg 116 / Msg 512.

Author: RyanLamansky

CLAUDE.md

@@ -77,7 +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).
-- Subqueries: `EXISTS (SELECT ...)`, `[NOT] EXISTS`, `expr [NOT] IN (SELECT ...)` parse as boolean atoms in WHERE / HAVING / CHECK; both correlated and non-correlated forms work, with arbitrary outer-scope nesting depth. EXISTS counts rows only (multi-column inner SELECT allowed); `IN (SELECT ...)` requires exactly one inner column (Msg 116) and follows the same NULL semantics as the literal-list IN (NULL row in the subquery → 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 non-correlated case re-executes the inner SELECT 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**: scalar subqueries (`WHERE col = (SELECT ...)` and projection-slot subqueries — these need cardinality enforcement / Msg 512), `ANY` / `SOME` / `ALL` quantifiers, `UNION` / `UNION ALL` inside a subquery body. Derived tables in FROM (already supported) don't see outer scope (no APPLY / lateral).
+- 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.
 - EF Core compatibility: the `SqlServerSimulator.EFCore` adapter (`UseSqlServerSimulator(...)`) covers the seven `SqlParameter`-downcast pairs — `DateOnly → date`, `DateTime → date`, `DateTime → smalldatetime`, `TimeOnly → time(N)`, `TimeSpan → time(N)`, `decimal → money`, `decimal → smallmoney`. Without the adapter (plain `UseSqlServer`), those mappings still throw at SaveChanges as before. The MAX-string family (default-mapped `string` → `nvarchar(max)`, `[Column(TypeName = "varchar(max)")]`, `[Column(TypeName = "varbinary(max)")]`) flows through plain `UseSqlServer` without needing the adapter. Other type pairs the SqlServer provider supports but aren't modeled here (e.g. `hierarchyid`, `geography`, `geometry`, `rowversion`) are not bridged.

SqlServerSimulator.Tests.EFCore/EFCoreSubquery.cs

@@ -85,4 +85,40 @@ public void Where_AnyWithAdditionalPredicate_FiltersInsideSubquery()
             .ToArray();
         CollectionAssert.AreEqual(new[] { 2 }, ids);
     }
+
+    [TestMethod]
+    public void Projection_CountCorrelated_EmitsScalarSubquery()
+    {
+        // EF Core translates `Count` of a related set in projection to a
+        // scalar subquery: `SELECT (SELECT COUNT(*) FROM CustomerOrders o
+        // WHERE o.CustomerId = c.Id) FROM Customers c`. Customers 1, 2, 3
+        // have order counts 2, 1, 0 respectively.
+        using var context = SeededContext();
+        var rows = context.Customers
+            .OrderBy(c => c.Id)
+            .Select(c => new
+            {
+                c.Id,
+                OrderCount = context.CustomerOrders.Count(o => o.CustomerId == c.Id)
+            })
+            .ToArray();
+        Assert.HasCount(3, rows);
+        Assert.AreEqual(2, rows[0].OrderCount);
+        Assert.AreEqual(1, rows[1].OrderCount);
+        Assert.AreEqual(0, rows[2].OrderCount);
+    }
+
+    [TestMethod]
+    public void Where_ScalarComparisonAgainstSubquery_FiltersByMaxAmount()
+    {
+        // EF Core translates `o.Amount == context.CustomerOrders.Max(...)`
+        // to `WHERE o.Amount = (SELECT MAX(o.Amount) FROM CustomerOrders)`.
+        // Single highest-amount order: 30 (CustomerId=2).
+        using var context = SeededContext();
+        var customerIds = context.CustomerOrders
+            .Where(o => o.Amount == context.CustomerOrders.Max(x => x.Amount))
+            .Select(o => o.CustomerId)
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 2 }, customerIds);
+    }
 }

SqlServerSimulator.Tests/SubqueryTests.cs

@@ -289,6 +289,136 @@ public void InSelect_NonCorrelated_ScansSubqueryPerOuterRow()
         CollectionAssert.AreEquivalent(new int?[] { 2, 4 }, matched);
     }
 
+    // === Scalar subqueries ===
+
+    [TestMethod]
+    public void Scalar_InProjection_ReturnsValue()
+    {
+        AreEqual(1, new Simulation().ExecuteScalar("select (select 1)"));
+    }
+
+    [TestMethod]
+    public void Scalar_InArithmetic_FlowsThroughOperator()
+    {
+        AreEqual(6, new Simulation().ExecuteScalar("select (select 1) + 5"));
+    }
+
+    [TestMethod]
+    public void Scalar_EmptyResult_IsNull()
+    {
+        AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select (select 1 where 1=0)"));
+    }
+
+    [TestMethod]
+    public void Scalar_EmptyInArithmetic_PropagatesNull()
+    {
+        AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select (select 1 where 1=0) + 5"));
+    }
+
+    [TestMethod]
+    public void Scalar_InWhereComparison_FiltersByValue()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (x int)");
+        _ = simulation.ExecuteNonQuery("insert into t values (5), (10), (15)");
+
+        using var connection = simulation.CreateOpenConnection();
+        var matched = ReadIntColumn(connection.CreateCommand("select x from t where x = (select max(x) from t)"));
+        CollectionAssert.AreEqual(new int?[] { 15 }, matched);
+    }
+
+    [TestMethod]
+    public void Scalar_NullValueInRow_PropagatesNull()
+    {
+        // Single-row inner with a NULL column value flows through normally.
+        AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select (select cast(null as int)) + 5"));
+    }
+
+    [TestMethod]
+    public void Scalar_MultiRow_RaisesMsg512()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (x int)");
+        _ = simulation.ExecuteNonQuery("insert into t values (1), (2)");
+
+        var ex = Throws<DbException>(() => _ = simulation.ExecuteScalar("select (select x from t)"));
+        AreEqual("512", ex.Data["HelpLink.EvtID"]);
+        AreEqual("Subquery returned more than 1 value. This is not permitted when the subquery follows =, !=, <, <= , >, >= or when the subquery is used as an expression.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Scalar_MultiColumn_RaisesMsg116()
+    {
+        var ex = Throws<DbException>(() =>
+            _ = new Simulation().ExecuteScalar("select (select 1, 2)"));
+        AreEqual("116", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void Scalar_Correlated_ResolvesPerRow()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table a (id int)");
+        _ = simulation.ExecuteNonQuery("create table b (id int, val int)");
+        _ = simulation.ExecuteNonQuery("insert into a values (1), (2), (3)");
+        _ = simulation.ExecuteNonQuery("insert into b values (1, 100), (2, 200)");
+
+        // For each a.id, look up b.val. id=3 has no match → NULL.
+        using var connection = simulation.CreateOpenConnection();
+        using var reader = connection.CreateCommand("select a.id, (select b.val from b where b.id = a.id) as v from a").ExecuteReader();
+        var ids = new List<int>();
+        var vals = new List<int?>();
+        while (reader.Read())
+        {
+            ids.Add(reader.GetInt32(0));
+            vals.Add(reader.IsDBNull(1) ? null : reader.GetInt32(1));
+        }
+        CollectionAssert.AreEqual(new[] { 1, 2, 3 }, ids);
+        CollectionAssert.AreEqual(new int?[] { 100, 200, null }, vals);
+    }
+
+    [TestMethod]
+    public void Scalar_CorrelatedMultiRow_RaisesMsg512()
+    {
+        // Per-outer-row Msg 512: a.id=1 matches two b rows, hits the limit.
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table a (id int)");
+        _ = simulation.ExecuteNonQuery("create table b (id int, val int)");
+        _ = simulation.ExecuteNonQuery("insert into a values (1)");
+        _ = simulation.ExecuteNonQuery("insert into b values (1, 100), (1, 200)");
+
+        using var connection = simulation.CreateOpenConnection();
+        var ex = Throws<DbException>(() =>
+        {
+            using var reader = connection.CreateCommand("select (select b.val from b where b.id = a.id) from a").ExecuteReader();
+            while (reader.Read()) { /* exhaust */ }
+        });
+        AreEqual("512", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void Scalar_AggregateInner_ReturnsAggregate()
+    {
+        // Common EF Core pattern: scalar subquery with COUNT.
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table a (id int)");
+        _ = simulation.ExecuteNonQuery("create table b (id int)");
+        _ = simulation.ExecuteNonQuery("insert into a values (1), (2)");
+        _ = simulation.ExecuteNonQuery("insert into b values (1), (2), (3)");
+
+        using var connection = simulation.CreateOpenConnection();
+        using var reader = connection.CreateCommand("select a.id, (select count(*) from b) as c from a").ExecuteReader();
+        var ids = new List<int>();
+        var counts = new List<int>();
+        while (reader.Read())
+        {
+            ids.Add(reader.GetInt32(0));
+            counts.Add(reader.GetInt32(1));
+        }
+        CollectionAssert.AreEqual(new[] { 1, 2 }, ids);
+        CollectionAssert.AreEqual(new[] { 3, 3 }, counts);
+    }
+
     // === EXISTS with table-alias resolution ===
 
     [TestMethod]

SqlServerSimulator/Parser/Expression.cs

@@ -71,7 +71,7 @@ public static Expression Parse(ParserContext context)
             // 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()),
             Name name => new Reference(name),
-            Operator { Character: '(' } => new Parenthesized(context),
+            Operator { Character: '(' } => ParseGroupedExpression(context),
             _ => throw SimulatedSqlException.SyntaxErrorNear(context)
         };
 
@@ -164,6 +164,34 @@ public static Expression Parse(ParserContext context)
     /// </summary>
     internal abstract string DebugDisplay();
 
+    /// <summary>
+    /// Parses a grouped expression starting at the opening <c>(</c>. Two
+    /// shapes share the leading paren: a parenthesized expression
+    /// (<c>(1 + 2)</c>, parses as <see cref="Parenthesized"/>) or a scalar
+    /// subquery (<c>(SELECT col FROM t)</c>, parses as
+    /// <see cref="ScalarSubqueryExpression"/>). Dispatch is by peeking the
+    /// token immediately after <c>(</c>: a <c>SELECT</c> keyword routes to
+    /// the subquery path; anything else falls through to the standard
+    /// parenthesized form. Both leave the cursor on the closing <c>)</c>,
+    /// matching the lookahead contract <see cref="Parse"/>'s
+    /// binary loop expects.
+    /// </summary>
+    private static Expression ParseGroupedExpression(ParserContext context)
+    {
+        context.MoveNextRequired();
+        if (context.Token is ReservedKeyword { Keyword: Keyword.Select })
+        {
+            var inner = Selection.Parse(context, depth: 1, outerTypeResolver: context.OuterTypeResolver);
+            return inner.Schema.Length != 1
+                ? throw SimulatedSqlException.SubqueryNotIntroducedWithExists()
+                : context.Token is not Operator { Character: ')' }
+                    ? throw SimulatedSqlException.SyntaxErrorNear(context)
+                    : (Expression)new ScalarSubqueryExpression(inner);
+        }
+
+        return new Parenthesized(Expression.Parse(context));
+    }
+
     private static Expression ResolveBuiltIn(string name, ParserContext context)
     {
         Span<char> uppercaseName = stackalloc char[name.Length];

SqlServerSimulator/Parser/Expressions/Parenthesized.cs

@@ -1,12 +1,14 @@
-namespace SqlServerSimulator.Parser.Expressions;
+namespace SqlServerSimulator.Parser.Expressions;
 
 /// <summary>
-/// An expression that's wrapped in parentheses, potentially affecting the order of operations.
+/// An expression that's wrapped in parentheses, potentially affecting the
+/// order of operations. Constructed by <see cref="Expression.Parse"/>'s
+/// grouped-expression dispatch after the inner body is parsed; that
+/// dispatch also handles the alternative <c>(SELECT ...)</c> shape, which
+/// produces a <see cref="ScalarSubqueryExpression"/> instead.
 /// </summary>
-internal sealed class Parenthesized(ParserContext context) : Expression
+internal sealed class Parenthesized(Expression wrapped) : Expression
 {
-    private readonly Expression wrapped = Parse(context.MoveNextRequiredReturnSelf());
-
     public override Storage.SqlValue Run(Func<List<string>, Storage.SqlValue> getColumnValue) => wrapped.Run(getColumnValue);
 
     public override Storage.SqlType GetSqlType(Func<List<string>, Storage.SqlType> resolveColumnType) => wrapped.GetSqlType(resolveColumnType);

SqlServerSimulator/Parser/Expressions/ScalarSubqueryExpression.cs

@@ -0,0 +1,43 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// A <c>(SELECT col FROM ...)</c> subquery used in an expression slot
+/// (projection, WHERE comparison, arithmetic operand, etc.). The inner
+/// SELECT must project exactly one column (Msg 116, enforced at parse time)
+/// and at runtime must return at most one row (Msg 512, enforced per
+/// evaluation). Empty result → NULL of the inner's projected type.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Each <see cref="Run"/> re-executes the inner plan against the caller's
+/// outer-scope resolver, so correlated scalar subqueries see fresh outer-row
+/// values per evaluation. Cardinality enforcement is greedy: pull the first
+/// row, then check whether a second exists by advancing the enumerator one
+/// more time. If it does, raise Msg 512 immediately — no need to materialize
+/// the rest of the result set.
+/// </para>
+/// <para>
+/// <see cref="GetSqlType"/> reads the inner plan's static schema, so the
+/// projection column type is known at parse time without executing.
+/// </para>
+/// </remarks>
+internal sealed class ScalarSubqueryExpression(Selection inner) : Expression
+{
+    public override SqlValue Run(Func<List<string>, SqlValue> getColumnValue)
+    {
+        var resultSet = inner.Execute(getColumnValue);
+        using var enumerator = resultSet.RowBytes.GetEnumerator();
+        if (!enumerator.MoveNext())
+            return SqlValue.Null(resultSet.Schema[0]);
+        var firstRow = enumerator.Current;
+        return enumerator.MoveNext()
+            ? throw SimulatedSqlException.SubqueryReturnedMoreThanOneValue()
+            : RowDecoder.DecodeColumn(resultSet.Schema, firstRow, 0);
+    }
+
+    public override SqlType GetSqlType(Func<List<string>, SqlType> resolveColumnType) => inner.Schema[0];
+
+    internal override string DebugDisplay() => "(SELECT ...)";
+}

SqlServerSimulator/SimulatedSqlException.cs

@@ -268,6 +268,15 @@ internal static SimulatedSqlException IdentifierTooLong(ReadOnlySpan<char> first
     internal static SimulatedSqlException SubqueryNotIntroducedWithExists() =>
         new("Only one expression can be specified in the select list when the subquery is not introduced with EXISTS.", 116, 16, 1);
 
+    /// <summary>
+    /// Mimics SQL Server's Msg 512 — fired when a scalar subquery (or one
+    /// behind a comparison operator) returns more than one row. Verbatim
+    /// text from the probed real SQL Server, including the literal extra
+    /// space in the <c>&lt;= , &gt;</c> sequence.
+    /// </summary>
+    internal static SimulatedSqlException SubqueryReturnedMoreThanOneValue() =>
+        new("Subquery returned more than 1 value. This is not permitted when the subquery follows =, !=, <, <= , >, >= or when the subquery is used as an expression.", 512, 16, 1);
+
     internal static SimulatedSqlException MissingEndCommentMark() => new("Missing end comment mark '*/'.", 113, 15, 1);
 
     internal static SimulatedSqlException MustDeclareScalarVariable(string name) => new($"Must declare the scalar variable \"@{name}\".", 137, 15, 2);