Properly implemented AND in WHERE clauses.

Author: RyanLamansky

CLAUDE.md

@@ -75,6 +75,7 @@ Heavy-hitters someone might assume work but don't. Source and `git log` are the
 - `text` / `ntext` / `image` operation restrictions: comparison (Msg 402) and ORDER BY / DISTINCT (Msg 306) are enforced; function-level restrictions (e.g. `LEN(ntext)` raising Msg 8116) and the legacy `READTEXT`/`WRITETEXT`/`UPDATETEXT` family aren't modeled.
 - `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 predicates: `AND` chains work, but `OR` / `NOT` (at the predicate-combinator level — `NOT LIKE` is fine inside a single predicate) and parenthesized predicate groupings aren't parsed yet. `OR` raises `NotSupportedException`.
 - `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/KeyConstraintTests.cs

@@ -99,13 +99,10 @@ public void PrimaryKey_DuplicateInsert_StringValue_RendersWithoutQuotes()
     [TestMethod]
     public void PrimaryKey_TableLevel_Composite_Works()
     {
-        // Each (a, b) pair distinct → all three insert successfully. Read-back
-        // uses single-predicate WHERE (composite-key equality projection
-        // already exercised by the duplicate-violation test).
         var simulation = new Simulation();
         _ = simulation.ExecuteNonQuery("create table t (a int not null, b int not null, c int, constraint pk_t primary key (a, b))");
         _ = simulation.ExecuteNonQuery("insert into t values (1, 2, 100), (1, 3, 200), (2, 2, 300)");
-        Assert.AreEqual(200, simulation.ExecuteScalar("select c from t where b = 3"));
+        Assert.AreEqual(200, simulation.ExecuteScalar("select c from t where a = 1 and b = 3"));
     }
 
     [TestMethod]

SqlServerSimulator.Tests/WhereTests.cs

@@ -332,6 +332,61 @@ public void FromTableWhere_CrossPrecisionDateTimeOffsetComparison()
         IsFalse(reader.Read());
     }
 
