BETWEEN / NOT BETWEEN predicate: new BetweenExpression : BooleanExpression desugars to value >= lower AND value <= upper with the result negated for the NOT form, value evaluated once per row regardless of the surface desugar. Hooks into BooleanExpression.ParseComparison's keyword switch (Between case + NOT Between under the existing NOT case); ParseBetween reads lower via Expression.Parse, consumes the required AND keyword (Msg 102 if missing), reads upper — Expression.Parse naturally stops at the trailing AND because AND is a higher-precedence boolean combinator, so a chained predicate falls back to the surrounding ParseAnd loop. Probe-confirmed semantics: inclusive on both ends (1 between 1 and 10 and 10 between 1 and 10 both true), reversed bounds (low > high) collapse to definite false, NULL in any operand position propagates per three-valued AND/NOT (even definitely-out-of-range with a NULL bound stays false because UNKNOWN AND FALSE = FALSE). 27 new BetweenTests via DataRow cover at/inside/outside bounds, NOT BETWEEN, reversed bounds, every NULL operand position, string / decimal / date type promotion, BETWEEN-vs-AND and BETWEEN-vs-OR precedence, arithmetic in bounds, multi-row WHERE with NULL filtering, CHECK constraint usage, and missing-AND syntax error. Pre-existing gap surfaced by the probe — Msg 4145 fall-through was the previous behavior because BETWEEN had no dispatch site outside of WindowExpression's frame-spec parser. docs/claude/query.md Boolean section extended with the desugar / precedence / once-per-row note.

