sqlitegraph 0.2.0__tar.gz → 0.4.0__tar.gz

{sqlitegraph-0.2.0 → sqlitegraph-0.4.0}/Cargo.lock

@@ -1387,7 +1387,7 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "sqlitegraph"
-version = "2.3.0"
+version = "3.0.0"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -1406,6 +1406,7 @@ dependencies = [
  "r2d2_sqlite",
  "rand 0.8.6",
  "rayon",
+ "regex",
  "rusqlite",
  "rustc_version",
  "serde",
@@ -1418,7 +1419,7 @@ dependencies = [
 
 [[package]]
 name = "sqlitegraph-cli"
-version = "2.1.5"
+version = "3.0.0"
 dependencies = [
  "anyhow",
  "clap",
@@ -1428,7 +1429,7 @@ dependencies = [
 
 [[package]]
 name = "sqlitegraph-py"
-version = "0.2.0"
+version = "0.4.0"
 dependencies = [
  "ndarray 0.16.1",
  "numpy",

{sqlitegraph-0.2.0 → sqlitegraph-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlitegraph
-Version: 0.2.0
+Version: 0.4.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3
@@ -54,6 +54,68 @@ g.add_edge(alice, order, "placed")
 print(g.neighbors(alice))
 ```
 
+## Query language
+
+`Graph.query()` exposes the same Cypher-inspired language as the CLI:
+
+```python
+from sqlitegraph import Graph
+
+g = Graph.open_in_memory()
+alice = g.add_node(kind="User", name="Alice", data={"age": 30})
+bob = g.add_node(kind="User", name="Bob", data={"age": 31})
+g.add_edge(alice, bob, "KNOWS")
+
+result = g.query("MATCH (a:User)-[:KNOWS]->(b:User) RETURN a.name, b.name")
+print(result["results"])
+```
+
+Supported query features include node scans, edge traversal, multi-hop chains,
+star/multi-pattern joins, variable-depth edges, `WHERE` with regex/numeric
+operators and parentheses, `LIMIT`, `CREATE`, `SET`, `DELETE`, and HNSW vector
+search through `CALL db.index.vector.queryNodes(...)`.
+
+## Algorithms
+
+```python
+from sqlitegraph import Graph
+
+g = Graph.open_in_memory()
+a = g.add_node(kind="Page", name="A")
+b = g.add_node(kind="Page", name="B")
+c = g.add_node(kind="Page", name="C")
+g.add_edge(a, b, "LINKS")
+g.add_edge(b, c, "LINKS")
+g.add_edge(c, a, "LINKS")
+
+print(g.pagerank(iterations=20))
+print(g.connected_components())
+print(g.strongly_connected_components())
+print(g.label_propagation(50))
+print(g.find_cycles(10))
+print(g.dominators(a))
+```
+
+`critical_path()` is also available for directed acyclic graphs and returns
+`{"path": [...], "distance": float, "path_length": int}`.
+
+## HNSW vector search
+
+```python
+from sqlitegraph import Graph
+
+g = Graph.open_in_memory()
+idx = g.create_hnsw_index("embeddings", dimension=3, metric="cosine")
+
+idx.insert_vector([1.0, 0.8, 0.1], {"label": "graph databases"})
+idx.insert_vector([0.1, 0.2, 1.0], {"label": "baking"})
+
+print(idx.search([1.0, 0.9, 0.0], 1))
+print(g.list_hnsw_indexes())
+
+g.delete_hnsw_index("embeddings")
+```
+
 ## Examples
 
 The [`examples/`](./examples/) directory contains runnable scripts:
@@ -61,10 +123,11 @@ The [`examples/`](./examples/) directory contains runnable scripts:
 | Example | What it shows |
 |---------|---------------|
 | [`01_basic_crud.py`](./examples/01_basic_crud.py) | Nodes, edges, update, delete, query by kind/pattern, degrees |
-| [`02_graph_algorithms.py`](./examples/02_graph_algorithms.py) | BFS, k-hop, shortest path, PageRank, Louvain communities, connected components |
+| [`02_graph_algorithms.py`](./examples/02_graph_algorithms.py) | BFS, k-hop, shortest path, PageRank, Louvain & label-propagation communities, connected components (WCC), strongly-connected components (SCC), cycle search, dominator tree, critical path |
 | [`03_vector_search.py`](./examples/03_vector_search.py) | HNSW index creation, insert, search, bulk insert, index listing |
 | [`04_social_network.py`](./examples/04_social_network.py) | Realistic network: influencers (PageRank), communities, connection paths, mutual follows |
 | [`05_file_backed.py`](./examples/05_file_backed.py) | Persistent `Graph.open(path)`, checkpoint, reopen, cleanup |
+| [`06_hybrid_sqlite_hnsw_query.py`](./examples/06_hybrid_sqlite_hnsw_query.py) | sqlite3 application rows + sqlitegraph metadata + HNSW + `Graph.query()` expansion |
 
 Run any example from the repo root:
 

sqlitegraph-0.4.0/README.md

@@ -0,0 +1,107 @@
+# sqlitegraph
+
+Python bindings to the [`sqlitegraph`](https://crates.io/crates/sqlitegraph)
+embedded graph database. Storage, graph algorithms, and HNSW vector search
+run in a reviewed Rust core; this package is the Pythonic surface.
+
+> Alpha — API subject to change before 1.0.
+
+## Install
+
+    pip install sqlitegraph
+
+## Quick start
+
+```python
+from sqlitegraph import Graph
+
+g = Graph.open_in_memory()
+alice = g.add_node(kind="User", name="Alice", data={"age": 30})
+order = g.add_node(kind="Order", name="Order-123")
+g.add_edge(alice, order, "placed")
+
+print(g.neighbors(alice))
+```
+
+## Query language
+
+`Graph.query()` exposes the same Cypher-inspired language as the CLI:
+
+```python
+from sqlitegraph import Graph
+
+g = Graph.open_in_memory()
+alice = g.add_node(kind="User", name="Alice", data={"age": 30})
+bob = g.add_node(kind="User", name="Bob", data={"age": 31})
+g.add_edge(alice, bob, "KNOWS")
+
+result = g.query("MATCH (a:User)-[:KNOWS]->(b:User) RETURN a.name, b.name")
+print(result["results"])
+```
+
+Supported query features include node scans, edge traversal, multi-hop chains,
+star/multi-pattern joins, variable-depth edges, `WHERE` with regex/numeric
+operators and parentheses, `LIMIT`, `CREATE`, `SET`, `DELETE`, and HNSW vector
+search through `CALL db.index.vector.queryNodes(...)`.
+
+## Algorithms
+
+```python
+from sqlitegraph import Graph
+
+g = Graph.open_in_memory()
+a = g.add_node(kind="Page", name="A")
+b = g.add_node(kind="Page", name="B")
+c = g.add_node(kind="Page", name="C")
+g.add_edge(a, b, "LINKS")
+g.add_edge(b, c, "LINKS")
+g.add_edge(c, a, "LINKS")
+
+print(g.pagerank(iterations=20))
+print(g.connected_components())
+print(g.strongly_connected_components())
+print(g.label_propagation(50))
+print(g.find_cycles(10))
+print(g.dominators(a))
+```
+
+`critical_path()` is also available for directed acyclic graphs and returns
+`{"path": [...], "distance": float, "path_length": int}`.
+
+## HNSW vector search
+
+```python
+from sqlitegraph import Graph
+
+g = Graph.open_in_memory()
+idx = g.create_hnsw_index("embeddings", dimension=3, metric="cosine")
+
+idx.insert_vector([1.0, 0.8, 0.1], {"label": "graph databases"})
+idx.insert_vector([0.1, 0.2, 1.0], {"label": "baking"})
+
+print(idx.search([1.0, 0.9, 0.0], 1))
+print(g.list_hnsw_indexes())
+
+g.delete_hnsw_index("embeddings")
+```
+
+## Examples
+
+The [`examples/`](./examples/) directory contains runnable scripts:
+
+| Example | What it shows |
+|---------|---------------|
+| [`01_basic_crud.py`](./examples/01_basic_crud.py) | Nodes, edges, update, delete, query by kind/pattern, degrees |
+| [`02_graph_algorithms.py`](./examples/02_graph_algorithms.py) | BFS, k-hop, shortest path, PageRank, Louvain & label-propagation communities, connected components (WCC), strongly-connected components (SCC), cycle search, dominator tree, critical path |
+| [`03_vector_search.py`](./examples/03_vector_search.py) | HNSW index creation, insert, search, bulk insert, index listing |
+| [`04_social_network.py`](./examples/04_social_network.py) | Realistic network: influencers (PageRank), communities, connection paths, mutual follows |
+| [`05_file_backed.py`](./examples/05_file_backed.py) | Persistent `Graph.open(path)`, checkpoint, reopen, cleanup |
+| [`06_hybrid_sqlite_hnsw_query.py`](./examples/06_hybrid_sqlite_hnsw_query.py) | sqlite3 application rows + sqlitegraph metadata + HNSW + `Graph.query()` expansion |
+
+Run any example from the repo root:
+
+```bash
+cd sqlitegraph-py
+source .venv/bin/activate
+python examples/01_basic_crud.py
+```

{sqlitegraph-0.2.0 → sqlitegraph-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlitegraph"
-version = "0.2.0"
+version = "0.4.0"
 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.2.0 → sqlitegraph-0.4.0}/sqlitegraph-core/Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "sqlitegraph"
-version = "2.3.0"
+version = "3.0.0"
 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"
 license = "GPL-3.0"
 repository = "https://github.com/oldnordic/sqlitegraph"
@@ -41,6 +42,7 @@ log = "0.4"
 rayon = "1.10"
 petgraph = "0.6"
 sha2 = "0.10"
+regex = "1"
 
 [dependencies.lru]
 version = "0.12"

sqlitegraph-0.4.0/sqlitegraph-core/README.md

@@ -0,0 +1,193 @@
+# SQLiteGraph
+
+[![crates.io](https://img.shields.io/crates/v/sqlitegraph.svg)](https://crates.io/crates/sqlitegraph)
+[![Documentation](https://docs.rs/sqlitegraph/badge.svg)](https://docs.rs/sqlitegraph)
+
+Embedded graph database with dual backend architecture, graph algorithms,
+Cypher-inspired queries, and HNSW vector search.
+
+**Positioning:** Single-binary embedded database (no server). Persistent storage with
+atomic batch commits. Graph algorithms + HNSW vector search in one engine.
+SQLite: stable, mature, excellent for adjacency queries. V3: high-performance,
+designed for large-scale graphs, faster for bulk traversals. See benchmarks below.
+
+## What's New in v3.0.0
+
+`v3.0.0` is the first release that ships the full Cypher engine, the
+expanded CLI surface, and the cross-session HNSW persistence fix:
+
+- 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.
+
+See [CHANGELOG](https://github.com/oldnordic/sqlitegraph/blob/main/CHANGELOG.md) for full history.
+
+## Backends
+
+| Feature | SQLite | Native V3 |
+|---------|--------|-----------|
+| Status | Stable | Stable |
+| Storage | `.db` file | `.graph` file |
+| Max nodes | Unlimited | Unlimited |
+| 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) |
+
+## Benchmarks
+
+See [Architecture](https://github.com/oldnordic/sqlitegraph/blob/main/docs/ARCHITECTURE.md) for system design details.
+
+**Backend Comparison (v2.2.4 - 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 |
+
+V3 excels at small-scale traversals. SQLite dominates at larger graph sizes and
+point lookups.
+
+**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
+```
+
+See [examples/](https://github.com/oldnordic/sqlitegraph/tree/main/sqlitegraph-core/examples) for reproducible performance tests.
+
+## Quick Start
+
+```toml
+[dependencies]
+# SQLite backend (default)
+sqlitegraph = "2.4"
+
+# OR Native V3 backend (faster traversals)
+sqlitegraph = { version = "2.4", features = ["native-v3"] }
+```
+
+```rust
+use sqlitegraph::backend::{GraphBackend, NodeSpec};
+use sqlitegraph::backend::sqlite::SqliteGraphBackend;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let backend = SqliteGraphBackend::in_memory()?;
+
+    let node_id = backend.insert_node(NodeSpec {
+        kind: "User".to_string(),
+        name: "Alice".to_string(),
+        file_path: None,
+        data: serde_json::json!({"age": 30}),
+    })?;
+
+    println!("Created node: {}", node_id);
+    Ok(())
+}
+```
+
+## CLI
+
+```bash
+cargo install sqlitegraph-cli
+
+# Query
+sqlitegraph --db graph.db query "MATCH (n:User) RETURN n.name"
+
+# Algorithms
+sqlitegraph --db graph.db bfs --start 1 --depth 3
+sqlitegraph --db graph.db algo pagerank --iterations 100
+```
+
+## Copy-Paste CLI Demo
+
+```bash
+rm -f /tmp/sqlitegraph-demo.db
+
+sqlitegraph --db /tmp/sqlitegraph-demo.db --write insert --kind User --name Alice --data '{"age":30}'
+sqlitegraph --db /tmp/sqlitegraph-demo.db --write insert --kind User --name Bob --data '{"age":31}'
+sqlitegraph --db /tmp/sqlitegraph-demo.db --write query 'CREATE (1)-[:KNOWS]->(2)'
+
+sqlitegraph --db /tmp/sqlitegraph-demo.db query 'MATCH (a:User)-[:KNOWS]->(b:User) RETURN a.name, b.name'
+sqlitegraph --db /tmp/sqlitegraph-demo.db algo scc
+```
+
+## Hybrid Runtime Demo
+
+This crate includes a runnable demo that combines ordinary SQLite rows, Native
+V3 graph metadata, SQLite-backed HNSW vectors, and V3 pub/sub:
+
+```bash
+cargo run -p sqlitegraph --example hybrid_sqlite_v3_hnsw_pubsub --features native-v3
+```
+
+## Safety Invariants
+
+- Orphan edges are detected by verifying every edge endpoint references a stored entity before any reasoning or subgraph extraction runs.
+- Duplicate edges (identical `(from,to,type)` tuples) are tallied so traversal/pipeline counts stay deterministic and regressions surface quickly.
+- Invalid label/property references (metadata rows pointing at missing entities) are reported by the safety-check helpers.
+- Integrity sweeps perform a deep table walk (entities/edges/labels/properties), verifying sorted IDs, valid JSON payloads, and metadata references before committing to pipelines or migrations.
+
+## DSL Constraints
+
+- Supported clauses are limited to deterministic `pattern`, `k-hop`, `filter type=…`, and `score` steps; ordering matters and only one filter clause is allowed.
+- Combination syntax (`CALLS*2`, `CALLS->USES`) must not introduce conflicting filters or unknown tokens—ambiguous or unsupported input causes parser errors surfaced to the CLI/tests.
+
+## 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.
+
+Runtime instrumentation is exposed through the core APIs used by benchmarks and
+integration tests: prepare/execute counts, transaction begins/commits/rollbacks,
+and cache hits/misses can be captured while reproducing workloads.
+
+## Schema Compatibility Matrix
+
+| Version | Description |
+|---------|-------------|
+| 1 | Base tables (`graph_entities`, `graph_edges`, `graph_labels`, `graph_properties`) plus indexes and `graph_meta`. |
+| 2 | Adds `graph_meta_history` rows so each migration application is recorded; exposed via `run_pending_migrations` / CLI `migrate`. |
+| Future | The CLI refuses to open DBs whose version exceeds the compiled `SCHEMA_VERSION`. |
+
+Upgrade workflow:
+1. Inspect the database with `sqlitegraph --db <path> status`.
+2. Review pending migrations through the library migration helpers.
+3. Apply migrations atomically through the library helper; history entries are appended automatically.
+
+## Ecosystem
+
+Tools built on SQLiteGraph:
+
+| Tool | Purpose | Repository | crates.io |
+|------|---------|------------|-----------|
+| **Magellan** | Code graph indexing, symbol navigation | [github.com/oldnordic/magellan](https://github.com/oldnordic/magellan) | [crates.io/crates/magellan](https://crates.io/crates/magellan) |
+| **llmgrep** | Semantic code search | [github.com/oldnordic/llmgrep](https://github.com/oldnordic/llmgrep) | [crates.io/crates/llmgrep](https://crates.io/crates/llmgrep) |
+| **Mirage** | CFG analysis, path enumeration | [github.com/oldnordic/mirage](https://github.com/oldnordic/mirage) | [crates.io/crates/mirage-analyzer](https://crates.io/crates/mirage-analyzer) |
+| **splice** | Precision code editing | [github.com/oldnordic/splice](https://github.com/oldnordic/splice) | [crates.io/crates/splice](https://crates.io/crates/splice) |
+
+## Documentation
+
+- [Architecture](https://github.com/oldnordic/sqlitegraph/blob/main/docs/ARCHITECTURE.md) - System design
+- [Manual](https://github.com/oldnordic/sqlitegraph/blob/main/MANUAL.md) - API guide
+- [Query Language](https://github.com/oldnordic/sqlitegraph/blob/main/docs/QUERY_LANGUAGE.md) - Cypher-inspired query reference
+- [Changelog](https://github.com/oldnordic/sqlitegraph/blob/main/CHANGELOG.md) - Version history
+- [SnapshotId Migration Guide](https://github.com/oldnordic/sqlitegraph/blob/main/docs/SNAPSHOTID_MIGRATION.md) - v2.1.2 API changes
+
+## License
+
+GPL-3.0

{sqlitegraph-0.2.0 → sqlitegraph-0.4.0}/sqlitegraph-core/benches/adjlist_benchmark.rs

@@ -36,15 +36,15 @@ impl SimpleAdjList {
     }
 
     fn add_edge(&mut self, src: u64, dst: u64) {
-        if let Some(outgoing) = self.outgoing.get_mut(&src) {
-            if !outgoing.contains(&dst) {
-                outgoing.push(dst);
-            }
+        if let Some(outgoing) = self.outgoing.get_mut(&src)
+            && !outgoing.contains(&dst)
+        {
+            outgoing.push(dst);
         }
-        if let Some(incoming) = self.incoming.get_mut(&dst) {
-            if !incoming.contains(&src) {
-                incoming.push(src);
-            }
+        if let Some(incoming) = self.incoming.get_mut(&dst)
+            && !incoming.contains(&src)
+        {
+            incoming.push(src);
         }
     }
 
@@ -68,10 +68,10 @@ impl SimpleAdjList {
         visited.insert(start);
 
         while let Some((node, depth)) = queue.pop_front() {
-            if let Some(max_depth) = max_depth {
-                if depth > max_depth {
-                    continue;
-                }
+            if let Some(max_depth) = max_depth
+                && depth > max_depth
+            {
+                continue;
             }
 
             result.push(node);

{sqlitegraph-0.2.0 → sqlitegraph-0.4.0}/sqlitegraph-core/benches/bench_utils.rs

@@ -2,6 +2,14 @@
 //!
 //! Provides utilities for creating deterministic test graphs and running
 //! fair performance comparisons between SQLite and Native backends.
+//!
+//! This module is consumed by many benchmark binaries; clippy reports dead
+//! code per-target, but every helper here is used by at least one bench.
+
+#![allow(
+    dead_code,
+    reason = "shared bench utilities used across multiple bench targets"
+)]
 
 use std::time::Duration;
 use tempfile::TempDir;
@@ -84,14 +92,14 @@ pub fn create_benchmark_graph(backend: BackendKind, spec: &BenchmarkGraph) -> Be
     }
 
     // Generate edges based on topology using individual insertions
-    let edge_count = generate_edges(&graph, &node_ids, spec);
+    let edge_count = generate_edges(&*graph, &node_ids, spec);
 
     let creation_time = start_time.elapsed();
 
     BenchmarkResult {
         backend,
         node_count: node_ids.len(),
-        edge_count: edge_count,
+        edge_count,
         creation_time,
         temp_dir,
         db_path,
@@ -110,7 +118,7 @@ pub struct BenchmarkResult {
 
 /// Generate edges based on the specified topology
 fn generate_edges(
-    graph: &Box<dyn sqlitegraph::GraphBackend>,
+    graph: &dyn sqlitegraph::GraphBackend,
     node_ids: &[i64],
     spec: &BenchmarkGraph,
 ) -> usize {
@@ -138,11 +146,12 @@ fn generate_edges(
                 return 0;
             }
             let center = node_ids[0];
-            for i in 1..node_ids.len().min(spec.edge_count + 1) {
+            let take = (spec.edge_count + 1).min(node_ids.len()).saturating_sub(1);
+            for (i, &to) in node_ids.iter().enumerate().skip(1).take(take) {
                 graph
                     .insert_edge(EdgeSpec {
                         from: center,
-                        to: node_ids[i],
+                        to,
                         edge_type: "star".to_string(),
                         data: serde_json::json!({"spoke": i}),
                     })
@@ -237,9 +246,10 @@ impl BenchInMemoryGraph {
 
         match spec.topology {
             GraphTopology::Chain => {
-                for i in 0..spec.node_count.min(spec.edge_count) {
+                let limit = spec.node_count.min(spec.edge_count);
+                for (i, adj) in adjacency.iter_mut().enumerate().take(limit) {
                     if i + 1 < spec.node_count {
-                        adjacency[i].push(i as u32 + 1);
+                        adj.push(i as u32 + 1);
                     }
                 }
             }
@@ -263,18 +273,19 @@ impl BenchInMemoryGraph {
             }
             GraphTopology::Grid => {
                 let grid_size = (spec.node_count as f64).sqrt() as usize;
-                for i in 0..spec.node_count.min(spec.edge_count) {
+                let limit = spec.node_count.min(spec.edge_count);
+                for (i, adj) in adjacency.iter_mut().enumerate().take(limit) {
                     let row = i / grid_size;
                     let col = i % grid_size;
 
                     // Right neighbor
                     if col + 1 < grid_size && i + 1 < spec.node_count {
-                        adjacency[i].push((i + 1) as u32);
+                        adj.push((i + 1) as u32);
                     }
 
                     // Bottom neighbor
                     if row + 1 < grid_size && i + grid_size < spec.node_count {
-                        adjacency[i].push((i + grid_size) as u32);
+                        adj.push((i + grid_size) as u32);
                     }
                 }
             }

{sqlitegraph-0.2.0 → sqlitegraph-0.4.0}/sqlitegraph-core/benches/comprehensive_performance.rs

@@ -97,7 +97,7 @@ fn bench_insert_throughput(criterion: &mut Criterion) {
             &batch_size,
             |b, &size| {
                 b.iter_batched(
-                    || create_benchmark_temp_dir(),
+                    create_benchmark_temp_dir,
                     |temp_dir| {
                         let db_path = temp_dir.path().join("insert.db");
                         let graph = open_graph(&db_path, &GraphConfig::native()).unwrap();
@@ -209,7 +209,7 @@ fn bench_memory_efficiency(criterion: &mut Criterion) {
             &node_count,
             |b, &count| {
                 b.iter_batched(
-                    || create_benchmark_temp_dir(),
+                    create_benchmark_temp_dir,
                     |temp_dir| {
                         let db_path = temp_dir.path().join("memory.db");
                         let graph = open_graph(&db_path, &GraphConfig::native()).unwrap();

{sqlitegraph-0.2.0 → sqlitegraph-0.4.0}/sqlitegraph-core/benches/graph_generators.rs

@@ -2,6 +2,14 @@
 //!
 //! Provides various graph structures to test algorithm performance
 //! under different topological conditions.
+//!
+//! Each bench binary uses a subset of these helpers; clippy flags the rest
+//! as dead per-target. Allow it here so the shared utilities stay green.
+
+#![allow(
+    dead_code,
+    reason = "shared bench utilities used across multiple bench targets"
+)]
 
 use rand::Rng;
 use sqlitegraph::backend::{EdgeSpec, NodeSpec};
@@ -307,7 +315,7 @@ fn generate_power_law(nodes: usize, target_edges: usize, alpha: f64) -> GraphDat
 
 /// Generate grid/lattice structure
 fn generate_grid(nodes: usize, width: usize) -> GraphData {
-    let height = (nodes + width - 1) / width;
+    let height = nodes.div_ceil(width);
 
     let node_specs = (0..nodes)
         .map(|i| NodeSpec {
@@ -392,6 +400,10 @@ fn generate_complete(nodes: usize) -> GraphData {
 
 #[cfg(test)]
 mod tests {
+    #[allow(
+        unused_imports,
+        reason = "items resolved through allow(dead_code) attribute"
+    )]
     use super::*;
 
     #[test]