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

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

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

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

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

{lora_python-0.8.2 → lora_python-0.8.4}/crates/lora-database/Cargo.toml

@@ -63,3 +63,7 @@ harness = false
 [[bench]]
 name = "concurrent_benchmarks"
 harness = false
+
+[[bench]]
+name = "concurrency_guard_benchmarks"
+harness = false

lora_python-0.8.4/crates/lora-database/benches/concurrency_guard_benchmarks.rs

@@ -0,0 +1,303 @@
+//! Tight local performance guard for concurrency work.
+//!
+//! `perf_smoke_benchmarks` is the broad CI canary and intentionally allows
+//! large runner noise. This suite is narrower and meant for phase-by-phase
+//! local checks while changing the concurrency/write/WAL plumbing:
+//!
+//! ```text
+//! cargo bench -p lora-database --bench concurrency_guard_benchmarks \
+//!     -- --output-format bencher > /tmp/lora-before.bencher
+//! # make one implementation step
+//! cargo bench -p lora-database --bench concurrency_guard_benchmarks \
+//!     -- --output-format bencher > /tmp/lora-after.bencher
+//! node scripts/check-bench-delta.mjs \
+//!     --baseline /tmp/lora-before.bencher \
+//!     --current /tmp/lora-after.bencher \
+//!     --threshold 1.15
+//! ```
+//!
+//! The cases here deliberately cover the hot surfaces most likely to regress
+//! while introducing concurrent writes: snapshot reads, live streams,
+//! auto-commit writes, explicit transactions, mixed read/write threads, and
+//! WAL-backed write paths.
+
+mod fixtures;
+
+use std::collections::BTreeMap;
+use std::hint::black_box;
+use std::path::PathBuf;
+use std::sync::{Arc, Barrier};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use fixtures::{build_node_graph, BenchDb, Scale};
+use lora_database::{
+    Database, ExecuteOptions, InMemoryGraph, LoraValue, ResultFormat, SyncMode, TransactionMode,
+    WalConfig,
+};
+
+fn opts() -> Option<ExecuteOptions> {
+    Some(ExecuteOptions {
+        format: ResultFormat::Rows,
+    })
+}
+
+fn guard_config() -> Criterion {
+    Criterion::default()
+        .warm_up_time(Duration::from_millis(400))
+        .measurement_time(Duration::from_millis(1_800))
+        .sample_size(30)
+        .noise_threshold(0.08)
+}
+
+struct ScratchDir {
+    path: PathBuf,
+}
+
+impl ScratchDir {
+    fn new(tag: &str) -> Self {
+        let mut path = std::env::temp_dir();
+        path.push(format!(
+            "lora-concurrency-guard-{}-{}-{}",
+            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 ScratchDir {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.path);
+    }
+}
+
+fn wal_config(dir: &std::path::Path, sync_mode: SyncMode) -> WalConfig {
+    WalConfig::Enabled {
+        dir: dir.to_path_buf(),
+        sync_mode,
+        segment_target_bytes: 8 * 1024 * 1024,
+    }
+}
+
+fn int_param(name: &str, value: i64) -> BTreeMap<String, LoraValue> {
+    let mut params = BTreeMap::new();
+    params.insert(name.to_string(), LoraValue::Int(value));
+    params
+}
+
+fn two_int_params(a: (&str, i64), b: (&str, i64)) -> BTreeMap<String, LoraValue> {
+    let mut params = BTreeMap::new();
+    params.insert(a.0.to_string(), LoraValue::Int(a.1));
+    params.insert(b.0.to_string(), LoraValue::Int(b.1));
+    params
+}
+
+fn bench_concurrency_guard(c: &mut Criterion) {
+    let mut group = c.benchmark_group("concurrency_guard");
+
+    // Snapshot read path: catches regressions in `LiveStore::load_full`,
+    // plan execution, and read-only WAL prechecks.
+    {
+        let db = build_node_graph(Scale::SMALL);
+        group.bench_function("read_scan_1k", |b| {
+            b.iter(|| {
+                black_box(
+                    db.service
+                        .execute("MATCH (n:Node) RETURN n.id", opts())
+                        .unwrap(),
+                );
+            });
+        });
+    }
+
+    // Live read stream: pins an Arc snapshot and drops after one row.
+    {
+        let db = build_node_graph(Scale::SMALL);
+        group.bench_function("stream_pull_one_1k", |b| {
+            b.iter(|| {
+                let mut stream = db.service.stream("MATCH (n:Node) RETURN n.id").unwrap();
+                black_box(stream.next_row().unwrap());
+            });
+        });
+    }
+
+    // Auto-commit create on one long-lived DB. This keeps the benchmark on the
+    // write hot path instead of measuring fixture setup.
+    {
+        let db = BenchDb::new();
+        let mut next = 0i64;
+        group.bench_function("write_create_one_steady", |b| {
+            b.iter(|| {
+                next += 1;
+                black_box(
+                    db.service
+                        .execute_with_params(
+                            "CREATE (:Guard {id: $id})",
+                            opts(),
+                            int_param("id", next),
+                        )
+                        .unwrap(),
+                );
+            });
+        });
+    }
+
+    // Existing-record write on a 1k graph. Future per-record commit
+    // validation should keep this close to the current single-writer cost.
+    {
+        let db = build_node_graph(Scale::SMALL);
+        let mut next = 0i64;
+        group.bench_function("write_set_existing_1k", |b| {
+            b.iter(|| {
+                next += 1;
+                black_box(
+                    db.service
+                        .execute_with_params(
+                            "MATCH (n:Node {id: $id}) SET n.value = $value",
+                            opts(),
+                            two_int_params(("id", 500), ("value", next)),
+                        )
+                        .unwrap(),
+                );
+            });
+        });
+    }
+
+    // Fixed explicit transaction cost. This should stay tiny while
+    // introducing concurrent write bookkeeping.
+    {
+        let db = build_node_graph(Scale::SMALL);
+        group.bench_function("tx_roundtrip_empty", |b| {
+            b.iter(|| {
+                let tx = db
+                    .service
+                    .begin_transaction(TransactionMode::ReadWrite)
+                    .unwrap();
+                tx.commit().unwrap();
+            });
+        });
+    }
+
+    // Explicit transaction write path, including buffering recorder and
+    // publish. Fresh DB per iteration so the committed write cannot
+    // accumulate into the next sample.
+    group.bench_function("tx_write_create_one", |b| {
+        b.iter_batched(
+            BenchDb::new,
+            |db| {
+                let mut tx = db
+                    .service
+                    .begin_transaction(TransactionMode::ReadWrite)
+                    .unwrap();
+                black_box(tx.execute("CREATE (:TxGuard {id: 1})", opts()).unwrap());
+                tx.commit().unwrap();
+            },
+            BatchSize::SmallInput,
+        );
+    });
+
+    // Mixed reader/writer pressure. Thread spawn overhead is intentional here:
+    // this is a coarse local guard for accidental global locks on read paths.
+    {
+        let db = Arc::new(build_node_graph(Scale::SMALL).service);
+        let mut next = 0i64;
+        group.bench_function("mixed_4_readers_1_writer", |b| {
+            b.iter(|| {
+                next += 1;
+                let barrier = Arc::new(Barrier::new(5));
+                let handles: Vec<_> = (0..4)
+                    .map(|_| {
+                        let db = db.clone();
+                        let barrier = barrier.clone();
+                        std::thread::spawn(move || {
+                            barrier.wait();
+                            black_box(db.execute("MATCH (n:Node) RETURN n.id", opts()).unwrap());
+                        })
+                    })
+                    .collect();
+
+                let writer = {
+                    let db = db.clone();
+                    let barrier = barrier.clone();
+                    std::thread::spawn(move || {
+                        barrier.wait();
+                        black_box(
+                            db.execute_with_params(
+                                "CREATE (:MixedGuard {id: $id})",
+                                opts(),
+                                int_param("id", next),
+                            )
+                            .unwrap(),
+                        );
+                    })
+                };
+
+                for handle in handles {
+                    handle.join().unwrap();
+                }
+                writer.join().unwrap();
+            });
+        });
+    }
+
+    // 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.
+    {
+        let dir = ScratchDir::new("wal-none");
+        let db = Database::<InMemoryGraph>::open_with_wal(wal_config(&dir.path, SyncMode::None))
+            .unwrap();
+        let mut next = 0i64;
+        group.bench_function("wal_none_create_delete_one", |b| {
+            b.iter(|| {
+                next += 1;
+                black_box(
+                    db.execute_with_params(
+                        "CREATE (n:WalGuard {id: $id}) DELETE n",
+                        opts(),
+                        int_param("id", next),
+                    )
+                    .unwrap(),
+                );
+            });
+        });
+    }
+
+    {
+        let dir = ScratchDir::new("wal-group");
+        let db = Database::<InMemoryGraph>::open_with_wal(wal_config(
+            &dir.path,
+            SyncMode::Group { interval_ms: 50 },
+        ))
+        .unwrap();
+        let mut next = 0i64;
+        group.bench_function("wal_group_create_delete_one", |b| {
+            b.iter(|| {
+                next += 1;
+                black_box(
+                    db.execute_with_params(
+                        "CREATE (n:WalGuard {id: $id}) DELETE n",
+                        opts(),
+                        int_param("id", next),
+                    )
+                    .unwrap(),
+                );
+            });
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group! {
+    name = benches;
+    config = guard_config();
+    targets = bench_concurrency_guard,
+}
+criterion_main!(benches);

{lora_python-0.8.2 → 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.2 → 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();
 }