feat(planner): seek a fixed-prefix GLOB range on a BINARY index (B9f)

`col GLOB 'abc*'` now seeks the `[abc, abd)` byte range on a BINARY index and
renders `SEARCH t USING INDEX tb (b>? AND b<?)` instead of scanning. SQLite's
GLOB is always case-sensitive and byte-based, so the index must be BINARY — the
seek is gated on the column's collation, matching sqlite (which scans a NOCASE
index). Implemented as a `BinaryOp::Glob` arm in the shared
collect_range_constraints, so the executor range seek and the eqp_access label
move in lockstep; the new glob_prefix_range helper extracts the literal prefix
(up to the first `*`/`?`/`[`) and forms the exclusive upper bound by incrementing
the last byte (dropping trailing 0xFF; a non-UTF-8 increment yields a
lower-bound-only seek). The full GLOB is re-applied, so results are exact.

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

Author: MagicalTux

ROADMAP.md

@@ -1200,10 +1200,15 @@ tie/representative order), so they are perf/EQP-fidelity work, not correctness:
   computed value in SQLite (`SEARCH … (b=?)`); graphite `SCAN`s because the eq-
   collector requires a constant RHS. Needs the executor to evaluate the
   non-correlated subquery once, then seek (superset-safe; `eqp_access` mirrors it).
-- **B9f — `GLOB 'prefix*'` prefix-range seek.** SQLite rewrites a fixed-prefix `GLOB`
-  (always case-sensitive) into `col >= 'prefix' AND col < 'prefix⁺'` and seeks a
-  BINARY index; graphite scans. Must gate on the index's collation being BINARY (else
-  the EQP diverges on a NOCASE index) and handle the multi-byte prefix increment.
+- **B9f — `GLOB 'prefix*'` prefix-range seek. ✅ Done.** A fixed-prefix `GLOB`
+  (always case-sensitive / byte-based) now seeks `col >= 'prefix' AND col < 'prefix⁺'`
+  on a BINARY index and reads `SEARCH … (b>? AND b<?)`. Implemented as a `BinaryOp::Glob`
+  arm in the shared `collect_range_constraints` (so the executor range seek and
+  `eqp_access` move in lockstep), gated on the column's collation being BINARY; the
+  `glob_prefix_range` helper extracts the literal prefix (up to the first `*`/`?`/`[`)
+  and increments the last byte `< 0xFF` (dropping trailing `0xFF`; a non-UTF-8
+  increment drops the upper bound → still a valid superset). A leading wildcard scans;
+  the full GLOB is re-applied so results are exact.
 - **B9g — eq-prefix + trailing rowid range on a secondary index. ✅ Done.**
   `WHERE b=? AND a>?` (a the IPK) *and* the bare `rowid`/`_rowid_`/`oid` alias spelling
   now seek and render `SEARCH … USING INDEX ib (b=? AND rowid>?)`, bounding the

src/exec/mod.rs

@@ -30465,6 +30465,42 @@ fn flip_cmp(op: BinaryOp) -> BinaryOp {
     }
 }
 
+/// The `[lo, hi)` byte-range a fixed-prefix `GLOB` pattern seeks: `'abc*'` matches
+/// exactly the strings `>= 'abc'` and `< 'abd'`. The literal prefix is the run before
+/// the first GLOB metacharacter (`*`, `?`, `[`); an empty prefix (a leading wildcard)
+/// is unseekable → `None`. The upper bound increments the last byte `< 0xFF` and drops
+/// trailing `0xFF` bytes (so it dominates every string starting with the prefix); if
+/// every byte is `0xFF`, or the increment is not valid UTF-8, there is no upper bound
+/// (`hi = None`) and the seek runs from `lo` to the end — still a valid superset.
+fn glob_prefix_range(pat: &str) -> Option<(String, Option<String>)> {
+    let prefix: String = pat
+        .chars()
+        .take_while(|&c| c != '*' && c != '?' && c != '[')
+        .collect();
+    if prefix.is_empty() {
+        return None;
+    }
+    let mut hi = prefix.clone().into_bytes();
+    loop {
+        match hi.last().copied() {
+            Some(0xFF) => {
+                hi.pop();
+            }
+            Some(b) => {
+                *hi.last_mut().unwrap() = b + 1;
+                break;
+            }
+            None => break,
+        }
+    }
+    let hi = if hi.is_empty() {
+        None
+    } else {
+        String::from_utf8(hi).ok()
+    };
+    Some((prefix, hi))
+}
+
 /// A range on the table's rowid expressed through a `rowid`/`_rowid_`/`oid` alias
 /// (`… AND rowid>?`) — the column-name range collector resolves the INTEGER PRIMARY
 /// KEY by its declared name, so the bare-alias spelling needs this separate walk.
@@ -30592,6 +30628,29 @@ fn collect_range_constraints(
                 }
             }
         }
+        // `col GLOB 'prefix*'` (SQLite's GLOB is always case-sensitive / byte-based)
+        // seeks the `[prefix, prefix⁺)` range on a BINARY index — the index orders keys
+        // by byte, matching GLOB. A NOCASE/RTRIM column can't serve it, so gate on the
+        // column's collation being BINARY. Superset-safe: `run_core` re-applies GLOB.
+        Expr::Binary {
+            op: BinaryOp::Glob,
+            left,
+            right,
+        } => {
+            if let (Some(ci), Some(Value::Text(pat))) =
+                (col_index(left, columns), const_value(right, params))
+            {
+                if columns[ci].collation == crate::value::Collation::Binary {
+                    if let Some((lo, hi)) = glob_prefix_range(&pat) {
+                        let b = out.entry(ci).or_default();
+                        apply_bound(b, BinaryOp::GtEq, Value::Text(lo));
+                        if let Some(hi) = hi {
+                            apply_bound(b, BinaryOp::Lt, Value::Text(hi));
+                        }
+                    }
+                }
+            }
+        }
         _ => {}
     }
 }