RyanLamansky · RyanLamansky · commit 31f20c6896f9 · 2026-05-13T10:44:03.000-05:00
diff --git a/SqlServerSimulator.Tests/BetweenTests.cs b/SqlServerSimulator.Tests/BetweenTests.cs
@@ -0,0 +1,157 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for <c>value [NOT] BETWEEN lower AND upper</c>. Semantically
+/// equivalent to <c>value &gt;= lower AND value &lt;= upper</c> (inclusive
+/// on both ends); reversed bounds produce a definite false; any NULL operand
+/// propagates per three-valued logic. Probed against SQL Server 2025
+/// (2026-05-13).
+/// </summary>
+[TestClass]
+public sealed class BetweenTests
+{
+    [TestMethod]
+    [DataRow("5 between 1 and 10", 1)]
+    [DataRow("1 between 1 and 10", 1)]
+    [DataRow("10 between 1 and 10", 1)]
+    [DataRow("0 between 1 and 10", 0)]
+    [DataRow("11 between 1 and 10", 0)]
+    [DataRow("5 not between 1 and 10", 0)]
+    [DataRow("11 not between 1 and 10", 1)]
+    [DataRow("5 between 10 and 1", 0)]
+    [DataRow("5 not between 10 and 1", 1)]
+    public void Basic(string predicate, int expectedCount) =>
+        AreEqual(expectedCount,
+            new Simulation().ExecuteReader($"select 1 where {predicate}").EnumerateRecords().Count());
+
+    [TestMethod]
+    [DataRow("cast(null as int) between 1 and 10")]
+    [DataRow("cast(null as int) not between 1 and 10")]
+    [DataRow("5 between cast(null as int) and 10")]
+    [DataRow("5 between 1 and cast(null as int)")]
+    [DataRow("5 between cast(null as int) and cast(null as int)")]
+    [DataRow("5 not between cast(null as int) and 10")]
+    [DataRow("5 not between 1 and cast(null as int)")]
+    public void NullOperand_ExcludesFromWhere(string predicate) =>
+        AreEqual(0,
+            new Simulation().ExecuteReader($"select 1 where {predicate}").EnumerateRecords().Count());
+
+    [TestMethod]
+    public void DefinitelyOutOfRange_WithNullBound_StillFalse()
+    {
+        // Probe-confirmed: even though the NULL-side comparison is UNKNOWN,
+        // three-valued AND with the definite-false side collapses to FALSE,
+        // so the row is excluded.
+        AreEqual(0,
+            new Simulation().ExecuteReader("select 1 where 100 between cast(null as int) and 10").EnumerateRecords().Count());
+        AreEqual(0,
+            new Simulation().ExecuteReader("select 1 where -5 between 1 and cast(null as int)").EnumerateRecords().Count());
+    }
+
+    [TestMethod]
+    public void StringBetween()
+    {
+        // 'mango' falls between 'apple' and 'pear' in ANSI string order.
+        AreEqual(1,
+            new Simulation().ExecuteReader("select 1 where 'mango' between 'apple' and 'pear'").EnumerateRecords().Count());
+        AreEqual(0,
+            new Simulation().ExecuteReader("select 1 where 'mango' not between 'apple' and 'pear'").EnumerateRecords().Count());
+    }
+
+    [TestMethod]
+    public void DecimalBetween_IntBounds_TypePromotion()
+    {
+        AreEqual(1,
+            new Simulation().ExecuteReader("select 1 where cast(2.5 as decimal(5,2)) between 1 and 5").EnumerateRecords().Count());
+    }
+
+    [TestMethod]
+    public void DateBetween_StringBounds_CoercionWorks()
+    {
+        AreEqual(1,
+            new Simulation().ExecuteReader(
+                "select 1 where cast('2026-05-15' as date) between '2026-01-01' and '2026-12-31'").EnumerateRecords().Count());
+    }
+
+    [TestMethod]
+    public void Precedence_BetweenBindsTighterThanAnd()
+    {
+        // `5 between 1 and 10 and 1 = 1` parses as
+        // `(5 between 1 and 10) AND (1 = 1)` — both true → row passes.
+        AreEqual(1,
+            new Simulation().ExecuteReader("select 1 where 5 between 1 and 10 and 1 = 1").EnumerateRecords().Count());
+    }
+
+    [TestMethod]
+    public void Precedence_BetweenInsideOr()
+    {
+        AreEqual(1,
+            new Simulation().ExecuteReader("select 1 where 1 = 0 or 5 between 1 and 10").EnumerateRecords().Count());
+    }
+
+    [TestMethod]
+    public void ArithmeticInBounds()
+    {
+        // Bounds accept arithmetic expressions — Expression.Parse stops at
+        // the AND keyword (boolean combinator) without consuming it.
+        AreEqual(1,
+            new Simulation().ExecuteReader("select 1 where 5 between 1 - 1 and 10 + 1").EnumerateRecords().Count());
+    }
+
+    [TestMethod]
+    public void MultiRowWhereBetween_FiltersNulls()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        _ = conn.CreateCommand("""
+            create table bv (id int, v int);
+            insert bv values (1, 5), (2, 10), (3, 15), (4, null)
+            """).ExecuteNonQuery();
+        using var reader = conn.CreateCommand("select id from bv where v between 5 and 12 order by id").ExecuteReader();
+        var ids = new List<int>();
+        while (reader.Read())
+            ids.Add(reader.GetInt32(0));
+        CollectionAssert.AreEqual(new int[] { 1, 2 }, ids);
+    }
+
+    [TestMethod]
+    public void MultiRowWhereNotBetween_ExcludesNulls()
+    {
+        // Probe-confirmed: id=4 (v=NULL) excluded by three-valued NOT (UNKNOWN
+        // → UNKNOWN → excluded), id=3 (v=15) is the only out-of-range row.
+        using var conn = new Simulation().CreateOpenConnection();
+        _ = conn.CreateCommand("""
+            create table bv (id int, v int);
+            insert bv values (1, 5), (2, 10), (3, 15), (4, null)
+            """).ExecuteNonQuery();
+        using var reader = conn.CreateCommand("select id from bv where v not between 5 and 12 order by id").ExecuteReader();
+        var ids = new List<int>();
+        while (reader.Read())
+            ids.Add(reader.GetInt32(0));
+        CollectionAssert.AreEqual(new int[] { 3 }, ids);
+    }
+
+    [TestMethod]
+    public void CheckConstraint_BetweenRejectsOutOfRange()
+    {
+        // CHECK constraint passes UNKNOWN — a definitively-false BETWEEN
+        // raises Msg 547. Inline single-column CHECK referencing only the
+        // owning column.
+        using var conn = new Simulation().CreateOpenConnection();
+        _ = conn.CreateCommand("create table bt (v int check (v between 1 and 10))").ExecuteNonQuery();
+        _ = conn.CreateCommand("insert bt values (5)").ExecuteNonQuery();
+        using var cmd = conn.CreateCommand("insert bt values (11)");
+        var ex = Throws<DbException>(() => cmd.ExecuteNonQuery());
+        AreEqual("547", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void MissingAndKeyword_SyntaxError()
+    {
+        // `value BETWEEN lower upper` (no AND) → syntax error near upper.
+        var ex = Throws<DbException>(() => new Simulation().ExecuteScalar("select 1 where 5 between 1 10"));
+        AreEqual("102", ex.Data["HelpLink.EvtID"]);
+    }
+}
diff --git a/SqlServerSimulator/Parser/BooleanExpression.cs b/SqlServerSimulator/Parser/BooleanExpression.cs
@@ -137,11 +137,14 @@ private static BooleanExpression ParseComparison(Expression left, ParserContext
                 return ParseIsNullSuffix(left, context);
             case ReservedKeyword { Keyword: Keyword.In }:
                 return ParseInList(left, context, negated: false);
+            case ReservedKeyword { Keyword: Keyword.Between }:
+                return ParseBetween(left, context, negated: false);
             case ReservedKeyword { Keyword: Keyword.Not }:
                 return context.GetNextRequired() switch
                 {
                     ReservedKeyword { Keyword: Keyword.Like } => ParseLike(left, context, negated: true),
                     ReservedKeyword { Keyword: Keyword.In } => ParseInList(left, context, negated: true),
+                    ReservedKeyword { Keyword: Keyword.Between } => ParseBetween(left, context, negated: true),
                     _ => throw SimulatedSqlException.SyntaxErrorNear(context),
                 };
         }
@@ -341,6 +344,28 @@ private static BooleanExpression ParseInList(Expression left, ParserContext cont
         return new InExpression(left, [.. candidates], negated);
     }
 
+    /// <summary>
+    /// Parses the <c>[NOT] BETWEEN lower AND upper</c> suffix after an
+    /// expression. Entered with <see cref="ParserContext.Token"/> on the
+    /// <c>BETWEEN</c> keyword; consumes <c>BETWEEN</c>, the lower expression,
+    /// the required <c>AND</c>, and the upper expression. Both bounds are
+    /// plain value expressions (not boolean predicates) — <see cref="Expression.Parse"/>
+    /// naturally stops at the trailing <c>AND</c> keyword because <c>AND</c>
+    /// is a boolean combinator at higher precedence, so a trailing <c>AND
+    /// other-predicate</c> falls back to the surrounding
+    /// <see cref="ParseAnd"/> loop.
+    /// </summary>
+    private static BetweenExpression ParseBetween(Expression left, ParserContext context, bool negated)
+    {
+        context.MoveNextRequired();
+        var lower = Expression.Parse(context);
+        if (context.Token is not ReservedKeyword { Keyword: Keyword.And })
+            throw SimulatedSqlException.SyntaxErrorNear(context);
+        context.MoveNextRequired();
+        var upper = Expression.Parse(context);
+        return new BetweenExpression(left, lower, upper, negated);
+    }
+
     /// <summary>
     /// Evaluates the predicate to SQL Server's three-valued logic:
     /// <c>true</c>, <c>false</c>, or <c>null</c> (UNKNOWN). NULL operands in a
@@ -513,6 +538,44 @@ private sealed class ExistsExpression(Selection inner) : BooleanExpression
         internal override void VisitOperandExpressions(Action<Expression> visitor) { }
     }
 