+    [TestMethod]
+    public void Where_AndChain_TwoPredicates_BothMustHold()
+    {
+        // Regression for the silent-wrong-rows bug: pre-fix, `where a=X and
+        // b=Y` parsed only `a=X` and dropped `and b=Y`, returning the first
+        // row matching just the left predicate. With composite-PK row
+        // (1,3,200) present, the right answer is 200, not the (1,2,100) row
+        // that matches only `a=1`.
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (a int not null, b int not null, c int)").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert into t values (1, 2, 100), (1, 3, 200), (2, 2, 300)").ExecuteNonQuery();
+
+        AreEqual(200, connection.CreateCommand("select c from t where a = 1 and b = 3").ExecuteScalar());
+        AreEqual(100, connection.CreateCommand("select c from t where a = 1 and b = 2").ExecuteScalar());
+        AreEqual(300, connection.CreateCommand("select c from t where a = 2 and b = 2").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void Where_AndChain_ThreePredicates_AllMustHold()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (a int, b int, c int)").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert into t values (1, 2, 100), (1, 2, 200)").ExecuteNonQuery();
+
+        AreEqual(100, connection.CreateCommand("select c from t where a = 1 and b = 2 and c = 100").ExecuteScalar());
+        IsNull(connection.CreateCommand("select c from t where a = 1 and b = 2 and c = 999").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void Where_AndChain_NullOperand_ExcludesRow()
+    {
+        // SQL Server WHERE: NULL on either side of AND treats the row as
+        // excluded (the whole predicate evaluates to false/UNKNOWN).
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (a int, b int)").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert into t values (1, null), (1, 2)").ExecuteNonQuery();
+
+        // Only (1, 2) passes both predicates; (1, NULL) fails the b=2 side.
+        using var reader = connection.CreateCommand("select b from t where a = 1 and b = 2").ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(2, reader[0]);
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void Where_OrInPredicate_RaisesNotSupported()
+    {
+        // OR / NOT at the boolean-combinator level aren't modeled yet; the
+        // parser surfaces the gap so the predicate doesn't silently drop.
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (a int, b int)").ExecuteNonQuery();
+        var ex = Throws<NotSupportedException>(() => connection.CreateCommand("select a from t where a = 1 or b = 2").ExecuteScalar());
+        Contains("OR", ex.Message);
+    }
+
     private static void AddTypedParameter(System.Data.Common.DbCommand command, string name, DbType dbType, object value)
     {
         var parameter = command.CreateParameter();

SqlServerSimulator/Parser/BooleanExpression.cs

@@ -12,26 +12,42 @@ namespace SqlServerSimulator.Parser;
 [DebuggerDisplay("{DebugDisplay(),nq}")]
 internal abstract class BooleanExpression
 {
-    protected readonly Expression left, right;
-
-    private protected BooleanExpression(Expression left, Expression right)
+    private protected BooleanExpression()
     {
-        this.left = left;
-        this.right = right;
     }
 
-    private protected BooleanExpression(Expression left, ParserContext context)
-        : this(left, Expression.Parse(context.MoveNextRequiredReturnSelf()))
+    /// <summary>
+    /// Parses a full boolean predicate from the current position: a single
+    /// comparison (the <see cref="CompareExpression"/> shapes), optionally
+    /// chained with one or more <c>AND</c> clauses producing an
+    /// <see cref="AndExpression"/> tree. Each chain element is itself a
+    /// comparison; nested parens around predicates and <c>OR</c>/<c>NOT</c>
+    /// at the boolean-combinator level aren't supported yet (they fall
+    /// through to the comparison parser, which surfaces them as syntax
+    /// errors). Follows the lookahead contract on <see cref="ParserContext"/>:
+    /// on return, <see cref="ParserContext.Token"/> is the first token not
+    /// consumed by the predicate.
+    /// </summary>
+    public static BooleanExpression Parse(ParserContext context)
     {
+        var result = ParseSingle(Expression.Parse(context), context);
+        while (context.Token is ReservedKeyword { Keyword: Keyword.And })
+        {
+            context.MoveNextRequired();
+            var rhs = ParseSingle(Expression.Parse(context), context);
+            result = new AndExpression(result, rhs);
+        }
+        return context.Token is ReservedKeyword { Keyword: Keyword.Or }
+            ? throw new NotSupportedException("OR in boolean expressions.")
+            : result;
     }
 
     /// <summary>
-    /// Parses a comparison operator and its right-hand expression. Follows
-    /// the lookahead contract documented on <see cref="ParserContext"/>: on
-    /// return, <see cref="ParserContext.Token"/> is the first token not
-    /// consumed by the comparison.
+    /// Parses a single comparison/predicate (no AND/OR chaining): equality,
+    /// inequality, ordered comparison, or LIKE/NOT LIKE. Caller must have
+    /// already parsed the left side.
     /// </summary>
-    public static BooleanExpression Parse(Expression left, ParserContext context) => context.Token switch
+    private static BooleanExpression ParseSingle(Expression left, ParserContext context) => context.Token switch
     {
         Operator { Character: '=' } => new EqualityExpression(left, context),
         Operator { Character: '>' } => context.GetNextRequired() switch
@@ -85,71 +101,111 @@ private static LikeExpression ParseLike(Expression left, ParserContext context,
     internal abstract string DebugDisplay();
 
     /// <summary>
-    /// Evaluates both sides, applies SQL Server type promotion to a common
-    /// type, and invokes the comparator. Cross-category type pairs surface as
-    /// <see cref="NotSupportedException"/> via <see cref="SqlType.Promote"/>.
-    /// LOB-typed operands (<c>text</c>, <c>ntext</c>, <c>image</c>) raise
-    /// Msg 402 rather than being routed through promotion — SQL Server rejects
-    /// them in any comparison/equality slot, and the operator name is woven
-    /// into the message via the caller-supplied <paramref name="operatorName"/>.
+    /// Combines two boolean predicates with a logical AND. Short-circuits on
+    /// the left side: if <c>left.Run</c> returns <c>false</c>, the right side
+    /// isn't evaluated. NULL-as-false propagates naturally — both sides must
+    /// run to true for the row to pass, matching SQL Server's WHERE-clause
+    /// "NULL excludes the row" semantics.
     /// </summary>
-    private static bool ComparePromoted(Expression left, Expression right, Func<List<string>, SqlValue> getColumnValue, string operatorName, Func<SqlValue, SqlValue, bool> compare)
+    private sealed class AndExpression(BooleanExpression left, BooleanExpression right) : BooleanExpression
     {
-        var l = left.Run(getColumnValue);
-        var r = right.Run(getColumnValue);
-        if (l.Type.IsLob || r.Type.IsLob)
-            throw SimulatedSqlException.IncompatibleDataTypesInOperator(l.Type, r.Type, operatorName);
-        if (l.IsNull || r.IsNull)
-            return false;
-
-        if (l.Type == r.Type)
-            return compare(l, r);
-
-        var common = SqlType.Promote(l.Type, r.Type);
-        return compare(l.CoerceTo(common), r.CoerceTo(common));
+        public override bool Run(Func<List<string>, SqlValue> getColumnValue) =>
+            left.Run(getColumnValue) && right.Run(getColumnValue);
+
+        internal override string DebugDisplay() => $"{left.DebugDisplay()} AND {right.DebugDisplay()}";
+    }
+
+    /// <summary>
+    /// Common base for the binary-comparison subclasses (=, &lt;&gt;, &lt;,
+    /// &gt;, &lt;=, &gt;=, LIKE). Holds the parsed left/right
+    /// <see cref="Expression"/>s and the shared promote-and-compare helper;
+    /// non-comparison <see cref="BooleanExpression"/>s (currently
+    /// <see cref="AndExpression"/> and <see cref="LikeExpression"/>) bring
+    /// their own field shapes.
+    /// </summary>
+    private abstract class CompareExpression : BooleanExpression
+    {
+        protected readonly Expression left, right;
+
+        private protected CompareExpression(Expression left, Expression right)
+        {
+            this.left = left;
+            this.right = right;
+        }
+
+        private protected CompareExpression(Expression left, ParserContext context)
+            : this(left, Expression.Parse(context.MoveNextRequiredReturnSelf()))
+        {
+        }
+
+        /// <summary>
+        /// Evaluates both sides, applies SQL Server type promotion to a common
+        /// type, and invokes the comparator. Cross-category type pairs surface
+        /// as <see cref="NotSupportedException"/> via
+        /// <see cref="SqlType.Promote"/>. LOB-typed operands (<c>text</c>,
+        /// <c>ntext</c>, <c>image</c>) raise Msg 402 rather than being routed
+        /// through promotion — SQL Server rejects them in any comparison /
+        /// equality slot, and the operator name is woven into the message via
+        /// the caller-supplied <paramref name="operatorName"/>.
+        /// </summary>
+        protected static bool ComparePromoted(Expression left, Expression right, Func<List<string>, SqlValue> getColumnValue, string operatorName, Func<SqlValue, SqlValue, bool> compare)
+        {
+            var l = left.Run(getColumnValue);
+            var r = right.Run(getColumnValue);
+            if (l.Type.IsLob || r.Type.IsLob)
+                throw SimulatedSqlException.IncompatibleDataTypesInOperator(l.Type, r.Type, operatorName);
+            if (l.IsNull || r.IsNull)
+                return false;
+
+            if (l.Type == r.Type)
+                return compare(l, r);
+
+            var common = SqlType.Promote(l.Type, r.Type);
+            return compare(l.CoerceTo(common), r.CoerceTo(common));
+        }
     }
 
-    private sealed class EqualityExpression(Expression left, ParserContext context) : BooleanExpression(left, context)
+    private sealed class EqualityExpression(Expression left, ParserContext context) : CompareExpression(left, context)
     {
         public override bool Run(Func<List<string>, SqlValue> getColumnValue) =>
             ComparePromoted(left, right, getColumnValue, "equal to", static (l, r) => l.Equals(r));
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} = {right.DebugDisplay()}";
     }
 
-    private sealed class InequalityExpression(Expression left, ParserContext context) : BooleanExpression(left, context)
+    private sealed class InequalityExpression(Expression left, ParserContext context) : CompareExpression(left, context)
     {
         public override bool Run(Func<List<string>, SqlValue> getColumnValue) =>
             ComparePromoted(left, right, getColumnValue, "not equal to", static (l, r) => !l.Equals(r));
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} <> {right.DebugDisplay()}";
     }
 
-    private sealed class GreaterThanExpression(Expression left, Expression right) : BooleanExpression(left, right)
+    private sealed class GreaterThanExpression(Expression left, Expression right) : CompareExpression(left, right)
     {
         public override bool Run(Func<List<string>, SqlValue> getColumnValue) =>
             ComparePromoted(left, right, getColumnValue, "greater than", static (l, r) => l.CompareTo(r) > 0);
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} > {right.DebugDisplay()}";
     }
 
-    private sealed class GreaterThanOrEqualExpression(Expression left, ParserContext context) : BooleanExpression(left, context)
+    private sealed class GreaterThanOrEqualExpression(Expression left, ParserContext context) : CompareExpression(left, context)
     {
         public override bool Run(Func<List<string>, SqlValue> getColumnValue) =>
             ComparePromoted(left, right, getColumnValue, "greater than or equal to", static (l, r) => l.CompareTo(r) >= 0);
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} >= {right.DebugDisplay()}";
     }
 
-    private sealed class LessThanExpression(Expression left, Expression right) : BooleanExpression(left, right)
+    private sealed class LessThanExpression(Expression left, Expression right) : CompareExpression(left, right)
     {
         public override bool Run(Func<List<string>, SqlValue> getColumnValue) =>
             ComparePromoted(left, right, getColumnValue, "less than", static (l, r) => l.CompareTo(r) < 0);
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} < {right.DebugDisplay()}";
     }
 
