feat(planner): seek a trailing rowid range via a rowid/oid alias too (B9g)

Completes B9g: `WHERE b=? AND rowid>?` (and `_rowid_`/`oid`, and `rowid BETWEEN
… AND …`) now bounds the `(b, rowid)` index range exactly as the INTEGER PRIMARY
KEY column spelling does. A new `rowid_alias_range` collector walks the WHERE for
a rowid-alias range (the column-name range collector resolves the IPK by its
declared name, so the bare alias needed a separate pass); both the executor seek
and eqp_access fall back to it when no IPK-column range is present.

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

Author: MagicalTux

ROADMAP.md

@@ -1199,15 +1199,13 @@ tie/representative order), so they are perf/EQP-fidelity work, not correctness:
   (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.
-- **B9g — eq-prefix + trailing rowid range on a secondary index.** *Done* for the
-  INTEGER-PRIMARY-KEY-column spelling: `WHERE b=? AND a>?` (a the IPK) now seeks and
-  renders `SEARCH … USING INDEX ib (b=? AND rowid>?)`, bounding the `(b, rowid)` index
-  range directly — the rowid is the index's implicit trailing key. Extended the
-  existing eq-prefix + next-column range seek (executor `try_index_lookup` +
-  `eqp_access`, in lockstep). *Residual:* the bare `rowid`-alias spelling
-  (`… AND rowid>?`) still renders `(b=?)` because `collect_range_constraints` resolves
-  by column name and the IPK column is `a` (rows stay correct via the WHERE re-apply);
-  needs rowid-alias range collection.
+- **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
+  `(b, rowid)` index range directly — the rowid is the index's implicit trailing key.
+  Extended the existing eq-prefix + next-column range seek (executor `try_index_lookup`
+  + `eqp_access`, in lockstep) with a `next_pos == idx_cols.len()` rowid-tail block,
+  and added a `rowid_alias_range` collector for the alias spelling.
 - **B9h — cost-model single-table index *choice*.** SQLite prefers, among indexes
   that share an equality prefix, the one whose walk does the most work: a composite
   `(b,c)` over `(b)` when a trailing range (`b=? AND c>?`) or a `GROUP BY`/`ORDER BY c`

src/exec/mod.rs

@@ -11562,52 +11562,53 @@ impl Connection {
         // component of every secondary index entry, so `x=? AND rowid>?` bounds the
         // `(x, rowid)` range `[eq…, lo] .. [eq…, hi]` (SQLite renders it the same way).
         // Superset-safe — `run_core` re-applies the full `WHERE`.
-        if next_pos == idx_cols.len() {
-            if let Some(ipk) = meta.ipk {
-                let mut ranges: alloc::collections::BTreeMap<usize, RangeBound> =
-                    alloc::collections::BTreeMap::new();
-                collect_range_constraints(where_expr, &meta.columns, params, &mut ranges);
-                if let Some(b) = ranges.get(&ipk) {
-                    let mut colls = full_colls[..next_pos].to_vec();
-                    colls.push(crate::value::Collation::default());
-                    let mut lo_key = key.clone();
-                    let lo_inc = match b.lower.as_ref() {
-                        Some((v, inc)) => {
-                            lo_key.push(v.clone());
-                            *inc
-                        }
-                        None => true,
-                    };
-                    let mut hi_key = key.clone();
-                    let hi_inc = match b.upper.as_ref() {
-                        Some((v, inc)) => {
-                            hi_key.push(v.clone());
-                            *inc
-                        }
-                        None => true,
-                    };
-                    let rowids = crate::btree::index_range_rowids(
-                        self.backend.source(),
-                        root,
-                        Some((lo_key.as_slice(), lo_inc)),
-                        Some((hi_key.as_slice(), hi_inc)),
-                        &colls,
-                    )?;
-                    let encoding = self.backend.source().header().text_encoding;
-                    let mut cur = TableCursor::new(self.backend.source(), meta.root);
-                    let mut out = Vec::new();
-                    for rid in rowids {
-                        if cur.seek(rid)? {
-                            let values =
-                                self.decode_full_row(meta, rid, &cur.payload()?, encoding)?;
-                            out.push(InputRow {
-                                values,
-                                rowid: Some(rid),
-                            });
-                        }
+        if next_pos == idx_cols.len() && meta.ipk.is_some() {
+            let mut ranges: alloc::collections::BTreeMap<usize, RangeBound> =
+                alloc::collections::BTreeMap::new();
+            collect_range_constraints(where_expr, &meta.columns, params, &mut ranges);
+            let rowid_bound = meta
+                .ipk
+                .and_then(|ipk| ranges.remove(&ipk))
+                .or_else(|| rowid_alias_range(where_expr, meta, params));
+            if let Some(b) = rowid_bound {
+                let mut colls = full_colls[..next_pos].to_vec();
+                colls.push(crate::value::Collation::default());
+                let mut lo_key = key.clone();
+                let lo_inc = match b.lower.as_ref() {
+                    Some((v, inc)) => {
+                        lo_key.push(v.clone());
+                        *inc
+                    }
+                    None => true,
+                };
+                let mut hi_key = key.clone();
+                let hi_inc = match b.upper.as_ref() {
+                    Some((v, inc)) => {
+                        hi_key.push(v.clone());
+                        *inc
+                    }
+                    None => true,
+                };
+                let rowids = crate::btree::index_range_rowids(
+                    self.backend.source(),
+                    root,
+                    Some((lo_key.as_slice(), lo_inc)),
+                    Some((hi_key.as_slice(), hi_inc)),
+                    &colls,
+                )?;
+                let encoding = self.backend.source().header().text_encoding;
+                let mut cur = TableCursor::new(self.backend.source(), meta.root);
+                let mut out = Vec::new();
+                for rid in rowids {
+                    if cur.seek(rid)? {
+                        let values = self.decode_full_row(meta, rid, &cur.payload()?, encoding)?;
+                        out.push(InputRow {
+                            values,
+                            rowid: Some(rid),
+                        });
                     }
-                    return Ok(Some(out));
                 }
+                return Ok(Some(out));
             }
         }
 
@@ -14815,18 +14816,20 @@ impl Connection {
                             conds.push(alloc::format!("{name}<?"));
                         }
                     }
-                } else if matched.len() == idx_cols.len() {
-                    if let Some(ipk) = meta.ipk {
-                        let mut ranges: alloc::collections::BTreeMap<usize, RangeBound> =
-                            alloc::collections::BTreeMap::new();
-                        collect_range_constraints(where_expr, &meta.columns, params, &mut ranges);
-                        if let Some(b) = ranges.get(&ipk) {
-                            if b.lower.is_some() {
-                                conds.push(String::from("rowid>?"));
-                            }
-                            if b.upper.is_some() {
-                                conds.push(String::from("rowid<?"));
-                            }
+                } else if matched.len() == idx_cols.len() && meta.ipk.is_some() {
+                    let mut ranges: alloc::collections::BTreeMap<usize, RangeBound> =
+                        alloc::collections::BTreeMap::new();
+                    collect_range_constraints(where_expr, &meta.columns, params, &mut ranges);
+                    let rowid_bound = meta
+                        .ipk
+                        .and_then(|ipk| ranges.remove(&ipk))
+                        .or_else(|| rowid_alias_range(where_expr, meta, params));
+                    if let Some(b) = rowid_bound {
+                        if b.lower.is_some() {
+                            conds.push(String::from("rowid>?"));
+                        }
+                        if b.upper.is_some() {
+                            conds.push(String::from("rowid<?"));
                         }
                     }
                 }
@@ -30407,6 +30410,70 @@ fn flip_cmp(op: BinaryOp) -> BinaryOp {
     }
 }
 
+/// 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.
+/// Returns the folded `RangeBound`, or `None` when no such bound is present. The
+/// alias must not be shadowed by a real column of that name.
+fn rowid_alias_range(e: &Expr, meta: &TableMeta, params: &Params) -> Option<RangeBound> {
+    fn is_rowid(x: &Expr, meta: &TableMeta) -> bool {
+        matches!(x, Expr::Column { column, .. }
+            if is_rowid_alias(column)
+                && !meta.columns.iter().any(|c| c.name.eq_ignore_ascii_case(column)))
+    }
+    fn walk(e: &Expr, meta: &TableMeta, params: &Params, out: &mut RangeBound, found: &mut bool) {
+        match e {
+            Expr::Binary {
+                op: BinaryOp::And,
+                left,
+                right,
+            } => {
+                walk(left, meta, params, out, found);
+                walk(right, meta, params, out, found);
+            }
+            Expr::Paren(inner) => walk(inner, meta, params, out, found),
+            Expr::Binary { op, left, right }
+                if matches!(
+                    op,
+                    BinaryOp::Lt | BinaryOp::LtEq | BinaryOp::Gt | BinaryOp::GtEq
+                ) =>
+            {
+                if is_rowid(left, meta) {
+                    if let Some(v) = const_value(right, params) {
+                        apply_bound(out, *op, v);
+                        *found = true;
+                    }
+                } else if is_rowid(right, meta) {
+                    if let Some(v) = const_value(left, params) {
+                        apply_bound(out, flip_cmp(*op), v);
+                        *found = true;
+                    }
+                }
+            }
+            Expr::Between {
+                expr,
+                low,
+                high,
+                negated: false,
+            } if is_rowid(expr, meta) => {
+                if let Some(v) = const_value(low, params) {
+                    apply_bound(out, BinaryOp::GtEq, v);
+                    *found = true;
+                }
+                if let Some(v) = const_value(high, params) {
+                    apply_bound(out, BinaryOp::LtEq, v);
+                    *found = true;
+                }
+            }
+            _ => {}
+        }
+    }
+    let mut b = RangeBound::default();
+    let mut found = false;
+    walk(e, meta, params, &mut b, &mut found);
+    found.then_some(b)
+}
+
 /// Collect per-column range bounds (`<`/`<=`/`>`/`>=`/`BETWEEN`) from the
 /// top-level `AND` conjuncts of `WHERE`, keyed by column index. Drives an index
 /// range scan; non-range and non-constant terms are ignored (the full `WHERE` is

tests/seek_trailing_rowid_range.rs

@@ -3,9 +3,8 @@
 //! `SEARCH t USING INDEX ib (b=? AND rowid>?)`, because every secondary-index entry
 //! is keyed `(cols…, rowid)`. graphite used to render (and seek) only `(b=?)` and
 //! re-filter the rowid bound; it now bounds the `(b, rowid)` range directly, matching
-//! SQLite. The rowid range is expressed via the INTEGER PRIMARY KEY column (`a`); the
-//! bare `rowid`-alias spelling still renders `(b=?)` in EQP (rows stay correct via the
-//! WHERE re-apply) — a small follow-up. Verified vs the sqlite3 3.50.4 CLI.
+//! SQLite. The rowid range is expressed via the INTEGER PRIMARY KEY column (`a`) or a
+//! bare `rowid`/`_rowid_`/`oid` alias. Verified vs the sqlite3 3.50.4 CLI.
 
 #![cfg(feature = "std")]
 
@@ -56,6 +55,9 @@ fn trailing_rowid_range_plan_matches_sqlite() {
         "SELECT * FROM t WHERE b=1 AND a>0 AND a<9",
         "SELECT * FROM t WHERE b=1 AND a<9",
         "SELECT * FROM t WHERE b=1 AND a>=3",
+        "SELECT * FROM t WHERE b=1 AND rowid>5", // rowid alias
+        "SELECT * FROM t WHERE b=1 AND oid<9",   // oid alias
+        "SELECT * FROM t WHERE b=1 AND rowid BETWEEN 2 AND 8",
         "SELECT a FROM t WHERE b=1 AND a>0", // covering
         // No rowid range → plain prefix seek, unchanged.
         "SELECT * FROM t WHERE b=1",