feat(planner): seek a parenthesized column like the bare column

`(a) = 2`, `(b) > 10`, `(a) IN (1,2)`, and `(b) IS NULL` now seek their index
exactly as the unparenthesized forms do, instead of falling back to a full scan.
SQLite ignores the redundant parentheses; graphite failed to see the column
through the `Paren` wrapper.

The fix unwraps `Expr::Paren` in the shared `col_index`, so every seek path
(equality, range, IN, IS NULL) and the `eqp_access` label pick it up together —
EXPLAIN QUERY PLAN and the executor stay in lockstep, and rows are unchanged.

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

Author: MagicalTux

ROADMAP.md

@@ -473,6 +473,10 @@ byte-exact vs the pinned `sqlite3` 3.50.4 oracle. Capability summary:
   SCANned. The fix is one arm in the shared `collect_eq_constraints` (a NULL operand
   is excluded, staying the `col IS NULL` NULL-key seek), so the executor seek and the
   `eqp_access` label move in lockstep; `col IS NOT <const>` (a `!=`) stays a scan.
+  A *parenthesized* column — `(a) = 2`, `(b) > 10`, `(a) IN (1,2)`, `(b) IS NULL` —
+  now seeks exactly as the bare column does (SQLite ignores the redundant parens);
+  the fix unwraps `Expr::Paren` in the shared `col_index`, so every seek path and
+  `eqp_access` pick it up together.
   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

@@ -30380,6 +30380,12 @@ fn collect_range_constraints(
 
 /// The column index a bare/qualified column expression resolves to, if any.
 fn col_index(e: &Expr, columns: &[ColumnInfo]) -> Option<usize> {
+    // A parenthesized column (`(a) = 2`) is the same column for seek purposes, so
+    // unwrap any `Paren` wrappers first — SQLite seeks it exactly as the bare form.
+    let mut e = e;
+    while let Expr::Paren(inner) = e {
+        e = inner;
+    }
     if let Expr::Column { table, column, .. } = e {
         columns.iter().position(|c| {
             c.name.eq_ignore_ascii_case(column)

tests/seek_parenthesized_column.rs

@@ -0,0 +1,84 @@
+//! A parenthesized column in a `WHERE` constraint — `(a) = 2`, `(b) > 10`,
+//! `(a) IN (1,2)`, `(b) IS NULL` — seeks its index exactly as the bare column does.
+//! SQLite ignores the redundant parentheses; graphite previously failed to recognize
+//! the column through the `Paren` wrapper and fell back to a full scan, so
+//! `EXPLAIN QUERY PLAN` diverged (`SCAN` vs `SEARCH`). The fix lives in the shared
+//! `col_index`, so the executor seek and the EQP label move in lockstep. 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 SCHEMA: &str = "CREATE TABLE t(a INTEGER PRIMARY KEY, b, c); CREATE INDEX tb ON t(b);";
+
+#[test]
+fn parenthesized_column_seeks_like_bare() {
+    if !sqlite3_available() {
+        eprintln!("sqlite3 CLI not found; skipping");
+        return;
+    }
+    let g = env!("CARGO_BIN_EXE_graphitesql");
+    for q in [
+        "SELECT * FROM t WHERE (a)=2",   // INTEGER PRIMARY KEY
+        "SELECT * FROM t WHERE ((a))=2", // nested parens
+        "SELECT * FROM t WHERE 2=(a)",   // flipped operands
+        "SELECT * FROM t WHERE (b)=10",  // secondary index equality
+        "SELECT * FROM t WHERE (b)>10",  // secondary index range
+        "SELECT * FROM t WHERE (a) IN (1,2)",
+        "SELECT * FROM t WHERE (b) IS NULL",
+    ] {
+        assert_eq!(
+            plan("sqlite3", SCHEMA, q),
+            plan(g, SCHEMA, q),
+            "plan for {q}"
+        );
+    }
+}
+
+#[test]
+fn parenthesized_column_rows_match() {
+    if !sqlite3_available() {
+        eprintln!("sqlite3 CLI not found; skipping");
+        return;
+    }
+    let g = env!("CARGO_BIN_EXE_graphitesql");
+    let base = format!("{SCHEMA} INSERT INTO t VALUES(1,10,5),(2,20,5),(3,NULL,9),(4,40,1);");
+    for q in [
+        "SELECT a FROM t WHERE (a)=2",
+        "SELECT a FROM t WHERE (b)>10 ORDER BY a",
+        "SELECT a FROM t WHERE (a) IN (1,3) ORDER BY a",
+        "SELECT a FROM t WHERE (b) IS NULL",
+    ] {
+        assert_eq!(rows("sqlite3", &base, q), rows(g, &base, q), "rows for {q}");
+    }
+}