+    /// <summary>
+    /// <c>value [NOT] BETWEEN lower AND upper</c>: equivalent to
+    /// <c>value &gt;= lower AND value &lt;= upper</c> (with the result negated
+    /// for the NOT form). Both bounds inclusive (probe-confirmed against
+    /// SQL Server 2025 — <c>5 between 1 and 5</c> is true at both endpoints).
+    /// Reversed bounds (low &gt; high) produce a definite false; NULL in any
+    /// operand position propagates per the standard three-valued AND/NOT
+    /// truth tables. <c>value</c> is evaluated once per row even though the
+    /// desugaring would suggest two evaluations.
+    /// </summary>
+    private sealed class BetweenExpression(Expression value, Expression lower, Expression upper, bool negated) : BooleanExpression
+    {
+        public override bool? Run(RuntimeContext runtime)
+        {
+            var v = value.Run(runtime);
+            var lo = lower.Run(runtime);
+            var hi = upper.Run(runtime);
+            var ge = CompareValuesPromoted(v, lo, "greater than or equal to", static (l, r) => l.CompareTo(r) >= 0);
+            var le = CompareValuesPromoted(v, hi, "less than or equal to", static (l, r) => l.CompareTo(r) <= 0);
+            var inRange = ge == false || le == false ? false
+                : ge == true && le == true ? true
+                : (bool?)null;
+            return negated
+                ? inRange switch { true => false, false => true, _ => null }
+                : inRange;
+        }
+
+        internal override string DebugDisplay() =>
+            $"{value.DebugDisplay()} {(negated ? "NOT BETWEEN" : "BETWEEN")} {lower.DebugDisplay()} AND {upper.DebugDisplay()}";
+
+        internal override void VisitOperandExpressions(Action<Expression> visitor)
+        {
+            visitor(value);
+            visitor(lower);
+            visitor(upper);
+        }
+    }
+
     /// <summary>
     /// <c>expr [NOT] IN (SELECT ...)</c>: equivalent to a chain of
     /// promote-and-equal comparisons against each row of the single-column
