lora-python 0.8.3__tar.gz → 0.8.4__tar.gz

{lora_python-0.8.3 → lora_python-0.8.4}/Cargo.lock

@@ -797,7 +797,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "lora-ast",
  "lora-parser",
@@ -807,14 +807,14 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-binding-buffer"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "lora-database",
  "lora-store",
@@ -822,7 +822,7 @@ dependencies = [
 
 [[package]]
 name = "lora-compiler"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -830,7 +830,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "anyhow",
  "arc-swap",
@@ -852,7 +852,7 @@ dependencies = [
 
 [[package]]
 name = "lora-executor"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -867,7 +867,7 @@ dependencies = [
 
 [[package]]
 name = "lora-ffi"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -879,7 +879,7 @@ dependencies = [
 
 [[package]]
 name = "lora-node"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -894,7 +894,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "lora-ast",
  "pest",
@@ -905,7 +905,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -917,7 +917,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "anyhow",
  "axum",
@@ -931,7 +931,7 @@ dependencies = [
 
 [[package]]
 name = "lora-snapshot"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "argon2",
  "bincode",
@@ -946,7 +946,7 @@ dependencies = [
 
 [[package]]
 name = "lora-store"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "bincode",
  "crc32fast",
@@ -958,7 +958,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wal"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "crc32fast",
  "lora-store",
@@ -968,7 +968,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -984,7 +984,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.8.3"
+version = "0.8.4"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -1408,18 +1408,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.126"
+version = "0.9.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "284799e73e899fe946fd77c7211b83bff61a1356e039ade7a2516a779e3212d0"
+checksum = "45ca28513560e56cfb79a62b1fce363c73af170a182024ce880c77ee9429920a"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.126"
+version = "0.9.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "855fc1ad8943d12c89ef12f9147f1cc531f5bf19fb744112fdd317bb6ee7b5c5"
+checksum = "ce04b2c55eff3a21aaa623fcc655d94373238e72cac6b3e1a3641ff31649f99a"
 dependencies = [
  "bindgen",
  "lazy_static",

{lora_python-0.8.3 → lora_python-0.8.4}/Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.8.3"
+version = "0.8.4"
 license = "BUSL-1.1"
 authors = ["LoraDB, Inc."]
 repository = "https://github.com/lora-db/lora"
@@ -15,16 +15,16 @@ rust-version = "1.87"
 # Internal crates — versions are kept in lockstep with [workspace.package].version
 # by `scripts/sync-versions.mjs`. Both `path` and `version` are set so that
 # `cargo publish` works (crates.io cannot resolve path-only deps).
-lora-ast = { path = "crates/lora-ast", version = "=0.8.3" }
-lora-parser = { path = "crates/lora-parser", version = "=0.8.3" }
-lora-analyzer = { path = "crates/lora-analyzer", version = "=0.8.3" }
-lora-compiler = { path = "crates/lora-compiler", version = "=0.8.3" }
-lora-store = { path = "crates/lora-store", version = "=0.8.3" }
-lora-snapshot = { path = "crates/lora-snapshot", version = "=0.8.3", default-features = false }
-lora-wal = { path = "crates/lora-wal", version = "=0.8.3" }
-lora-executor = { path = "crates/lora-executor", version = "=0.8.3" }
-lora-database = { path = "crates/lora-database", version = "=0.8.3" }
-lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.8.3" }
+lora-ast = { path = "crates/lora-ast", version = "=0.8.4" }
+lora-parser = { path = "crates/lora-parser", version = "=0.8.4" }
+lora-analyzer = { path = "crates/lora-analyzer", version = "=0.8.4" }
+lora-compiler = { path = "crates/lora-compiler", version = "=0.8.4" }
+lora-store = { path = "crates/lora-store", version = "=0.8.4" }
+lora-snapshot = { path = "crates/lora-snapshot", version = "=0.8.4", default-features = false }
+lora-wal = { path = "crates/lora-wal", version = "=0.8.4" }
+lora-executor = { path = "crates/lora-executor", version = "=0.8.4" }
+lora-database = { path = "crates/lora-database", version = "=0.8.4" }
+lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.8.4" }
 
 # External crates.
 anyhow = "1"

{lora_python-0.8.3 → lora_python-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lora-python
-Version: 0.8.3
+Version: 0.8.4
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8

{lora_python-0.8.3 → lora_python-0.8.4}/crates/lora-database/benches/perf_smoke_baseline.json

@@ -5,7 +5,7 @@
     "default_threshold": 3,
     "seeded_on": "2026-04-24",
     "seeded_from": "Rough scaling of docs/performance/benchmarks.md numbers to allow for ubuntu-latest CI being slower and noisier than the reference Apple Silicon run. Replace with real CI-measured values on first green run.",
-    "last_updated": "2026-04-26"
+    "last_updated": "2026-05-06"
   },
   "benchmarks": {
     "perf_smoke/scan_1k": {
@@ -40,6 +40,21 @@
     },
     "perf_smoke/tx_write_100": {
       "ns": 114336
+    },
+    "perf_smoke/write_one_wal_group": {
+      "ns": 40000,
+      "threshold": 5,
+      "note": "Seed estimate from local Apple Silicon (~15 µs/iter) scaled ~2.5x for ubuntu-latest. Refresh after first green CI run."
+    },
+    "perf_smoke/write_batch_100_wal_group": {
+      "ns": 4000000,
+      "threshold": 5,
+      "note": "Seed estimate from local Apple Silicon (~1.56 ms/iter) scaled ~2.5x for ubuntu-latest. Wide threshold because WAL segment rotation and FS noise inflate variance. Refresh after first green CI run."
+    },
+    "perf_smoke/tx_write_100_wal_group": {
+      "ns": 7000000,
+      "threshold": 5,
+      "note": "Seed estimate from local Apple Silicon (~2.6 ms/iter) scaled ~2.5x for ubuntu-latest. Wide threshold because the explicit-tx path stages-and-publishes alongside the WAL append and adds variance. Refresh after first green CI run."
     }
   }
 }

{lora_python-0.8.3 → lora_python-0.8.4}/crates/lora-database/benches/perf_smoke_benchmarks.rs

@@ -22,9 +22,12 @@ mod fixtures;
 
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use fixtures::*;
-use lora_database::{ExecuteOptions, ResultFormat, TransactionMode};
+use lora_database::{
+    Database, ExecuteOptions, InMemoryGraph, ResultFormat, SyncMode, TransactionMode, WalConfig,
+};
 use std::hint::black_box;
-use std::time::Duration;
+use std::path::PathBuf;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 fn opts() -> Option<ExecuteOptions> {
     Some(ExecuteOptions {
@@ -32,6 +35,51 @@ fn opts() -> Option<ExecuteOptions> {
     })
 }
 
+/// Per-iteration scratch directory for WAL-backed benches. Removed on
+/// drop, so each Criterion sample starts on an empty WAL.
+struct WalScratch {
+    path: PathBuf,
+}
+
+impl WalScratch {
+    fn new(tag: &str) -> Self {
+        let mut path = std::env::temp_dir();
+        path.push(format!(
+            "lora-perf-smoke-{}-{}-{}",
+            tag,
+            std::process::id(),
+            SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&path).unwrap();
+        Self { path }
+    }
+}
+
+impl Drop for WalScratch {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.path);
+    }
+}
+
+/// Open a WAL-backed database with `SyncMode::Group`. Group sync matches
+/// the durability profile most embedded callers reach for — write-only
+/// on commit, background flusher fsyncs on a 50 ms interval — and keeps
+/// the bench dominated by engine + WAL append cost rather than fsync
+/// latency.
+fn open_wal_group(tag: &str) -> (WalScratch, Database<InMemoryGraph>) {
+    let dir = WalScratch::new(tag);
+    let cfg = WalConfig::Enabled {
+        dir: dir.path.clone(),
+        sync_mode: SyncMode::Group { interval_ms: 50 },
+        segment_target_bytes: 8 * 1024 * 1024,
+    };
+    let db = Database::open_with_wal(cfg).unwrap();
+    (dir, db)
+}
+
 /// CI-friendly Criterion config: short warmup + short measurement + modest
 /// sample count. Total measurement budget per bench ≈ 1.8 s.
 fn smoke_config() -> Criterion {
@@ -263,6 +311,67 @@ fn bench_perf_smoke(c: &mut Criterion) {
         );
     });
 
+    // --- 11. persistent single CREATE: WAL group sync --------------------
+    //
+    // Auto-commit `CREATE` against a WAL-backed DB. The DB is opened
+    // once and shared across iterations — the WAL grows, but UNWIND-free
+    // CREATE has no scan cost, so per-iteration cost stays steady-state.
+    // What this bench captures is one record-encode + one segment append
+    // + one `Arc::make_mut` mutation. A regression here means the
+    // durable single-write path picked up per-call overhead beyond the
+    // fixed WAL append cost.
+    {
+        let (_dir, db) = open_wal_group("write-one");
+        group.bench_function("write_one_wal_group", |b| {
+            b.iter(|| {
+                black_box(db.execute("CREATE (:B {n: 1})", opts()).unwrap());
+            });
+        });
+    }
+
+    // --- 12. persistent batched write: WAL group sync --------------------
+    //
+    // Same shape as `write_batch_100` but committed durably via the
+    // group-sync WAL path. Distance from `write_batch_100` is the
+    // batched-write WAL overhead (one append, not 100). A regression
+    // that affects only the persistence write path — e.g., a per-row
+    // WAL fence or extra encode pass — shows up here without moving
+    // the in-memory baseline.
+    {
+        let (_dir, db) = open_wal_group("write-batch-100");
+        group.bench_function("write_batch_100_wal_group", |b| {
+            b.iter(|| {
+                black_box(
+                    db.execute(
+                        "UNWIND range(1, 100) AS i CREATE (:B {id: i, val: i * 2})",
+                        opts(),
+                    )
+                    .unwrap(),
+                );
+            });
+        });
+    }
+
+    // --- 13. persistent explicit transaction: WAL group sync -------------
+    //
+    // Mirror of `tx_write_100` against the WAL/group profile. Catches
+    // regressions in the explicit-transaction commit path where it
+    // intersects the WAL recorder (transaction commit promotes the
+    // staged graph and appends one batched commit record).
+    {
+        let (_dir, db) = open_wal_group("tx-write-100");
+        group.bench_function("tx_write_100_wal_group", |b| {
+            b.iter(|| {
+                let mut tx = db.begin_transaction(TransactionMode::ReadWrite).unwrap();
+                black_box(
+                    tx.execute("UNWIND range(1, 100) AS i CREATE (:B {id: i})", opts())
+                        .unwrap(),
+                );
+                tx.commit().unwrap();
+            });
+        });
+    }
+
     group.finish();
 }
 

{lora_python-0.8.3 → lora_python-0.8.4}/crates/lora-store/src/memory/graph.rs

@@ -360,23 +360,17 @@ impl InMemoryGraph {
             .filter_map(|(i, slot)| slot.as_ref().map(|r| (i as RelationshipId, r.as_ref())))
     }
 
-    /// Add `rel_id` to `node_id`'s outgoing list. Idempotent: skips the push
-    /// if the id is already present (it shouldn't be — relationship ids are
-    /// monotonic — but the guard is cheap and keeps the invariant explicit).
+    /// Add `rel_id` to `node_id`'s outgoing list. Relies on the monotonic-id
+    /// invariant: relationship ids are allocated once and never re-used, so
+    /// the bucket can never see a duplicate.
     fn outgoing_push(&mut self, node_id: NodeId, rel_id: RelationshipId) {
         self.ensure_node_slot(node_id);
-        let v = &mut self.outgoing[node_id as usize];
-        if !v.contains(&rel_id) {
-            v.push(rel_id);
-        }
+        self.outgoing[node_id as usize].push(rel_id);
     }
 
     fn incoming_push(&mut self, node_id: NodeId, rel_id: RelationshipId) {
         self.ensure_node_slot(node_id);
-        let v = &mut self.incoming[node_id as usize];
-        if !v.contains(&rel_id) {
-            v.push(rel_id);
-        }
+        self.incoming[node_id as usize].push(rel_id);
     }
 
     /// Remove `rel_id` from `node_id`'s outgoing list. `swap_remove` keeps
@@ -409,12 +403,14 @@ impl InMemoryGraph {
     }
 
     pub(super) fn insert_node_label_index(&mut self, node_id: NodeId, label: &str) {
-        let bucket = self.nodes_by_label.entry(label.to_string()).or_default();
-        // Same monotonic-id invariant as `outgoing_push`: ids never appear
-        // twice, but the `contains` guard is cheap on small buckets and
-        // makes the invariant explicit for replay paths.
-        if !bucket.contains(&node_id) {
+        // Hot path: skip the `String` alloc when the label bucket already
+        // exists. The monotonic-id invariant on the create path guarantees
+        // `node_id` is unique, so we push unconditionally; the previous
+        // `contains` guard turned bulk CREATE into O(n²).
+        if let Some(bucket) = self.nodes_by_label.get_mut(label) {
             bucket.push(node_id);
+        } else {
+            self.nodes_by_label.insert(label.to_string(), vec![node_id]);
         }
     }
 
@@ -430,12 +426,12 @@ impl InMemoryGraph {
     }
 
     fn insert_relationship_type_index(&mut self, rel_id: RelationshipId, rel_type: &str) {
-        let bucket = self
-            .relationships_by_type
-            .entry(rel_type.to_string())
-            .or_default();
-        if !bucket.contains(&rel_id) {
+        // See `insert_node_label_index` for the same hot-path rationale.
+        if let Some(bucket) = self.relationships_by_type.get_mut(rel_type) {
             bucket.push(rel_id);
+        } else {
+            self.relationships_by_type
+                .insert(rel_type.to_string(), vec![rel_id]);
         }
     }
 

{lora_python-0.8.3 → lora_python-0.8.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "lora-python"
-version = "0.8.3"
+version = "0.8.4"
 description = "Python bindings for the Lora in-memory graph database"
 readme = "README.md"
 license = { text = "BUSL-1.1" }