-    private sealed class LessThanOrEqualExpression(Expression left, ParserContext context) : BooleanExpression(left, context)
+    private sealed class LessThanOrEqualExpression(Expression left, ParserContext context) : CompareExpression(left, context)
     {
         public override bool Run(Func<List<string>, SqlValue> getColumnValue) =>
             ComparePromoted(left, right, getColumnValue, "less than or equal to", static (l, r) => l.CompareTo(r) <= 0);
@@ -167,7 +223,7 @@ public override bool Run(Func<List<string>, SqlValue> getColumnValue) =>
     /// ranges (<c>[c-a]</c>) and unterminated <c>[</c> all produce never-match
     /// translations to mirror SQL Server's silent failure.
     /// </summary>
-    private sealed class LikeExpression(Expression left, Expression right, Expression? escape, bool negated) : BooleanExpression(left, right)
+    private sealed class LikeExpression(Expression left, Expression right, Expression? escape, bool negated) : CompareExpression(left, right)
     {
         private readonly Expression? escape = escape;
         private readonly bool negated = negated;

SqlServerSimulator/Parser/Selection.cs

@@ -204,7 +204,7 @@ private static void ConsumeWhereAndOrderBy(ParserContext context, List<BooleanEx
     {
         while (context.Token is ReservedKeyword { Keyword: Keyword.Where })
         {
-            excluders.Add(BooleanExpression.Parse(Expression.Parse(context.MoveNextRequiredReturnSelf()), context));
+            excluders.Add(BooleanExpression.Parse(context.MoveNextRequiredReturnSelf()));
         }
 
         if (context.Token is ReservedKeyword { Keyword: Keyword.Order })

SqlServerSimulator/Simulation.Merge.cs

@@ -79,7 +79,7 @@ private static SimulatedStatementOutcome ParseMerge(ParserContext context)
             throw SimulatedSqlException.SyntaxErrorNear(context);
 
         context.MoveNextRequired();
-        var onPredicate = BooleanExpression.Parse(Expression.Parse(context), context);
+        var onPredicate = BooleanExpression.Parse(context);
 
         // Compute source schema by static type-of'ing the first tuple's
         // expressions. Source tuples can't reference any columns yet (they're