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

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

@@ -797,7 +797,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "lora-ast",
  "lora-parser",
@@ -807,14 +807,14 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-binding-buffer"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "lora-database",
  "lora-store",
@@ -822,7 +822,7 @@ dependencies = [
 
 [[package]]
 name = "lora-compiler"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -830,7 +830,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "anyhow",
  "arc-swap",
@@ -852,7 +852,7 @@ dependencies = [
 
 [[package]]
 name = "lora-executor"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -867,7 +867,7 @@ dependencies = [
 
 [[package]]
 name = "lora-ffi"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -879,7 +879,7 @@ dependencies = [
 
 [[package]]
 name = "lora-node"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -894,7 +894,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "lora-ast",
  "pest",
@@ -905,7 +905,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -917,7 +917,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "anyhow",
  "axum",
@@ -931,7 +931,7 @@ dependencies = [
 
 [[package]]
 name = "lora-snapshot"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "argon2",
  "bincode",
@@ -946,7 +946,7 @@ dependencies = [
 
 [[package]]
 name = "lora-store"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "bincode",
  "crc32fast",
@@ -958,7 +958,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wal"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "crc32fast",
  "lora-store",
@@ -968,7 +968,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -984,7 +984,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.8.4"
+version = "0.8.5"
 dependencies = [
  "anyhow",
  "lora-database",

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

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.8.4"
+version = "0.8.5"
 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.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" }
+lora-ast = { path = "crates/lora-ast", version = "=0.8.5" }
+lora-parser = { path = "crates/lora-parser", version = "=0.8.5" }
+lora-analyzer = { path = "crates/lora-analyzer", version = "=0.8.5" }
+lora-compiler = { path = "crates/lora-compiler", version = "=0.8.5" }
+lora-store = { path = "crates/lora-store", version = "=0.8.5" }
+lora-snapshot = { path = "crates/lora-snapshot", version = "=0.8.5", default-features = false }
+lora-wal = { path = "crates/lora-wal", version = "=0.8.5" }
+lora-executor = { path = "crates/lora-executor", version = "=0.8.5" }
+lora-database = { path = "crates/lora-database", version = "=0.8.5" }
+lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.8.5" }
 
 # External crates.
 anyhow = "1"

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

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

{lora_python-0.8.4 → lora_python-0.8.5}/crates/lora-database/benches/concurrency_guard_benchmarks.rs

@@ -247,14 +247,17 @@ fn bench_concurrency_guard(c: &mut Criterion) {
     }
 
     // WAL write paths without the per-iteration directory setup measured.
-    // `None` isolates WAL encoding/flush-buffer overhead; cooperative Group
-    // isolates the path that future concurrent fsync coordination will touch.
+    // GroupSync isolates WAL encoding/flush-buffer overhead plus background
+    // fsync coordination.
     {
-        let dir = ScratchDir::new("wal-none");
-        let db = Database::<InMemoryGraph>::open_with_wal(wal_config(&dir.path, SyncMode::None))
-            .unwrap();
+        let dir = ScratchDir::new("wal-group-sync");
+        let db = Database::<InMemoryGraph>::open_with_wal(wal_config(
+            &dir.path,
+            SyncMode::GroupSync { interval_ms: 50 },
+        ))
+        .unwrap();
         let mut next = 0i64;
-        group.bench_function("wal_none_create_delete_one", |b| {
+        group.bench_function("wal_group_sync_create_delete_one", |b| {
             b.iter(|| {
                 next += 1;
                 black_box(
@@ -273,7 +276,7 @@ fn bench_concurrency_guard(c: &mut Criterion) {
         let dir = ScratchDir::new("wal-group");
         let db = Database::<InMemoryGraph>::open_with_wal(wal_config(
             &dir.path,
-            SyncMode::Group { interval_ms: 50 },
+            SyncMode::GroupSync { interval_ms: 50 },
         ))
         .unwrap();
         let mut next = 0i64;

lora_python-0.8.5/crates/lora-database/benches/perf_smoke_baseline.json

@@ -0,0 +1,89 @@
+{
+  "_meta": {
+    "purpose": "Baseline ns/iter for the perf_smoke_benchmarks suite. Used by scripts/check-perf-smoke.mjs to detect performance regressions. NOT an authoritative performance record. See docs/performance/perf-smoke.md.",
+    "refresh": "node scripts/check-perf-smoke.mjs --update <bencher-output>",
+    "default_threshold": 3,
+    "threshold_policy": "Each bench carries an explicit `threshold` (regression multiplier). 3 is the canonical 'obvious-regression' gate for low-variance in-memory paths; 5 is used for sub-µs benches and WAL-backed benches where filesystem and runner noise inflate variance. Widen rather than remove if a bench becomes chronically flaky — a 5× gate still catches a catastrophic regression.",
+    "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-05-06"
+  },
+  "benchmarks": {
+    "perf_smoke/scan_1k": {
+      "ns": 172801,
+      "threshold": 2
+    },
+    "perf_smoke/filter_1k": {
+      "ns": 166596,
+      "threshold": 2
+    },
+    "perf_smoke/traversal_chain_500": {
+      "ns": 167629,
+      "threshold": 2
+    },
+    "perf_smoke/write_batch_100": {
+      "ns": 109584,
+      "threshold": 2
+    },
+    "perf_smoke/stream_scan_1k": {
+      "ns": 201749,
+      "threshold": 2
+    },
+    "perf_smoke/stream_pull_one": {
+      "ns": 717,
+      "threshold": 2
+    },
+    "perf_smoke/stream_write_100": {
+      "ns": 80604,
+      "threshold": 2
+    },
+    "perf_smoke/stream_write_sort_100": {
+      "ns": 205564,
+      "threshold": 2
+    },
+    "perf_smoke/tx_roundtrip_empty": {
+      "ns": 147,
+      "threshold": 2
+    },
+    "perf_smoke/tx_read_1k": {
+      "ns": 267327,
+      "threshold": 2
+    },
+    "perf_smoke/tx_write_100": {
+      "ns": 99217,
+      "threshold": 2
+    },
+    "perf_smoke/write_one_wal_group": {
+      "ns": 4417,
+      "threshold": 2
+    },
+    "perf_smoke/write_batch_100_wal_group": {
+      "ns": 189573,
+      "threshold": 2
+    },
+    "perf_smoke/tx_write_100_wal_group": {
+      "ns": 2446265,
+      "threshold": 2
+    },
+    "perf_smoke/write_one_wal_persistent": {
+      "ns": 4268990,
+      "threshold": 2
+    },
+    "perf_smoke/scan_1k_wal_group": {
+      "ns": 177912,
+      "threshold": 2
+    },
+    "perf_smoke/delete_100_wal_group": {
+      "ns": 4509379,
+      "threshold": 2
+    },
+    "perf_smoke/update_100_wal_group": {
+      "ns": 81676,
+      "threshold": 2
+    },
+    "perf_smoke/wal_replay_100": {
+      "ns": 533982,
+      "threshold": 2
+    }
+  }
+}

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

@@ -64,7 +64,7 @@ impl Drop for WalScratch {
     }
 }
 
-/// Open a WAL-backed database with `SyncMode::Group`. Group sync matches
+/// Open a WAL-backed database with `SyncMode::GroupSync`. 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
@@ -73,7 +73,7 @@ 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 },
+        sync_mode: SyncMode::GroupSync { interval_ms: 50 },
         segment_target_bytes: 8 * 1024 * 1024,
     };
     let db = Database::open_with_wal(cfg).unwrap();
@@ -372,6 +372,123 @@ fn bench_perf_smoke(c: &mut Criterion) {
         });
     }
 
+    // --- 14. persistent single CREATE: WAL + force_fsync per commit ------
+    //
+    // Same shape as `write_one_wal_group` but adds an explicit
+    // `Database::sync()` on each iteration, forcing the WAL through to
+    // durable storage before the next commit lands. This captures the
+    // fully-durable per-commit profile (formerly `SyncMode::PerCommit`)
+    // — the gap to `write_one_wal_group` is one `fsync` per iteration.
+    // A regression here without one in `write_one_wal_group` points at
+    // the durability boundary path (`force_fsync` / `sync_dir`).
+    {
+        let (_dir, db) = open_wal_group("write-one-persistent");
+        group.bench_function("write_one_wal_persistent", |b| {
+            b.iter(|| {
+                black_box(db.execute("CREATE (:B {n: 1})", opts()).unwrap());
+                db.sync().unwrap();
+            });
+        });
+    }
+
+    // --- 15. persistent read: WAL group sync -----------------------------
+    //
+    // Read-heavy workload against a WAL-backed DB. Reads should not touch
+    // the recorder, so this should track `scan_1k` (#1) ± noise. A
+    // regression here without one in `scan_1k` points at the WAL recorder
+    // leaking into the read path (e.g. an extra guard or fence taken on
+    // every MATCH).
+    {
+        let (_dir, db) = open_wal_group("scan-wal");
+        db.execute(
+            "UNWIND range(1, 1000) AS i CREATE (:Node {id: i, value: i % 100})",
+            opts(),
+        )
+        .unwrap();
+        group.bench_function("scan_1k_wal_group", |b| {
+            b.iter(|| {
+                black_box(db.execute("MATCH (n:Node) RETURN n.id", opts()).unwrap());
+            });
+        });
+    }
+
+    // --- 16. persistent batched delete: WAL group sync -------------------
+    //
+    // MATCH + DELETE on 100 nodes against a freshly seeded DB. Exercises
+    // the WAL node-tombstone record path, which is distinct from the
+    // node-create path that #11/#12 cover. Fresh DB per iteration since
+    // each batch consumes the seed.
+    group.bench_function("delete_100_wal_group", |b| {
+        b.iter_batched(
+            || {
+                let (dir, db) = open_wal_group("delete-100");
+                db.execute("UNWIND range(1, 100) AS i CREATE (:D {id: i})", opts())
+                    .unwrap();
+                (dir, db)
+            },
+            |(_dir, db)| {
+                black_box(db.execute("MATCH (n:D) DELETE n", opts()).unwrap());
+            },
+            BatchSize::SmallInput,
+        );
+    });
+
+    // --- 17. persistent property update: WAL group sync ------------------
+    //
+    // MATCH + SET on 100 nodes — exercises the property-mutation WAL
+    // record path (distinct from create/delete). DB is shared across
+    // iterations: each SET re-stamps the same property and appends one
+    // batched commit record, giving a steady-state cost per iteration.
+    {
+        let (_dir, db) = open_wal_group("update-100");
+        db.execute("UNWIND range(1, 100) AS i CREATE (:U {id: i})", opts())
+            .unwrap();
+        group.bench_function("update_100_wal_group", |b| {
+            b.iter(|| {
+                black_box(
+                    db.execute("MATCH (n:U) SET n.touched = true", opts())
+                        .unwrap(),
+                );
+            });
+        });
+    }
+
+    // --- 18. WAL replay on open ------------------------------------------
+    //
+    // Open a WAL directory that already has 100 committed records and
+    // measure how long the replay-on-open path takes. Bounds startup time
+    // on a crash-recovery boot. The WAL is built once outside the iter and
+    // its scratch directory is `mem::forget`-ed so the files stay alive
+    // across every Criterion iteration (the OS reclaims at process exit).
+    {
+        let dir = WalScratch::new("replay-100");
+        {
+            let cfg = WalConfig::Enabled {
+                dir: dir.path.clone(),
+                sync_mode: SyncMode::GroupSync { interval_ms: 50 },
+                segment_target_bytes: 8 * 1024 * 1024,
+            };
+            let db = Database::open_with_wal(cfg).unwrap();
+            for _ in 0..100 {
+                db.execute("CREATE (:R {n: 1})", opts()).unwrap();
+            }
+            drop(db);
+        }
+        let path = dir.path.clone();
+        std::mem::forget(dir);
+        group.bench_function("wal_replay_100", |b| {
+            b.iter(|| {
+                let cfg = WalConfig::Enabled {
+                    dir: path.clone(),
+                    sync_mode: SyncMode::GroupSync { interval_ms: 50 },
+                    segment_target_bytes: 8 * 1024 * 1024,
+                };
+                let db = Database::open_with_wal(cfg).unwrap();
+                black_box(db.node_count());
+            });
+        });
+    }
+
     group.finish();
 }