feat(vdbe): seek an INNER/LEFT rowid-join with a compound ON clause (B5b-2c)

The live inner-cursor seek (B5b-2a/2b) no longer requires the ipk equality to
be the entire `ON`. The `ON` is split into its top-level `AND` conjuncts and the
first conjunct that binds the inner table's INTEGER PRIMARY KEY to a plain outer
column drives the rowid seek (in either operand order); the full `ON` is still
re-evaluated against the assembled row after the seek, so any additional
conjunct (`… AND t.name = o.y`) simply filters the seeked row. This rides the
same superset invariant as the single-equality case and introduces no new
comparison semantics — the seek key still coerces through `to_i64` exactly as
the tree-walker's rowid seek does.

Deliberately does not extend to a secondary-index seek: `index_seek_rowids`
compares raw keys with the index collation and skips the comparison-affinity
that `o.x = t.k` applies, so routing it could silently drop a matching row
(a false negative that would not fall back) — that needs the tree-walker's
affinity machinery first and is left for a later step.

Verified VDBE-vs-tree-walker and vs sqlite3 3.50.4 (`tests/vdbe_live_cursor.rs`).

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

Author: MagicalTux

ROADMAP.md

@@ -1195,10 +1195,19 @@ gated on VDBE-vs-tree-walker parity, so it can't regress correctness):
     order/content to the existing null-padding nested loop, but without scanning or
     materializing the inner table. Same narrow routing as 2a plus `JoinKind::Left`.
     Verified vs the tree-walker and sqlite3 3.50.4.
+  - **B5b-2c — compound `ON` seek. DONE.** The ipk equality no longer has to be the
+    *whole* `ON` — it may be one top-level `AND` conjunct (`… ON o.x = t.id AND
+    t.name = o.y`, in either order). That conjunct drives the rowid seek; the full
+    `ON` is re-evaluated after the seek (superset invariant), so the extra conjunct
+    just filters the seeked row. Affinity-neutral (same `to_i64` rowid coercion).
+    Verified vs the tree-walker and sqlite3 3.50.4.
   - **Remaining:** in-*interpreter* `OpenRead`/`SeekRowid` opcodes over B5b-1's