tests/seek_glob_prefix.rs

@@ -0,0 +1,94 @@
+//! B9f — a fixed-prefix `GLOB` pattern seeks a byte range on a BINARY index. SQLite's
+//! `GLOB` is always case-sensitive and byte-based, so `b GLOB 'abc*'` matches exactly
+//! `b >= 'abc' AND b < 'abd'` and reads `SEARCH t USING INDEX tb (b>? AND b<?)`; a
+//! leading wildcard (`'*abc'`, `'[ab]c'`) has no seekable prefix and scans. The seek
+//! only applies to a BINARY-collation column (a NOCASE index orders keys differently),
+//! and the full `GLOB` is re-applied so results are exact. graphite used to scan every
+//! `GLOB`. Verified vs the sqlite3 3.50.4 CLI.
+
+#![cfg(feature = "std")]
+
+use std::process::Command;
+
+fn sqlite3_available() -> bool {
+    Command::new("sqlite3").arg("--version").output().is_ok()
+}
+
+fn plan(bin: &str, base: &str, sql: &str) -> String {
+    let full = format!("{base} EXPLAIN QUERY PLAN {sql}");
+    let out = Command::new(bin)
+        .arg(":memory:")
+        .arg(&full)
+        .output()
+        .unwrap();
+    String::from_utf8_lossy(&out.stdout)
+        .lines()
+        .filter(|l| !l.trim().is_empty() && !l.starts_with("QUERY PLAN"))
+        .map(|l| l.trim_start_matches(|c: char| " |`*+_-".contains(c)))
+        .collect::<Vec<_>>()
+        .join("#")
+}
+
+fn rows(bin: &str, base: &str, sql: &str) -> String {
+    let full = format!("{base} {sql}");
+    let out = Command::new(bin)
+        .arg(":memory:")
+        .arg(&full)
+        .output()
+        .unwrap();
+    String::from_utf8_lossy(&out.stdout).trim_end().to_string()
+}
+
+const BINARY_COL: &str =
+    "CREATE TABLE t(a INTEGER PRIMARY KEY, b TEXT, c); CREATE INDEX tb ON t(b);";
+const NOCASE_COL: &str =
+    "CREATE TABLE t(a INTEGER PRIMARY KEY, b TEXT COLLATE NOCASE, c); CREATE INDEX tb ON t(b);";
+
+#[test]
+fn glob_prefix_plan_matches_sqlite() {
+    if !sqlite3_available() {
+        eprintln!("sqlite3 CLI not found; skipping");
+        return;
+    }
+    let g = env!("CARGO_BIN_EXE_graphitesql");
+    for q in [
+        "SELECT * FROM t WHERE b GLOB 'abc*'", // prefix + wildcard → range seek
+        "SELECT * FROM t WHERE b GLOB 'abc'",  // no wildcard → still a prefix range
+        "SELECT * FROM t WHERE b GLOB 'a?c*'", // '?' stops the prefix at 'a'
+        "SELECT * FROM t WHERE b GLOB '*abc'", // leading wildcard → no prefix → SCAN
+        "SELECT * FROM t WHERE b GLOB '[ab]c'", // char class → no prefix → SCAN
+    ] {
+        assert_eq!(
+            plan("sqlite3", BINARY_COL, q),
+            plan(g, BINARY_COL, q),
+            "plan for {q}"
+        );
+    }
+    // A NOCASE-collation column can't serve the byte-ordered GLOB range → SCAN.
+    assert_eq!(
+        plan("sqlite3", NOCASE_COL, "SELECT * FROM t WHERE b GLOB 'abc*'"),
+        plan(g, NOCASE_COL, "SELECT * FROM t WHERE b GLOB 'abc*'"),
+    );
+}
+
+#[test]
+fn glob_prefix_rows_match() {
+    if !sqlite3_available() {
+        eprintln!("sqlite3 CLI not found; skipping");
+        return;
+    }
+    let g = env!("CARGO_BIN_EXE_graphitesql");
+    let base = format!(
+        "{BINARY_COL} INSERT INTO t VALUES\
+         (1,'abc',1),(2,'abd',2),(3,'abcd',3),(4,'ABC',4),(5,'abz',5),(6,'xabc',6),(7,'ab',7);"
+    );
+    for q in [
+        "SELECT b FROM t WHERE b GLOB 'abc*' ORDER BY b", // case-sensitive: excludes ABC
+        "SELECT b FROM t WHERE b GLOB 'ab*' ORDER BY b",
+        "SELECT b FROM t WHERE b GLOB 'abc' ORDER BY b",
+        "SELECT count(*) FROM t WHERE b GLOB 'a*'",
+        "SELECT b FROM t WHERE b GLOB 'zzz*' ORDER BY b", // empty range
+    ] {
+        assert_eq!(rows("sqlite3", &base, q), rows(g, &base, q), "rows for {q}");
+    }
+}