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

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

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

{lora_python-0.8.1 → lora_python-0.8.2}/Cargo.toml

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

{lora_python-0.8.1 → lora_python-0.8.2}/PKG-INFO

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

{lora_python-0.8.1 → lora_python-0.8.2}/crates/lora-database/src/database/mod.rs

@@ -26,7 +26,6 @@ use crate::explain::{QueryPlan, QueryProfile};
 use crate::live_store::LiveStore;
 use crate::plan_cache::PlanCache;
 use crate::snapshot::ManagedSnapshotStore;
-use crate::wal::write_scope::WalAbortPolicy;
 
 /// Minimal abstraction any transport can depend on to run Lora queries.
 ///
@@ -192,14 +191,12 @@ where
     /// Drop every node and relationship, returning WAL/archive errors to the
     /// caller.
     ///
-    /// When a WAL is attached, the clear is wrapped in `arm`/`commit` so the
-    /// `MutationEvent::Clear` fired by the store reaches the log inside a
-    /// transaction. If a failure happens after the in-memory graph has been
-    /// cleared, the recorder is poisoned by the failing WAL path and future
-    /// writes fail until the database is reopened from durable state.
+    /// When a WAL is attached, the buffered `MutationEvent::Clear` is appended
+    /// to the log on success. The clear runs in place against the live
+    /// graph via the same fast path as `with_logged_store_mut`, so a
+    /// large graph clear no longer pays an O(N+E) snapshot clone.
     pub fn try_clear(&self) -> Result<(), LoraError> {
-        let guard = self.write_store();
-        self.with_logged_write_guard(guard, WalAbortPolicy::AbortOnly, |store| {
+        self.with_logged_store_mut(|store| {
             store.clear();
             Ok(())
         })
@@ -236,13 +233,18 @@ where
 
     /// Run a closure with an exclusive borrow of the underlying store. Reserved
     /// for admin paths (restore, bulk load); regular mutation goes through
-    /// `execute_with_params`. The closure mutates a staged copy that is
-    /// published atomically when the closure returns.
+    /// `execute_with_params`. The closure mutates the live graph in place
+    /// via `Arc::make_mut`, so callers don't pay an O(N+E) snapshot clone
+    /// just to overwrite the graph. Concurrent readers, when present,
+    /// force a single CoW clone and keep observing their pre-mutation
+    /// snapshot via the `Arc<S>` they already hold.
     pub fn with_store_mut<R>(&self, f: impl FnOnce(&mut S) -> R) -> R {
-        let mut guard = self.write_store();
-        let result = f(&mut *guard);
-        guard.publish();
-        result
+        let _lock = self
+            .writer
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner());
+        let mut handle = self.store.write();
+        f(handle.as_mut())
     }
 }
 

{lora_python-0.8.1 → lora_python-0.8.2}/crates/lora-database/src/database/write_guard.rs

@@ -4,27 +4,35 @@
 //!
 //! * [`WriteGuard`] — a working copy + writer-mutex lease produced by
 //!   [`Database::write_store`]. Callers mutate the inner `S` and then
-//!   `publish()` to atomically swap the new state into the `ArcSwap`,
-//!   or drop the guard to discard the changes.
+//!   `publish()` to atomically swap the new state into the live store,
+//!   or drop the guard to discard the changes. Reserved for the
+//!   pessimistic non-`InMemoryGraph` fallback in `execute.rs`; the
+//!   InMemoryGraph admin paths bypass it via the live-mutate
+//!   fast path below.
 //! * [`Database::write_store_deadline`] / [`Database::read_store_deadline`]
 //!   — deadline-aware variants that participate in the cooperative
 //!   query-timeout flow.
 //! * [`Database::with_logged_write_guard`] — a closure runner that
 //!   brackets the staged mutation with WAL `arm` / `commit` / `abort`
 //!   and atomically publishes on success.
+//! * [`Database::with_logged_store_mut`] — the InMemoryGraph fast
+//!   path: mutates the live `Arc<S>` in place via `Arc::make_mut`
+//!   and only commits buffered events to the WAL on success. Skips
+//!   the O(N+E) snapshot clone that `write_store()` pays.
 
-use std::any::Any;
+use std::any::{Any, TypeId};
 use std::ops::{Deref, DerefMut};
-use std::sync::{Arc, MutexGuard, TryLockError};
+use std::sync::{Arc, Mutex, MutexGuard, TryLockError};
 use std::time::{Duration, Instant};
 
 use anyhow::{anyhow, Result};
 use lora_executor::ExecutorError;
-use lora_store::{GraphStorage, GraphStorageMut, InMemoryGraph, MutationRecorder};
+use lora_store::{GraphStorage, GraphStorageMut, InMemoryGraph, MutationEvent, MutationRecorder};
 use lora_wal::WalRecorder;
 
 use crate::database::Database;
-use crate::wal::write_scope::{WalAbortPolicy, WalWriteScope};
+use crate::transaction::BufferingRecorder;
+use crate::wal::write_scope::{ensure_wal_query_can_start, WalAbortPolicy, WalWriteScope};
 
 use super::replay::install_recorder_if_inmemory;
 
@@ -158,14 +166,80 @@ where
         Ok(())
     }
 