-    multi-cursor foundation (so the seek lives in bytecode, not row-assembly);
-    seek by a **secondary index** / `WITHOUT ROWID` PK; the bare-`rowid`-alias `ON`
-    spelling (blocked on a pre-existing divergence — `t.rowid` in a join projection
+    multi-cursor foundation (so the seek lives in bytecode, not row-assembly); seek
+    by a **secondary index** / `WITHOUT ROWID` PK (*affinity-blocked*: `index_seek_rowids`
+    compares raw keys with the index collation and skips the comparison-affinity that
+    `o.x = t.k` applies, so routing it risks a silent false-negative that would not
+    fall back — needs the tree-walker's affinity machinery first); the bare-`rowid`-alias
+    `ON` spelling (blocked on a pre-existing divergence — `t.rowid` in a join projection
     already errors on the tree-walker); N-table chains.
 - **B1c — RIGHT/FULL join inner seeks.** INNER/LEFT already seek; RIGHT/FULL still
   materialize the inner table.

src/exec/mod.rs

@@ -2070,21 +2070,15 @@ impl Connection {
                     .map(|_| inner_qual.clone())
                     .collect();
                 let ipk_name = inner_meta.columns[ipk].name.clone();
-                // The `ON` must be a single `Eq` (parens stripped) binding the
-                // inner ipk column on one side and a plain outer column on the
-                // other.
+                // The `ON` must contain (as one top-level `AND` conjunct, parens
+                // stripped) an `Eq` binding the inner ipk column on one side and a
+                // plain outer column on the other. Any additional conjuncts ride
+                // the superset invariant: the whole `ON` is re-evaluated after the
+                // seek, so an extra `AND t.name = o.y` just filters the seeked row.
                 let mut on_expr = on;
                 while let sql::ast::Expr::Paren(inner) = on_expr {
                     on_expr = inner;
                 }
-                let (l, r) = match on_expr {
-                    sql::ast::Expr::Binary {
-                        op: sql::ast::BinaryOp::Eq,
-                        left,
-                        right,
-                    } => (left.as_ref(), right.as_ref()),
-                    _ => break 'seek,
-                };
                 // A plain (optionally parenthesized) unqualified-schema column ref.
                 fn col_ref(mut e: &sql::ast::Expr) -> Option<(Option<&str>, &str)> {
                     while let sql::ast::Expr::Paren(i) = e {
@@ -2146,18 +2140,53 @@ impl Connection {
                     }
                     Some(matches[0])
                 };
-                let oc = if is_inner_ipk(l) {
-                    match outer_col_index(r) {
-                        Some(oc) => oc,
-                        None => break 'seek,
+                // Collect the top-level `AND` conjuncts of the `ON` (parens
+                // stripped), then find the first that is an `Eq` binding the inner
+                // ipk to an outer column — that conjunct drives the rowid seek.
+                fn and_conjuncts<'a>(e: &'a sql::ast::Expr, out: &mut Vec<&'a sql::ast::Expr>) {
+                    let mut e = e;
+                    while let sql::ast::Expr::Paren(i) = e {
+                        e = i;
                     }
-                } else if is_inner_ipk(r) {
-                    match outer_col_index(l) {
-                        Some(oc) => oc,
-                        None => break 'seek,
+                    if let sql::ast::Expr::Binary {
+                        op: sql::ast::BinaryOp::And,
+                        left,
+                        right,
+                    } = e
+                    {
+                        and_conjuncts(left, out);
+                        and_conjuncts(right, out);
+                    } else {
+                        out.push(e);
                     }
-                } else {
-                    break 'seek;
+                }
+                let mut conjuncts: Vec<&sql::ast::Expr> = Vec::new();
+                and_conjuncts(on_expr, &mut conjuncts);
+                let seek_key = conjuncts.iter().find_map(|c| {
+                    let mut c = *c;
+                    while let sql::ast::Expr::Paren(i) = c {
+                        c = i;
+                    }
+                    let sql::ast::Expr::Binary {
+                        op: sql::ast::BinaryOp::Eq,
+                        left,
+                        right,
+                    } = c
+                    else {
+                        return None;
+                    };
+                    let (l, r) = (left.as_ref(), right.as_ref());
+                    if is_inner_ipk(l) {
+                        outer_col_index(r)
+                    } else if is_inner_ipk(r) {
+                        outer_col_index(l)
+                    } else {
+                        None
+                    }
+                });
+                let oc = match seek_key {
+                    Some(oc) => oc,
+                    None => break 'seek,
                 };
                 // Combined schema (outer cols ++ inner cols), leftmost outermost.
                 let mut c_cols = o_cols.clone();

tests/vdbe_live_cursor.rs

@@ -23,7 +23,8 @@ fn sqlite3_available() -> bool {
 
 const SCHEMA: &str = "CREATE TABLE o(x, y TEXT);\
      INSERT INTO o VALUES(1,'a'),(2,'b'),(3,'c'),(NULL,'n'),(2,'b2'),(2.0,'real'),\
-       ('2','txt'),('2abc','junk'),(x'32','blob'),(2.5,'half'),(99,'miss'),(-1,'neg');\
+       ('2','txt'),('2abc','junk'),(x'32','blob'),(2.5,'half'),(99,'miss'),(-1,'neg'),\
+       (2,'two'),(5,'five');\
      CREATE TABLE t(id INTEGER PRIMARY KEY, name TEXT);\
      INSERT INTO t VALUES(1,'one'),(2,'two'),(5,'five');";
 
@@ -49,6 +50,14 @@ const VDBE_QUERIES: &[&str] = &[
     "SELECT o.y FROM o LEFT JOIN t ON o.x = t.id WHERE t.name IS NULL ORDER BY o.y",
     "SELECT count(*), count(t.id) FROM o LEFT JOIN t ON o.x = t.id",
     "SELECT o.x, t.name FROM o LEFT JOIN t ON o.x = t.id ORDER BY o.y LIMIT 3 OFFSET 2",
+    // Compound `ON` (B5b-2c): the ipk equality is one `AND` conjunct — it drives
+    // the rowid seek, the whole `ON` is re-checked so the extra conjunct just
+    // filters the seeked row. The ipk-eq may be either conjunct.
+    "SELECT o.x, t.name FROM o JOIN t ON o.x = t.id AND t.name = o.y ORDER BY o.y",
+    "SELECT o.x, t.name FROM o JOIN t ON t.name = o.y AND o.x = t.id ORDER BY o.y",
+    "SELECT o.x, t.name FROM o JOIN t ON o.x = t.id AND t.name <> 'one' ORDER BY o.y",
+    "SELECT o.x, t.name FROM o LEFT JOIN t ON o.x = t.id AND t.name = o.y ORDER BY o.y",
+    "SELECT count(*) FROM o JOIN t ON o.x = t.id AND o.y = t.name",
 ];
 
 fn setup() -> Connection {