diff --git a/docs/claude/query.md b/docs/claude/query.md
@@ -1,7 +1,8 @@
 # Query semantics — set ops, CASE, pagination, aggregates, windows
 
 ## Boolean / set ops / projection / CASE
-- Boolean combinators (WHERE / MERGE-ON / CHECK): `AND` / `OR` / `NOT`, parens, `IS [NOT] NULL`, `[NOT] IN (literal,...)`, `[NOT] IN (SELECT ...)`, `EXISTS (SELECT ...)`, `expr <op> {ANY|SOME|ALL} (SELECT col FROM ...)` quantified comparison. Tri-valued.
+- Boolean combinators (WHERE / MERGE-ON / CHECK): `AND` / `OR` / `NOT`, parens, `IS [NOT] NULL`, `[NOT] IN (literal,...)`, `[NOT] IN (SELECT ...)`, `EXISTS (SELECT ...)`, `expr <op> {ANY|SOME|ALL} (SELECT col FROM ...)` quantified comparison, `value [NOT] BETWEEN lower AND upper`. Tri-valued.
+- `[NOT] BETWEEN` desugars to `value >= lower AND value <= upper` (inclusive on both ends, probe-confirmed). Reversed bounds (low > high) collapse to a definite false; NULL in any operand position propagates through three-valued AND. `value` is evaluated once per row by `BetweenExpression.Run` (the desugaring is per-row semantics, not duplicated evaluation). BETWEEN binds tighter than the surrounding AND/OR, so `value between a and b and other` parses as `(value between a and b) AND (other)`; bounds may be arbitrary value expressions (Expression.Parse stops at the trailing AND keyword).
 - Quantified comparison (`Parser/BooleanExpression.cs` — `QuantifiedComparisonExpression`): all six operators (`=`, `<>`, `<`, `<=`, `>`, `>=`) plus T-SQL synonyms (`!=` → `<>`, `!<` → `>=`, `!>` → `<=`) fold at parse time into a `ComparisonOp` enum. `SOME` is a pure alias of `ANY`. Inner SELECT must project exactly one column (Msg 116, shared factory with IN-subquery). **Predicate-only**: probe-confirmed (2026-05-13) that real SQL Server raises Msg 102 when the form appears in a SELECT-list expression slot — the simulator inherits the same restriction because parsing lives in `BooleanExpression.ParseComparison`, reachable only from the boolean-atom path. Empty inner: `ALL` is vacuously true, `ANY` vacuously false (LHS NULL irrelevant — the inner is consumed first). Non-empty inner runs three-valued fold: any comparison evaluating to `true` short-circuits `ANY` to `true`; any `false` short-circuits `ALL` to `false`; otherwise `null`-tainted comparisons turn the overall result UNKNOWN, fall-through is `false` for `ANY` / `true` for `ALL`. `<op> ANY` cannot be negated directly (`NOT <op> ANY` isn't grammar — apps must flip the operator: `NOT (x > ALL y)` ≡ `x <= ANY y`).
 - Set ops (UNION / UNION ALL / INTERSECT / EXCEPT): standard precedence (INTERSECT > UNION/EXCEPT). **NULLs are equal during set-op dedup/matching** (opposite of `=`'s tri-state). Per-branch ORDER BY in non-final branch → Msg 156. Top-level ORDER BY references first-branch column names only.
 - `SELECT *`: bare and qualified `<source>.*`. Multi-source `*` keeps duplicate names. Unbound `<qualifier>.*` → Msg 4104.