+    /// Run `f` against the live graph, mutating in place, and commit
+    /// the buffered mutation events to the WAL on success.
+    ///
+    /// For `InMemoryGraph` (the default backend) this is the fast
+    /// path: it skips the O(N+E) snapshot clone that `write_store()`
+    /// pays, going through the same `LiveStore::write()` +
+    /// `Arc::make_mut` flow that the optimistic auto-commit query
+    /// path uses. Mutation events buffer into a tx-local `Vec` while
+    /// the closure runs; on success they're appended to the WAL as a
+    /// single transaction, on failure they're discarded so the WAL
+    /// stays consistent. The trade-off matches the OCC fast path: a
+    /// failure mid-closure can leave the in-memory graph partially
+    /// mutated, but durable state stays consistent and recovery from
+    /// snapshot+WAL replays only committed transactions.
+    ///
+    /// For non-`InMemoryGraph` backends the pessimistic clone-then-
+    /// publish path is preserved: those backends don't expose the
+    /// `set_mutation_recorder` hook, so a buffered-event redirect
+    /// isn't possible.
     pub(crate) fn with_logged_store_mut<R>(
         &self,
         f: impl FnOnce(&mut S) -> Result<R>,
     ) -> Result<R> {
+        if TypeId::of::<S>() == TypeId::of::<InMemoryGraph>() {
+            return self.with_live_store_mut(f);
+        }
         let guard = self.write_store();
         self.with_logged_write_guard(guard, WalAbortPolicy::AbortOnly, f)
     }
 
+    fn with_live_store_mut<R>(&self, f: impl FnOnce(&mut S) -> Result<R>) -> Result<R> {
+        let _commit_lock = self
+            .writer
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner());
+
+        let buffer = Arc::new(Mutex::new(Vec::<MutationEvent>::new()));
+        let buffering_rec: Arc<dyn MutationRecorder> =
+            Arc::new(BufferingRecorder::new(buffer.clone()));
+
+        let mut handle = self.store.write();
+
+        let exec_result = {
+            let staged = handle.as_mut();
+            install_recorder_if_inmemory(staged, Some(buffering_rec));
+            let r = f(staged);
+            install_recorder_if_inmemory(staged, None);
+            r
+        };
+
+        let events: Vec<MutationEvent> = std::mem::take(&mut buffer.lock().unwrap());
+
+        let mut wrote_commit = false;
+        if let Some(rec) = self.wal.as_ref() {
+            if exec_result.is_ok() && !events.is_empty() {
+                ensure_wal_query_can_start(rec)?;
+                wrote_commit = rec.commit_events(events)?.wrote();
+            }
+            // Reinstall the durable recorder so the live graph keeps
+            // observing future mutations after this scope exits.
+            let staged = handle.as_mut();
+            install_recorder_if_inmemory(staged, Some(rec.clone() as Arc<dyn MutationRecorder>));
+        }
+
+        if wrote_commit {
+            if let Some(rec) = self.wal.as_ref() {
+                let live = handle.snapshot();
+                self.observe_snapshot_commit_if_needed(&*live, rec)?;
+            }
+        }
+
+        exec_result
+    }
+
     /// Run `f` against the staged graph inside a WAL transaction. On
     /// success, atomically publishes the staged graph to the live
     /// `ArcSwap`; on error, the staged copy is dropped (no observable

{lora_python-0.8.1 → lora_python-0.8.2}/pyproject.toml

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