sqlrite 0.5.0__tar.gz → 0.5.1__tar.gz

{sqlrite-0.5.0 → sqlrite-0.5.1}/Cargo.lock

@@ -3817,7 +3817,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-ask"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "serde",
  "serde_json",
@@ -3828,7 +3828,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-desktop"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "serde",
  "serde_json",
@@ -3840,7 +3840,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-engine"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "clap",
  "env_logger",
@@ -3857,7 +3857,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-ffi"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "cbindgen",
  "serde",
@@ -3867,7 +3867,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-mcp"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "clap",
  "libc",
@@ -3878,7 +3878,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-nodejs"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "napi",
  "napi-build",
@@ -3888,7 +3888,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-python"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "pyo3",
  "sqlrite-engine",

{sqlrite-0.5.0 → sqlrite-0.5.1}/Cargo.toml

@@ -27,7 +27,7 @@ resolver = "3"
 # `package =` key so the import name stays `sqlrite` internally:
 #     sqlrite = { package = "sqlrite-engine", path = "…" }
 name = "sqlrite-engine"
-version = "0.5.0"
+version = "0.5.1"
 authors = ["Joao Henrique Machado Silva <joaoh82@gmail.com>"]
 edition = "2024"
 rust-version = "1.85"
@@ -138,4 +138,4 @@ fs2 = { version = "0.4", optional = true }
 # crate publishes to crates.io, and a path-only dep without a
 # version field fails the manifest verification step. See PR #58
 # retrospective in docs/roadmap.md.
-sqlrite-ask = { version = "0.5.0", path = "sqlrite-ask", optional = true }
+sqlrite-ask = { version = "0.5.1", path = "sqlrite-ask", optional = true }

