sqlitegraph 0.5.0__tar.gz → 0.5.2__tar.gz

{sqlitegraph-0.5.0 → sqlitegraph-0.5.2}/Cargo.lock

@@ -163,9 +163,9 @@ dependencies = [
 
 [[package]]
 name = "bitflags"
-version = "2.12.1"
+version = "2.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84d7ced0ae9557296835c32bf1b1e02b44c746701f898460fb000d7eaa84f00a"
+checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"
 
 [[package]]
 name = "block-buffer"
@@ -1387,7 +1387,7 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "sqlitegraph"
-version = "3.1.0"
+version = "3.2.3"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -1419,7 +1419,7 @@ dependencies = [
 
 [[package]]
 name = "sqlitegraph-cli"
-version = "3.1.0"
+version = "3.2.0"
 dependencies = [
  "anyhow",
  "clap",
@@ -1429,7 +1429,7 @@ dependencies = [
 
 [[package]]
 name = "sqlitegraph-py"
-version = "0.5.0"
+version = "0.5.2"
 dependencies = [
  "ndarray 0.16.1",
  "numpy",

{sqlitegraph-0.5.0 → sqlitegraph-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlitegraph
-Version: 0.5.0
+Version: 0.5.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3

{sqlitegraph-0.5.0 → sqlitegraph-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlitegraph"
-version = "0.5.0"
+version = "0.5.2"
 description = "Embedded graph database with HNSW vector search — Python bindings to the sqlitegraph Rust crate."
 license = { text = "GPL-3.0-only" }
 authors = [{ name = "Luiz Spies" }]

{sqlitegraph-0.5.0 → sqlitegraph-0.5.2}/sqlitegraph-core/CHANGELOG.md

@@ -1,5 +1,74 @@
 # SQLiteGraph Changelog
 
+## [3.2.3] - 2026-06-07
+
+### Changed
+
+- **Benchmarking guidance corrected and consolidated** — Added
+  `docs/BENCHMARKING.md`, updated README benchmark instructions to use release
+  mode for the quick comparison example, and removed stale claims that no
+  longer matched current clean runs.
+- **`sqlite_v3_curated` benchmark added** — A small-case Criterion suite for
+  high-signal SQLite vs V3 comparisons that completes in practical time on a
+  developer workstation.
+- **`examples/test_performance_comparison.rs` now describes itself correctly** —
+  The example is documented as a warm-cache microbenchmark and no longer ends
+  with hardcoded backend recommendations that could contradict measured output.
+
+- **HNSW index lock upgraded from `std::sync::Mutex` to `parking_lot::Mutex`** —
+  Removed poison handling at 10 call sites in `index_api.rs`. `parking_lot::Mutex`
+  provides smaller lock size and eliminates poison handling overhead. (SG-1)
+
+- **All remaining `std::sync::Mutex` replaced with `parking_lot::Mutex`** —
+  `progress.rs` (2 sites), `statement_tracker.rs` (1 site), `publisher.rs`
+  (5 sites). All `.expect("... poisoned")` patterns eliminated. (SG-2)
+
+- **HNSW runtime operation counters added with atomics** — `HnswIndexStats`
+  now reports lock-free `insert_count`, `search_count`, `vector_cache_hits`,
+  and `vector_cache_misses`, all backed by `AtomicU64`. Rebuild/autoload paths
+  reset these counters after internal recovery so they reflect runtime traffic
+  instead of startup repair work. `Publisher::next_id` also now uses
+  `AtomicU64` instead of `Arc<Mutex<u64>>`. (SG-2/SG-3)
+
+- **`std::sync::RwLock` replaced with `parking_lot::RwLock` in `query_cache.rs`** —
+  11 poison handling blocks removed. (SG-2)
+
+### Added
+
+- **Streaming graph traversal iterators** — `bfs_iter`, `dfs_iter`,
+  `topological_sort_iter`, `connected_components_iter` in
+  `algo::backend::iterator`. Implement `GraphIterator` trait (BFS/DFS/topo)
+  and `Iterator<Item=Result<Vec<i64>>>` (connected components) for lazy,
+  composable traversal. O(frontier) memory for node iterators,
+  O(|V_component|) for connected components. (SG-4)
+
+## [3.1.4] - 2026-06-06
+
+### Fixed
+- Set `busy_timeout(5000ms)` on `conn_for_storage` in `hnsw_index_persistent`. Without
+  this, concurrent writes from the magellan service daemon caused `persist_topology` to
+  receive SQLITE_BUSY and silently discard entry_points and layer data (via
+  `let _ = self.persist_topology()`). Result: 0 rows in hnsw_entry_points,
+  incomplete hnsw_layers, and "Index not initialized" errors on every hopgraph query.
+
+## [3.1.3] - 2026-06-06
+
+### Fixed
+- `search_layer` now implements proper HNSW greedy search with early termination. Previous
+  implementation stopped after `k + M` candidates (e.g. 21 for k=5, M=16), exploring only
+  the entry point's immediate neighborhood. New implementation uses `ef_search` as the
+  candidate pool size and stops when the closest unexplored candidate is farther than the
+  worst result seen, matching the standard HNSW algorithm. Fixes hopgraph returning only
+  symbols from the first indexed file regardless of query.
+
+## [3.1.2] - 2026-06-04
+
+### Fixed
+- `store_vector` now uses `INSERT` without explicit `id` + `last_insert_rowid()` instead of
+  `SELECT MAX(id) + 1`. Removes a TOCTOU race where two concurrent writers to the same DB
+  could compute the same next-id and collide on PRIMARY KEY. `store_vector_with_id` (used
+  only for topology restore) retains explicit-id `INSERT OR IGNORE` semantics unchanged.
+
 ## [3.0.4] - 2026-05-26
 
 ### Fixed

{sqlitegraph-0.5.0 → sqlitegraph-0.5.2}/sqlitegraph-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlitegraph"
-version = "3.1.0"
+version = "3.2.3"
 edition = "2024"
 rust-version = "1.89"
 description = "Embedded graph database with full ACID transactions, HNSW vector search, dual backend support, and comprehensive graph algorithms library"
@@ -128,6 +128,11 @@ harness = false
 name = "sqlite_v3_comparison"
 harness = false
 
+# Curated SQLite vs V3 comparison suite
+[[bench]]
+name = "sqlite_v3_curated"
+harness = false
+
 # Phase 45: Graph Theory algorithms benchmarks
 [[bench]]
 name = "graph_theory_benchmarks"

{sqlitegraph-0.5.0 → sqlitegraph-0.5.2}/sqlitegraph-core/README.md

@@ -12,20 +12,19 @@ SQLite: stable, mature, and easy to inspect with standard tooling. Native V3:
 graph-oriented storage with cache, KV, pub/sub, and traversal features. See the
 benchmarks below for workload-specific behavior.
 
-## What's New in v3.0.0
+## What's New in the 3.2 Line
 
-`v3.0.0` is the first release that ships the full Cypher engine, the
-expanded CLI surface, and the cross-session HNSW persistence fix:
+The current 3.2 release line builds on the 3.0 backend/model transition with
+concrete HNSW and traversal improvements:
 
-- Cypher-inspired `MATCH`, `CREATE`, `SET`, `DELETE`, multi-hop, variable-depth,
-  star/multi-pattern joins, `WHERE` with precedence/parentheses, and HNSW
-  vector search via `CALL db.index.vector.queryNodes(...)`.
-- CLI coverage for PageRank, betweenness, WCC/SCC, Louvain, label propagation,
-  cycle search, dominators, topological sort, critical path, and HNSW
-  create/insert/search/list/delete.
-- Python `Graph.query()` plus algorithm bindings for SCC, label propagation,
-  cycle search, dominators, critical path, and HNSW index deletion.
-- V3 durability fixes and HNSW autoload persistence fixes.
+- `HnswIndex::batch_insert_vectors()` for lower-overhead bulk vector ingestion.
+- Transactional topology persistence for HNSW metadata and layers.
+- `HnswIndexStats` runtime counters for inserts, searches, vector-cache hits,
+  and vector-cache misses.
+- Streaming traversal iterators for BFS, DFS, topological sort, and connected
+  components, so callers can avoid materializing full `Vec`s when they only
+  need incremental results.
+- `parking_lot`-based lock cleanup across the HNSW path and related hot locks.
 
 See [CHANGELOG](https://github.com/oldnordic/sqlitegraph/blob/main/CHANGELOG.md) for full history.
 
@@ -39,48 +38,48 @@ See [CHANGELOG](https://github.com/oldnordic/sqlitegraph/blob/main/CHANGELOG.md)
 | Graph algorithms | 35+ | 35+ |
 | HNSW vectors | Yes | Yes |
 | Pub/Sub | Yes | Yes |
-| LRU Cache | No | Yes (v2.1.0) |
-| Parallel BFS | No | Yes (v2.1.1) |
+| LRU Cache | No | Yes |
+| Parallel BFS | No | Yes |
 
 ## Benchmarks
 
-See [Architecture](https://github.com/oldnordic/sqlitegraph/blob/main/docs/ARCHITECTURE.md) for system design details.
+See [Architecture](https://github.com/oldnordic/sqlitegraph/blob/main/docs/ARCHITECTURE.md) for system design details and [Benchmarking](https://github.com/oldnordic/sqlitegraph/blob/main/docs/BENCHMARKING.md) for methodology.
 
-**Backend Comparison (v2.2.4 - AMD Ryzen 7 7800X3D, tmpfs, Rust 1.95.0):**
+**Representative clean samples from 2026-06-07 (AMD Ryzen 7 7800X3D, tmpfs, Rust 1.95.0):**
 
-| Benchmark | SQLite | V3 | Ratio |
-|-----------|--------|----|-------|
-| BFS 1K nodes / 5K edges | 2.5ms | 0.45ms | V3 **5.5x faster** |
-| BFS 10K / 50K | 26ms | 27ms | ~parity |
-| BFS 50K / 250K | 160ms | 586ms | SQLite 3.6x faster |
-| DFS 1K / 5K | 2.4ms | 0.46ms | V3 **5.2x faster** |
-| Point lookup 1K | 15us | 82us | SQLite 5.4x faster |
-| Point lookup 10K | 27us | 503us | SQLite 18x faster |
-| Shortest path 1K | 304us | 393us | SQLite 29% faster |
+| Benchmark | SQLite | V3 |
+|-----------|--------|----|
+| Criterion `bfs_traversal/small_random_1k_5k` | `2.3680 ms` | `3.3191 ms` |
+| Criterion `bfs_traversal/medium_random_10k_50k` | `26.510 ms` | `56.240 ms` |
+| Release microbenchmark point lookup | `3965 ns` | `146 ns` |
 
-V3 excels at small-scale traversals. SQLite dominates at larger graph sizes and
-point lookups.
+Use the release microbenchmark for fast sanity checks and the Criterion suites
+for workload comparisons.
 
 **Run benchmarks yourself:**
 
 ```bash
 git clone https://github.com/oldnordic/sqlitegraph.git
-cd sqlitegraph/sqlitegraph-core
-cargo run --example test_performance_comparison --features native-v3
-cargo bench --features native-v3 -- backend_comparison
+cd sqlitegraph
+./scripts/run-curated-benchmarks.sh
+
+cd sqlitegraph-core
+cargo run --release --example test_performance_comparison --features native-v3
+cargo bench --features native-v3 --bench backend_comparison
+cargo bench --features native-v3 --bench sqlite_v3_curated
 ```
 
-See [examples/](https://github.com/oldnordic/sqlitegraph/tree/main/sqlitegraph-core/examples) for reproducible performance tests.
+See [examples/](https://github.com/oldnordic/sqlitegraph/tree/main/sqlitegraph-core/examples) for quick performance checks and [docs/BENCHMARKING.md](https://github.com/oldnordic/sqlitegraph/blob/main/docs/BENCHMARKING.md) for the full workflow.
 
 ## Quick Start
 
 ```toml
 [dependencies]
 # SQLite backend (default)
-sqlitegraph-core = "3.0"
+sqlitegraph = "3.2"
 
 # OR Native V3 backend (graph-oriented storage)
-sqlitegraph-core = { version = "3.0", features = ["native-v3"] }
+sqlitegraph = { version = "3.2", features = ["native-v3"] }
 ```
 
 ```rust
@@ -128,7 +127,7 @@ let mut dfs = Dfs::new(&g, a);
 assert_eq!(dfs.by_ref().collect::<Vec<_>>(), vec![a, b, c]);
 ```
 
-New in v3.0.5.
+Available in the current 3.x line.
 
 ## CLI
 
@@ -179,7 +178,11 @@ cargo run -p sqlitegraph --example hybrid_sqlite_v3_hnsw_pubsub --features nativ
 
 ## Performance & Instrumentation
 
-Performance thresholds in sqlitegraph_bench.json gate releases. Benchmarks produce HTML reports under `target/criterion`. Use `cargo bench --bench bench_insert` (etc.) to isolate suites. The `bench_driver` binary runs all benches sequentially and surfaces pass/fail summaries.
+Performance thresholds in `sqlitegraph_bench.json` gate releases. Benchmarks
+produce HTML reports under `target/criterion`. Use
+`cargo bench --bench bench_insert` (etc.) to isolate suites. For comparison
+work, prefer release-mode examples for quick sanity checks and Criterion suites
+for workload data.
 
 Runtime instrumentation is exposed through the core APIs used by benchmarks and
 integration tests: prepare/execute counts, transaction begins/commits/rollbacks,

{sqlitegraph-0.5.0 → sqlitegraph-0.5.2}/sqlitegraph-core/benches/backend_comparison.rs

@@ -1,13 +1,12 @@
-//! Criterion Benchmark: SQLite vs Native V3 Backend
+//! Criterion benchmark: curated SQLite vs Native V3 backend comparison.
 //!
-//! Run with: cargo bench --features native-v3 -- backend_comparison
+//! Run with: cargo bench --features native-v3 --bench backend_comparison
 //!
-//! This benchmark provides statistically rigorous comparisons between
-//! SQLite and Native V3 backends using Criterion.rs for measurement.
+//! This suite is intentionally curated to finish in practical time on a
+//! developer workstation. It focuses on the highest-signal workload families.
 
 use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main};
 use std::time::Duration;
-use tempfile::TempDir;
 
 // Import graph types
 use sqlitegraph::algo::backend::{bfs_traversal, dfs_traversal, k_hop_neighbors, shortest_path};
@@ -15,8 +14,10 @@ use sqlitegraph::backend::native::v3::V3Backend;
 use sqlitegraph::backend::{EdgeSpec, GraphBackend, NodeSpec, SqliteGraphBackend};
 use sqlitegraph::snapshot::SnapshotId;
 
+mod bench_utils;
 // Graph topology generators
 mod graph_generators;
+use bench_utils::create_v3_bench_context;
 
 /// Hardware and environment information
 #[derive(Debug, Clone)]
@@ -169,7 +170,6 @@ fn bench_bfs_traversal(c: &mut Criterion) {
     for (name, nodes, edges) in &[
         ("small_random_1k_5k", 1000, 5000),
         ("medium_random_10k_50k", 10000, 50000),
-        ("large_random_50k_250k", 50000, 250000),
     ] {
         group.throughput(Throughput::Elements(*nodes as u64));
 
@@ -196,13 +196,12 @@ fn bench_bfs_traversal(c: &mut Criterion) {
         group.bench_with_input(BenchmarkId::new("v3", name), &graph_data, |b, data| {
             b.iter_batched(
                 || {
-                    let temp = TempDir::new().unwrap();
-                    let backend = V3Backend::create(temp.path().join("v3.db")).unwrap();
-                    populate_v3_backend(&backend, data);
-                    (backend, temp) // Keep temp alive
+                    let ctx = create_v3_bench_context("v3.db");
+                    populate_v3_backend(&ctx.backend, data);
+                    ctx
                 },
-                |(backend, _temp)| {
-                    let result = bfs_traversal(&backend, black_box(1)).unwrap();
+                |ctx| {
+                    let result = bfs_traversal(&ctx.backend, black_box(1)).unwrap();
                     black_box(result.len());
                 },
                 criterion::BatchSize::SmallInput,
@@ -216,7 +215,7 @@ fn bench_bfs_traversal(c: &mut Criterion) {
 /// Benchmark: DFS Traversal
 fn bench_dfs_traversal(c: &mut Criterion) {
     let mut group = c.benchmark_group("dfs_traversal");
-    group.measurement_time(Duration::from_secs(10));
+    group.measurement_time(Duration::from_secs(8));
     group.sample_size(10);
 
     for (name, nodes, edges) in &[
@@ -244,13 +243,12 @@ fn bench_dfs_traversal(c: &mut Criterion) {
         group.bench_with_input(BenchmarkId::new("v3", name), &graph_data, |b, data| {
             b.iter_batched(
                 || {
-                    let temp = TempDir::new().unwrap();
-                    let backend = V3Backend::create(temp.path().join("v3.db")).unwrap();
-                    populate_v3_backend(&backend, data);
-                    (backend, temp)
+                    let ctx = create_v3_bench_context("v3.db");
+                    populate_v3_backend(&ctx.backend, data);
+                    ctx
                 },
-                |(backend, _temp)| {
-                    let result = dfs_traversal(&backend, black_box(1)).unwrap();
+                |ctx| {
+                    let result = dfs_traversal(&ctx.backend, black_box(1)).unwrap();
                     black_box(result.len());
                 },
                 criterion::BatchSize::SmallInput,
@@ -264,7 +262,8 @@ fn bench_dfs_traversal(c: &mut Criterion) {
 /// Benchmark: k-hop neighbors
 fn bench_k_hop(c: &mut Criterion) {
     let mut group = c.benchmark_group("k_hop_neighbors");
-    group.measurement_time(Duration::from_secs(5));
+    group.measurement_time(Duration::from_secs(4));
+    group.sample_size(10);
 
     for (name, nodes, edges, k) in &[
         ("small_k2", 1000, 5000, 2),
@@ -299,14 +298,13 @@ fn bench_k_hop(c: &mut Criterion) {
             |b, (data, k)| {
                 b.iter_batched(
                     || {
-                        let temp = TempDir::new().unwrap();
-                        let backend = V3Backend::create(temp.path().join("v3.db")).unwrap();
-                        populate_v3_backend(&backend, data);
-                        (backend, temp)
+                        let ctx = create_v3_bench_context("v3.db");
+                        populate_v3_backend(&ctx.backend, data);
+                        ctx
                     },
-                    |(backend, _temp)| {
+                    |ctx| {
                         let result =
-                            k_hop_neighbors(&backend, black_box(1), black_box(*k)).unwrap();
+                            k_hop_neighbors(&ctx.backend, black_box(1), black_box(*k)).unwrap();
                         black_box(result.len());
                     },
                     criterion::BatchSize::SmallInput,
@@ -321,7 +319,8 @@ fn bench_k_hop(c: &mut Criterion) {
 /// Benchmark: Shortest path
 fn bench_shortest_path(c: &mut Criterion) {
     let mut group = c.benchmark_group("shortest_path");
-    group.measurement_time(Duration::from_secs(5));
+    group.measurement_time(Duration::from_secs(4));
+    group.sample_size(10);
 
     for (name, nodes, edges) in &[("small", 1000, 5000), ("medium", 10000, 50000)] {
         let graph_data = generate_random_graph(*nodes, *edges);
@@ -353,14 +352,13 @@ fn bench_shortest_path(c: &mut Criterion) {
             |b, (data, target)| {
                 b.iter_batched(
                     || {
-                        let temp = TempDir::new().unwrap();
-                        let backend = V3Backend::create(temp.path().join("v3.db")).unwrap();
-                        populate_v3_backend(&backend, data);
-                        (backend, temp)
+                        let ctx = create_v3_bench_context("v3.db");
+                        populate_v3_backend(&ctx.backend, data);
+                        ctx
                     },
-                    |(backend, _temp)| {
+                    |ctx| {
                         let result =
-                            shortest_path(&backend, black_box(1), black_box(*target)).unwrap();
+                            shortest_path(&ctx.backend, black_box(1), black_box(*target)).unwrap();
                         black_box(result.map(|p| p.len()));
                     },
                     criterion::BatchSize::SmallInput,
@@ -375,6 +373,8 @@ fn bench_shortest_path(c: &mut Criterion) {
 /// Benchmark: Point lookup (get_node)
 fn bench_point_lookup(c: &mut Criterion) {
     let mut group = c.benchmark_group("point_lookup");
+    group.measurement_time(Duration::from_secs(4));
+    group.sample_size(10);
 
     for (name, nodes) in &[("1k", 1000), ("10k", 10000), ("100k", 100000)] {
         let graph_data = generate_random_graph(*nodes, 0); // No edges for pure lookup test
@@ -406,14 +406,13 @@ fn bench_point_lookup(c: &mut Criterion) {
             |b, (data, target)| {
                 b.iter_batched(
                     || {
-                        let temp = TempDir::new().unwrap();
-                        let backend = V3Backend::create(temp.path().join("v3.db")).unwrap();
-                        populate_v3_backend(&backend, data);
-                        (backend, temp, *target)
+                        let ctx = create_v3_bench_context("v3.db");
+                        populate_v3_backend(&ctx.backend, data);
+                        (ctx, *target)
                     },
-                    |(backend, _temp, target)| {
+                    |(ctx, target)| {
                         let snapshot = SnapshotId::current();
-                        let result = backend.get_node(snapshot, black_box(target)).unwrap();
+                        let result = ctx.backend.get_node(snapshot, black_box(target)).unwrap();
                         black_box(result);
                     },
                     criterion::BatchSize::SmallInput,
@@ -428,6 +427,8 @@ fn bench_point_lookup(c: &mut Criterion) {
 /// Benchmark: Fetch outgoing edges
 fn bench_fetch_outgoing(c: &mut Criterion) {
     let mut group = c.benchmark_group("fetch_outgoing");
+    group.measurement_time(Duration::from_secs(4));
+    group.sample_size(10);
 
     for (name, nodes, edges) in &[
         ("sparse_1k_1k", 1000, 1000),  // 1 edge per node avg
@@ -455,13 +456,12 @@ fn bench_fetch_outgoing(c: &mut Criterion) {
         group.bench_with_input(BenchmarkId::new("v3", name), &graph_data, |b, data| {
             b.iter_batched(
                 || {
-                    let temp = TempDir::new().unwrap();
-                    let backend = V3Backend::create(temp.path().join("v3.db")).unwrap();
-                    populate_v3_backend(&backend, data);
-                    (backend, temp)
+                    let ctx = create_v3_bench_context("v3.db");
+                    populate_v3_backend(&ctx.backend, data);
+                    ctx
                 },
-                |(backend, _temp)| {
-                    let result = backend.fetch_outgoing(black_box(1)).unwrap();
+                |ctx| {
+                    let result = ctx.backend.fetch_outgoing(black_box(1)).unwrap();
                     black_box(result.len());
                 },
                 criterion::BatchSize::SmallInput,
@@ -475,7 +475,8 @@ fn bench_fetch_outgoing(c: &mut Criterion) {
 /// Benchmark: Batch insert performance
 fn bench_batch_insert(c: &mut Criterion) {
     let mut group = c.benchmark_group("batch_insert");
-    group.measurement_time(Duration::from_secs(20));
+    group.measurement_time(Duration::from_secs(8));
+    group.sample_size(10);
 
     for (name, count) in &[("100_nodes", 100), ("1k_nodes", 1000), ("10k_nodes", 10000)] {
         group.throughput(Throughput::Elements(*count as u64));
@@ -502,13 +503,9 @@ fn bench_batch_insert(c: &mut Criterion) {
 
         group.bench_with_input(BenchmarkId::new("v3", name), count, |b, &count| {
             b.iter_batched(
-                || {
-                    let temp = TempDir::new().unwrap();
-                    let backend = V3Backend::create(temp.path().join("v3.db")).unwrap();
-                    (backend, temp)
-                },
-                |(backend, _temp)| {
-                    let mut batch = backend.begin_batch();
+                || create_v3_bench_context("v3.db"),
+                |ctx| {
+                    let mut batch = ctx.backend.begin_batch();
                     for i in 0..count {
                         batch
                             .insert_node(sqlitegraph::backend::NodeSpec {

{sqlitegraph-0.5.0 → sqlitegraph-0.5.2}/sqlitegraph-core/benches/bench_utils.rs

@@ -15,6 +15,7 @@ use std::time::Duration;
 use tempfile::TempDir;
 
 use rand::{RngCore, SeedableRng};
+use sqlitegraph::backend::native::v3::V3Backend;
 use sqlitegraph::{BackendKind, EdgeSpec, GraphConfig, NodeSpec, open_graph};
 
 /// Common benchmark configuration
@@ -22,6 +23,28 @@ pub const SAMPLE_SIZE: usize = 20;
 pub const WARM_UP: Duration = Duration::from_millis(300);
 pub const MEASURE: Duration = Duration::from_millis(500);
 
+/// Benchmark-owned state that guarantees the backend drops before the temp dir.
+///
+/// Benchmarks often need an ephemeral on-disk backend. Returning `(backend,
+/// temp_dir)` from `iter_batched` is subtly wrong because pattern destructuring
+/// drops the temp dir before the backend, which triggers teardown noise in
+/// `V3Backend::drop`. This wrapper makes the intended drop order explicit.
+pub struct BenchmarkState<B, T> {
+    pub backend: B,
+    pub temp_dir: T,
+}
+
+pub type V3BenchContext = BenchmarkState<V3Backend, TempDir>;
+
+pub fn create_v3_bench_context(db_name: &str) -> V3BenchContext {
+    let temp_dir = create_benchmark_temp_dir();
+    let db_path = temp_dir.path().join(db_name);
+    let backend = V3Backend::create(&db_path)
+        .unwrap_or_else(|e| panic!("Failed to create V3 backend at {:?}: {}", db_path, e));
+
+    V3BenchContext { backend, temp_dir }
+}
+
 /// Graph topology types for benchmarking
 #[derive(Debug, Clone, Copy)]
 pub enum GraphTopology {

{sqlitegraph-0.5.0 → sqlitegraph-0.5.2}/sqlitegraph-core/benches/cold_cache.rs

@@ -12,8 +12,9 @@ use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group,
 use std::fs::OpenOptions;
 use std::io::Write;
 use std::time::Duration;
-use tempfile::TempDir;
 
+mod bench_utils;
+use bench_utils::BenchmarkState;
 use sqlitegraph::backend::native::v3::V3Backend;
 use sqlitegraph::backend::{BackendDirection, EdgeSpec, GraphBackend, NeighborQuery, NodeSpec};
 use sqlitegraph::snapshot::SnapshotId;
@@ -74,8 +75,8 @@ fn bench_cold_cache_bfs(c: &mut Criterion) {
             // Setup: Create a fresh database for each iteration
             b.iter_batched(
                 || {
-                    let temp = TempDir::new().unwrap();
-                    let db_path = temp.path().join("cold_cache_bfs.db");
+                    let temp_dir = bench_utils::create_benchmark_temp_dir();
+                    let db_path = temp_dir.path().join("cold_cache_bfs.db");
                     let backend = V3Backend::create(&db_path).unwrap();
 
                     // Create chain graph: 0 -> 1 -> 2 -> ... -> (size-1)
@@ -116,10 +117,11 @@ fn bench_cold_cache_bfs(c: &mut Criterion) {
                     // Reopen backend (this will be cold cache)
                     let backend = V3Backend::open(&db_path).unwrap();
 
-                    (backend, node_ids, temp)
+                    (BenchmarkState { backend, temp_dir }, node_ids)
                 },
-                |(backend, node_ids, _temp)| {
+                |(ctx, node_ids)| {
                     // BFS traversal from first node
+                    let backend = &ctx.backend;
                     let snapshot = SnapshotId::current();
                     let mut visited = std::collections::HashSet::new();
                     let mut queue = vec![node_ids[0]];
@@ -177,8 +179,8 @@ fn bench_cold_cache_point_lookup(c: &mut Criterion) {
             // Setup: Create a fresh database for each iteration
             b.iter_batched(
                 || {
-                    let temp = TempDir::new().unwrap();
-                    let db_path = temp.path().join("cold_cache_lookup.db");
+                    let temp_dir = bench_utils::create_benchmark_temp_dir();
+                    let db_path = temp_dir.path().join("cold_cache_lookup.db");
                     let backend = V3Backend::create(&db_path).unwrap();
 
                     // Create nodes
@@ -207,10 +209,11 @@ fn bench_cold_cache_point_lookup(c: &mut Criterion) {
                     // Reopen backend (this will be cold cache)
                     let backend = V3Backend::open(&db_path).unwrap();
 
-                    (backend, node_ids, temp)
+                    (BenchmarkState { backend, temp_dir }, node_ids)
                 },
-                |(backend, node_ids, _temp)| {
+                |(ctx, node_ids)| {
                     // Point lookups: fetch every 10th node
+                    let backend = &ctx.backend;
                     let snapshot = SnapshotId::current();
                     let mut count = 0;
 
@@ -248,8 +251,8 @@ fn bench_cold_cache_sequential_scan(c: &mut Criterion) {
             // Setup: Create a fresh database for each iteration
             b.iter_batched(
                 || {
-                    let temp = TempDir::new().unwrap();
-                    let db_path = temp.path().join("cold_cache_scan.db");
+                    let temp_dir = bench_utils::create_benchmark_temp_dir();
+                    let db_path = temp_dir.path().join("cold_cache_scan.db");
                     let backend = V3Backend::create(&db_path).unwrap();
 
                     // Create nodes
@@ -278,10 +281,11 @@ fn bench_cold_cache_sequential_scan(c: &mut Criterion) {
                     // Reopen backend (this will be cold cache)
                     let backend = V3Backend::open(&db_path).unwrap();
 
-                    (backend, node_ids, temp)
+                    (BenchmarkState { backend, temp_dir }, node_ids)
                 },
-                |(backend, node_ids, _temp)| {
+                |(ctx, node_ids)| {
                     // Sequential scan: fetch all nodes in order
+                    let backend = &ctx.backend;
                     let snapshot = SnapshotId::current();
                     let mut count = 0;