fix(planner): apply the COLLATE-mismatch seek check to range bounds too

A range bound whose explicit COLLATE differs from the column's collation
(`b > 'x' COLLATE NOCASE` over a BINARY index) now scans like SQLite instead of
seeking the index, and a BETWEEN keeps only the bound whose collation matches
(`b BETWEEN 'a' COLLATE NOCASE AND 'z'` → seek `b < 'z'` only). Mirrors the
equality fix, in the shared collect_range_constraints, so the executor seek and
the EQP label stay in lockstep. (`IN (…) COLLATE` is left as-is — SQLite still
seeks there.)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: MagicalTux

ROADMAP.md

@@ -482,8 +482,10 @@ byte-exact vs the pinned `sqlite3` 3.50.4 oracle. Capability summary:
   graphite SCANs as SQLite does; this also fixed a row-**ordering** bug, since the
   mis-applied seek had wrongly credited its `(b, rowid)` walk for a sole `ORDER BY` on
   the rowid (a NOCASE match spans several binary keys, so the rows are not in rowid
-  order). The check lives in the shared `collect_eq_constraints`, so the seek, the
-  EQP label, and the ORDER-BY credit stay in lockstep.
+  order). The check lives in the shared `collect_eq_constraints` /
+  `collect_range_constraints` (a range bound and a `BETWEEN` bound get it per-bound,
+  so `b BETWEEN 'a' COLLATE NOCASE AND 'z'` keeps only the matching `b<'z'` bound, as
+  SQLite does), so the seek, the EQP label, and the ORDER-BY credit stay in lockstep.
   The `NOT INDEXED` planner hint is now honored in the *plan* (the executor already
   honored it, so rows were always correct): SQLite forbids every *secondary* index on
   that table, so a `WHERE` seek, covering scan, ORDER-BY index walk, and MULTI-INDEX OR

src/exec/mod.rs

@@ -30363,12 +30363,23 @@ fn collect_range_constraints(
                 BinaryOp::Lt | BinaryOp::LtEq | BinaryOp::Gt | BinaryOp::GtEq
             ) =>
         {
+            // A bound whose value carries an explicit `COLLATE` differing from the
+            // column's collation cannot seek that column's index (its keys order for a
+            // different collation), so SQLite ignores it for the seek — same rule as
+            // the equality collector.
+            let coll_ok = |ci: usize, val: &Expr| {
+                explicit_collation(val).is_none_or(|c| c == columns[ci].collation)
+            };
             if let (Some(ci), Some(v)) = (col_index(left, columns), const_value(right, params)) {
-                apply_bound(out.entry(ci).or_default(), *op, v);
+                if coll_ok(ci, right) {
+                    apply_bound(out.entry(ci).or_default(), *op, v);
+                }
             } else if let (Some(ci), Some(v)) =
                 (col_index(right, columns), const_value(left, params))
             {
-                apply_bound(out.entry(ci).or_default(), flip_cmp(*op), v);
+                if coll_ok(ci, left) {
+                    apply_bound(out.entry(ci).or_default(), flip_cmp(*op), v);
+                }
             }
         }
         Expr::Between {
@@ -30378,11 +30389,13 @@ fn collect_range_constraints(
             negated: false,
         } => {
             if let Some(ci) = col_index(expr, columns) {
+                let coll_ok =
+                    |val: &Expr| explicit_collation(val).is_none_or(|c| c == columns[ci].collation);
                 let b = out.entry(ci).or_default();
-                if let Some(v) = const_value(low, params) {
+                if let (Some(v), true) = (const_value(low, params), coll_ok(low)) {
                     apply_bound(b, BinaryOp::GtEq, v);
                 }
-                if let Some(v) = const_value(high, params) {
+                if let (Some(v), true) = (const_value(high, params), coll_ok(high)) {
                     apply_bound(b, BinaryOp::LtEq, v);
                 }
             }

tests/seek_collation_mismatch.rs

@@ -58,10 +58,16 @@ fn collation_mismatch_scans_matching_seeks() {
     }
     let g = env!("CARGO_BIN_EXE_graphitesql");
     // BINARY column / index: an explicit NOCASE differs → SCAN; BINARY (or absent) → SEARCH.
+    // Equality and range alike; a BETWEEN keeps only the bound whose collation matches.
     for q in [
         "SELECT * FROM t WHERE b='x' COLLATE NOCASE",
         "SELECT * FROM t WHERE b='x' COLLATE BINARY",
         "SELECT * FROM t WHERE b='x'",
+        "SELECT * FROM t WHERE b>'x' COLLATE NOCASE",
+        "SELECT * FROM t WHERE b>'x' COLLATE BINARY",
+        "SELECT * FROM t WHERE b>'x'",
+        "SELECT * FROM t WHERE b BETWEEN 'a' COLLATE NOCASE AND 'z'",
+        "SELECT * FROM t WHERE b BETWEEN 'a' AND 'z'",
     ] {
         assert_eq!(
             plan("sqlite3", BINARY_COL, q),
@@ -102,6 +108,14 @@ fn collation_mismatch_orders_rows_correctly() {
             "SELECT a,b FROM t WHERE b='x' COLLATE BINARY ORDER BY a",
         ),
         (BINARY_COL, "SELECT a,b FROM t WHERE b='x' ORDER BY a"),
+        (
+            BINARY_COL,
+            "SELECT a FROM t WHERE b>'x' COLLATE NOCASE ORDER BY a",
+        ),
+        (
+            BINARY_COL,
+            "SELECT a FROM t WHERE b BETWEEN 'a' COLLATE NOCASE AND 'z' ORDER BY a",
+        ),
         (
             NOCASE_COL,
             "SELECT a,b FROM t WHERE b='x' COLLATE BINARY ORDER BY a",