{sqlrite-0.5.0 → sqlrite-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlrite
-Version: 0.5.0
+Version: 0.5.1
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{sqlrite-0.5.0 → sqlrite-0.5.1}/desktop/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sqlrite-desktop-frontend",
   "private": true,
-  "version": "0.5.0",
+  "version": "0.5.1",
   "type": "module",
   "scripts": {
     "dev": "vite",

{sqlrite-0.5.0 → sqlrite-0.5.1}/docs/file-format.md

@@ -139,6 +139,8 @@ body           variable        depends on kind_tag
 
 The shared prefix means `Cell::peek_rowid` works uniformly across all kinds — useful for binary search over a page's slot directory without decoding full bodies.
 
+**Decoder dispatch is per-B-tree, not per-cell.** Each B-Tree owns one cell kind on its leaves: table B-Trees carry `Local`/`Overflow` cells (decoded via `PagedEntry::decode`), secondary-index B-Trees carry `Index` cells (`IndexCell::decode`), HNSW carries `HNSW` cells (`HnswNodeCell::decode`), FTS carries `FTS Posting` cells (`FtsPostingCell::decode`), and every interior node — regardless of the leaf kind below it — carries `Interior` divider cells (`InteriorCell::decode`). Callers must dispatch on the *page's owning B-Tree*, not on the kind tag they happen to see; pointing the wrong decoder at a leaf yields an `Internal` error that names both the offending kind and the B-Tree it belongs to (SQLR-1).
+
 ### Local cell body
 
 ```

{sqlrite-0.5.0 → sqlrite-0.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlrite"
-version = "0.5.0"
+version = "0.5.1"
 description = "Python bindings for SQLRite — a small, embeddable SQLite clone written in Rust."
 authors = [{ name = "Joao Henrique Machado Silva", email = "joaoh82@gmail.com" }]
 license = { text = "MIT" }

{sqlrite-0.5.0 → sqlrite-0.5.1}/sdk/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlrite-python"
-version = "0.5.0"
+version = "0.5.1"
 authors = ["Joao Henrique Machado Silva <joaoh82@gmail.com>"]
 edition = "2024"
 rust-version = "1.85"

{sqlrite-0.5.0 → sqlrite-0.5.1}/sqlrite-ask/Cargo.toml

@@ -10,7 +10,7 @@
 # Published to crates.io as `sqlrite-ask`. Joins the lockstep release
 # wave (`sqlrite-ask-vX.Y.Z` tag) — see `docs/release-plan.md`.
 name = "sqlrite-ask"
-version = "0.5.0"
+version = "0.5.1"
 authors = ["Joao Henrique Machado Silva <joaoh82@gmail.com>"]
 edition = "2024"
 rust-version = "1.85"

{sqlrite-0.5.0 → sqlrite-0.5.1}/src/sql/pager/mod.rs

@@ -267,6 +267,43 @@ fn save_database_with_mode(db: &mut Database, path: &Path, compact: bool) -> Res
         read_old_rootpages(&pager, old_header.schema_root_page)?
     };
 
+    // SQLR-1 — snapshot every prior B-Tree's page set NOW, before any
+    // staging starts. `Pager::read_page` shadows on-disk bytes with the
+    // current `staged` buffer, so if we deferred these walks until each
+    // object's turn in the staging loop, a *new* index added in this
+    // save would extend past the old high-water and overwrite the
+    // pages of any later-staged object whose old root sits in that
+    // range — including `sqlrite_master`, which is always staged last.
+    // The follow-up walk would then read the wrong B-Tree's bytes and
+    // either hand the allocator a bogus preferred pool or panic
+    // dispatching cells (a table-cell decoder vs. an index leaf, the
+    // shape of the original SQLR-1 panic). Walking up front pins each
+    // map to the committed bytes that were on disk before this save
+    // touched anything.
+    let old_preferred_pages: HashMap<(String, String), Vec<u32>> = if compact {
+        HashMap::new()
+    } else {
+        let mut map: HashMap<(String, String), Vec<u32>> = HashMap::new();
+        for ((kind, name), &root) in &old_rootpages {
+            // Tables can carry overflow chains; index/HNSW/FTS leaves
+            // never overflow in the current encoding, so the cheaper
+            // walk suffices for them.
+            let follow = kind == "table";
+            let pages = collect_pages_for_btree(&pager, root, follow)?;
+            map.insert((kind.clone(), name.clone()), pages);
+        }
+        map
+    };
+    let old_master_pages: Vec<u32> = if compact || old_header.schema_root_page == 0 {
+        Vec::new()
+    } else {
+        collect_pages_for_btree(
+            &pager,
+            old_header.schema_root_page,
+            /*follow_overflow=*/ true,
+        )?
+    };
+
     pager.clear_staged();
 
     // Allocator: in normal mode, seed with the old freelist; in compact
@@ -292,10 +329,8 @@ fn save_database_with_mode(db: &mut Database, path: &Path, compact: bool) -> Res
             )));
         }
         if !compact {
-            if let Some(&prev_root) = old_rootpages.get(&("table".to_string(), name.to_string())) {
-                let prev =
-                    collect_pages_for_btree(&pager, prev_root, /*follow_overflow=*/ true)?;
-                alloc.set_preferred(prev);
+            if let Some(prev) = old_preferred_pages.get(&("table".to_string(), name.to_string())) {
+                alloc.set_preferred(prev.clone());
             }
         }
         let table = &db.tables[name];
@@ -322,12 +357,10 @@ fn save_database_with_mode(db: &mut Database, path: &Path, compact: bool) -> Res
         .sort_by(|(ta, ia), (tb, ib)| ta.tb_name.cmp(&tb.tb_name).then(ia.name.cmp(&ib.name)));
     for (_table, idx) in index_entries {
         if !compact {
-            if let Some(&prev_root) =
-                old_rootpages.get(&("index".to_string(), idx.name.to_string()))
+            if let Some(prev) =
+                old_preferred_pages.get(&("index".to_string(), idx.name.to_string()))
             {
-                let prev =
-                    collect_pages_for_btree(&pager, prev_root, /*follow_overflow=*/ false)?;
-                alloc.set_preferred(prev);
+                alloc.set_preferred(prev.clone());
             }
         }
         let rootpage = stage_index_btree(&mut pager, idx, &mut alloc)?;
@@ -359,12 +392,10 @@ fn save_database_with_mode(db: &mut Database, path: &Path, compact: bool) -> Res
         .sort_by(|(ta, ea), (tb, eb)| ta.tb_name.cmp(&tb.tb_name).then(ea.name.cmp(&eb.name)));
     for (table, entry) in hnsw_entries {
         if !compact {
-            if let Some(&prev_root) =
-                old_rootpages.get(&("index".to_string(), entry.name.to_string()))
+            if let Some(prev) =
+                old_preferred_pages.get(&("index".to_string(), entry.name.to_string()))
             {
-                let prev =
-                    collect_pages_for_btree(&pager, prev_root, /*follow_overflow=*/ false)?;
-                alloc.set_preferred(prev);
+                alloc.set_preferred(prev.clone());
             }
         }
         let rootpage = stage_hnsw_btree(&mut pager, &entry.index, &mut alloc)?;
@@ -401,12 +432,10 @@ fn save_database_with_mode(db: &mut Database, path: &Path, compact: bool) -> Res
     let any_fts = !fts_entries.is_empty();
     for (table, entry) in fts_entries {
         if !compact {
-            if let Some(&prev_root) =
-                old_rootpages.get(&("index".to_string(), entry.name.to_string()))
+            if let Some(prev) =
+                old_preferred_pages.get(&("index".to_string(), entry.name.to_string()))
             {
-                let prev =
-                    collect_pages_for_btree(&pager, prev_root, /*follow_overflow=*/ false)?;
-                alloc.set_preferred(prev);
+                alloc.set_preferred(prev.clone());
             }
         }
         let rootpage = stage_fts_btree(&mut pager, &entry.index, &mut alloc)?;
@@ -442,13 +471,11 @@ fn save_database_with_mode(db: &mut Database, path: &Path, compact: bool) -> Res
             ],
         )?;
     }
-    if !compact && old_header.schema_root_page != 0 {
-        let prev = collect_pages_for_btree(
-            &pager,
-            old_header.schema_root_page,
-            /*follow_overflow=*/ true,
-        )?;
-        alloc.set_preferred(prev);
+    if !compact && !old_master_pages.is_empty() {
+        // Use the page list snapshotted before any staging touched
+        // disk; re-walking here would read whatever a new index
+        // already restaged on top of master's old root (SQLR-1).
+        alloc.set_preferred(old_master_pages.clone());
     }
     let master_root = stage_table_btree(&mut pager, &master, &mut alloc)?;
     alloc.finish_preferred();
@@ -2723,6 +2750,148 @@ mod tests {
         cleanup(&path);
     }
 
+    /// SQLR-1 — `CREATE INDEX` on a wide table must round-trip when the
+    /// index B-tree grows past one leaf and needs an interior level.
+    /// Before the fix, the post-DDL auto-save panicked with
+    /// `Internal("unknown paged-entry kind tag 0x4 …")` because a
+    /// table-cell decoder was being run against an index leaf
+    /// (`KIND_INDEX = 0x04`).
+    ///
+    /// 5 000 rows mirror the original repro from the issue and exceed
+    /// every leaf-fanout cliff for the small `(rowid, value)` cells in
+    /// a TEXT-keyed secondary index.
+    #[test]
+    fn secondary_index_with_interior_level_round_trips() {
+        let path = tmp_path("sqlr1_wide_index");
+        let mut db = Database::new("idx".to_string());
+        db.source_path = Some(path.clone());
+
+        process_command(
+            "CREATE TABLE bloat (id INTEGER PRIMARY KEY, payload TEXT);",
+            &mut db,
+        )
+        .unwrap();
+        // BEGIN/COMMIT collapses 5 000 inserts into one save (matches
+        // `auto_vacuum_setup` and the issue's repro shape).
+        process_command("BEGIN;", &mut db).unwrap();
+        for i in 0..5000 {
+            process_command(
+                &format!("INSERT INTO bloat (payload) VALUES ('p-{i:08}');"),
+                &mut db,
+            )
+            .unwrap();
+        }
+        process_command("COMMIT;", &mut db).unwrap();
+
+        // The DDL that used to panic.
+        process_command("CREATE INDEX idx_p ON bloat (payload);", &mut db).unwrap();
+
+        // Reopen and verify lookups, plus that the index tree actually
+        // grew an interior layer (otherwise this test wouldn't cover the
+        // regression).
+        drop(db);
+        let loaded = open_database(&path, "idx".to_string()).unwrap();
+        let bloat = loaded.get_table("bloat".to_string()).unwrap();
+        let idx = bloat
+            .index_by_name("idx_p")
+            .expect("idx_p should survive close/reopen");
+        assert!(!idx.is_unique);
+
+        // Spot-check the keyspace: first, middle, last value each map
+        // back to exactly the row that carried them.
+        for &(probe_i, expected_rowid) in &[(0i64, 1i64), (2500, 2501), (4999, 5000)] {
+            let value = Value::Text(format!("p-{probe_i:08}"));
+            let hits = idx.lookup(&value);
+            assert_eq!(
+                hits,
+                vec![expected_rowid],
+                "lookup({value:?}) should yield rowid {expected_rowid}",
+            );
+        }
+
+        // Confirm the index tree is multi-level (the regression's
+        // necessary condition) — root must be an `InteriorNode` and
+        // `find_leftmost_leaf` must reach a `TableLeaf` through it.
+        let pager = loaded.pager.as_ref().unwrap();
+        let mut master = build_empty_master_table();
+        load_table_rows(pager, &mut master, pager.header().schema_root_page).unwrap();
+        let idx_root = master
+            .rowids()
+            .into_iter()
+            .find_map(
+                |r| match (master.get_value("name", r), master.get_value("type", r)) {
+                    (Some(Value::Text(name)), Some(Value::Text(kind)))
+                        if name == "idx_p" && kind == "index" =>
+                    {
+                        match master.get_value("rootpage", r) {
+                            Some(Value::Integer(p)) => Some(p as u32),
+                            _ => None,
+                        }
+                    }
+                    _ => None,
+                },
+            )
+            .expect("idx_p should appear in sqlrite_master");
+        let root_buf = pager.read_page(idx_root).unwrap();
+        assert_eq!(
+            root_buf[0],
+            PageType::InteriorNode as u8,
+            "5 000-entry index must have an interior root — without one this test wouldn't cover SQLR-1",
+        );
+        let leaf = find_leftmost_leaf(pager, idx_root).unwrap();
+        let leaf_buf = pager.read_page(leaf).unwrap();
+        assert_eq!(leaf_buf[0], PageType::TableLeaf as u8);
+
+        cleanup(&path);
+    }
+
+    /// SQLR-1 follow-on — the page-recycling path between two large
+    /// versions of the same index name must not corrupt cell decoding.
+    /// `DROP INDEX` returns its pages to the freelist; the next
+    /// `CREATE INDEX` is free to reuse them. If the allocator hands an
+    /// old index leaf to a *table* without zeroing it, an upstream
+    /// table walk would see KIND_INDEX cells and panic.
+    #[test]
+    fn drop_then_recreate_wide_index_does_not_panic() {
+        let path = tmp_path("sqlr1_drop_recreate");
+        let mut db = Database::new("idx".to_string());
+        db.source_path = Some(path.clone());
+
+        process_command(
+            "CREATE TABLE bloat (id INTEGER PRIMARY KEY, payload TEXT);",
+            &mut db,
+        )
+        .unwrap();
+        process_command("BEGIN;", &mut db).unwrap();
+        for i in 0..5000 {
+            process_command(
+                &format!("INSERT INTO bloat (payload) VALUES ('p-{i:08}');"),
+                &mut db,
+            )
+            .unwrap();
+        }
+        process_command("COMMIT;", &mut db).unwrap();
+
+        process_command("CREATE INDEX idx_p ON bloat (payload);", &mut db).unwrap();
+        process_command("DROP INDEX idx_p;", &mut db).unwrap();
+        // Recreate from scratch — exercises the recycle path.
+        process_command("CREATE INDEX idx_p ON bloat (payload);", &mut db).unwrap();
+
+        drop(db);
+        let loaded = open_database(&path, "idx".to_string()).unwrap();
+        let bloat = loaded.get_table("bloat".to_string()).unwrap();
+        let idx = bloat
+            .index_by_name("idx_p")
+            .expect("idx_p should survive drop+recreate+reopen");
+        assert_eq!(
+            idx.lookup(&Value::Text("p-00002500".into())),
+            vec![2501],
+            "post-recycle lookup must still resolve correctly",
+        );
+
+        cleanup(&path);
+    }
+
     #[test]
     fn deep_tree_round_trips() {
         // Force a 3-level tree by bypassing process_command (which prints

{sqlrite-0.5.0 → sqlrite-0.5.1}/src/sql/pager/overflow.rs

@@ -139,8 +139,17 @@ impl PagedEntry {
     }
 
     /// Dispatches on the kind tag and returns the appropriate variant.
+    ///
+    /// Only `KIND_LOCAL` and `KIND_OVERFLOW` are valid here — `PagedEntry`
+    /// is the table-leaf-cell type, so any other kind means a caller
+    /// pointed the wrong decoder at this page (the slot directory layout
+    /// is shared across leaf B-Trees, but secondary-index, HNSW, and
+    /// FTS leaves carry kind-specific cells decoded by `IndexCell::decode`,
+    /// `HnswNodeCell::decode`, and `FtsPostingCell::decode` respectively).
+    /// The named-kind error makes that mistake obvious next time.
     pub fn decode(buf: &[u8], pos: usize) -> Result<(PagedEntry, usize)> {
-        match Cell::peek_kind(buf, pos)? {
+        let kind = Cell::peek_kind(buf, pos)?;
+        match kind {
             KIND_LOCAL => {
                 let (c, n) = Cell::decode(buf, pos)?;
                 Ok((PagedEntry::Local(c), n))
@@ -150,12 +159,41 @@ impl PagedEntry {
                 Ok((PagedEntry::Overflow(r), n))
             }
             other => Err(SQLRiteError::Internal(format!(
-                "unknown paged-entry kind tag {other:#x} at offset {pos}"
+                "PagedEntry::decode at offset {pos} got kind tag {other:#x} ({}); \
+                 expected KIND_LOCAL (0x01) or KIND_OVERFLOW (0x02). \
+                 The caller is reading a {} page with the table-leaf decoder.",
+                kind_name(other),
+                kind_btree_hint(other),
             ))),
         }
     }
 }
 
+/// Human-readable label for a cell kind tag — used in error messages
+/// to make wrong-decoder mistakes self-explanatory.
+fn kind_name(tag: u8) -> &'static str {
+    match tag {
+        crate::sql::pager::cell::KIND_LOCAL => "KIND_LOCAL",
+        crate::sql::pager::cell::KIND_OVERFLOW => "KIND_OVERFLOW",
+        crate::sql::pager::cell::KIND_INTERIOR => "KIND_INTERIOR",
+        crate::sql::pager::cell::KIND_INDEX => "KIND_INDEX",
+        crate::sql::pager::cell::KIND_HNSW => "KIND_HNSW",
+        crate::sql::pager::cell::KIND_FTS_POSTING => "KIND_FTS_POSTING",
+        _ => "unknown kind",
+    }
+}
+
+/// Hint pointing at which B-Tree owns a cell of the given kind.
+fn kind_btree_hint(tag: u8) -> &'static str {
+    match tag {
+        crate::sql::pager::cell::KIND_INTERIOR => "B-Tree interior",
+        crate::sql::pager::cell::KIND_INDEX => "secondary-index",
+        crate::sql::pager::cell::KIND_HNSW => "HNSW",
+        crate::sql::pager::cell::KIND_FTS_POSTING => "FTS",
+        _ => "non-table",
+    }
+}
+
 /// Writes `bytes` into a chain of Overflow-typed pages, drawing each
 /// page number from the supplied [`PageAllocator`]. Returns the page
 /// number of the first link in the chain (the value to record in the
@@ -284,6 +322,50 @@ mod tests {
         assert_eq!(decoded, PagedEntry::Overflow(overflow));
     }
 
+    /// SQLR-1 — `PagedEntry::decode` is the table-leaf-cell decoder.
+    /// Pointing it at a secondary-index leaf used to surface as a
+    /// cryptic `unknown paged-entry kind tag 0x4`. The new error
+    /// message names the offending kind and the B-Tree the caller
+    /// is mistakenly walking.
+    #[test]
+    fn paged_entry_decode_rejects_index_kind_with_clear_error() {
+        use crate::sql::pager::index_cell::IndexCell;
+        let ic = IndexCell::new(42, Value::Text("alice".into()));
+        let bytes = ic.encode().unwrap();
+        let err = PagedEntry::decode(&bytes, 0).unwrap_err();
+        let msg = format!("{err}");
+        assert!(
+            msg.contains("KIND_INDEX"),
+            "expected error to name KIND_INDEX, got: {msg}",
+        );
+        assert!(
+            msg.contains("secondary-index"),
+            "expected error to identify the secondary-index B-Tree, got: {msg}",
+        );
+    }
+
+    /// Symmetric coverage for HNSW and FTS — same wrong-decoder shape,
+    /// same diagnostic guarantee.
+    #[test]
+    fn paged_entry_decode_rejects_hnsw_and_fts_kinds() {
+        use crate::sql::pager::cell::{KIND_FTS_POSTING, KIND_HNSW};
+        // Build minimal byte sequences carrying the right kind tag at
+        // the right offset. Body content past the kind tag doesn't
+        // matter — we expect the dispatch to short-circuit on the tag.
+        for (tag, hint) in [(KIND_HNSW, "HNSW"), (KIND_FTS_POSTING, "FTS")] {
+            // body_len declared as 1 (the kind tag itself); body is the
+            // tag and nothing else. Honest about what's in the buffer
+            // so a future tightening of `peek_kind` doesn't bite us.
+            let bytes = vec![/*body_len varint=*/ 1u8, tag];
+            let err = PagedEntry::decode(&bytes, 0).unwrap_err();
+            let msg = format!("{err}");
+            assert!(
+                msg.contains(hint),
+                "expected error to identify the {hint} B-Tree, got: {msg}",
+            );
+        }
+    }
+
     #[test]
     fn peek_rowid_works_for_both_kinds() {
         let local = Cell::new(99, vec![Some(Value::Integer(1))]);