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

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

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

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.8.3"
+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.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.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.3 → lora_python-0.8.5}/PKG-INFO

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

{lora_python-0.8.3 → 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.3 → lora_python-0.8.5}/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::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
+/// 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::GroupSync { 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,184 @@ 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();
+            });
+        });
+    }
+
+    // --- 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();
 }