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

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

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

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

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

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

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

{lora_python-0.8.0 → lora_python-0.8.1}/crates/lora-database/src/database/builder.rs

@@ -21,12 +21,12 @@ use std::io::BufReader;
 use std::path::Path;
 use std::sync::{Arc, Mutex};
 
-use arc_swap::ArcSwap;
 use lora_store::{GraphStorage, GraphStorageMut, InMemoryGraph, MutationRecorder};
 use lora_wal::{replay_dir, Lsn, Wal, WalConfig, WalMirror, WalRecorder};
 
 use crate::database::Database;
 use crate::error::{LoraError, LoraErrorCode};
+use crate::live_store::LiveStore;
 use crate::named::{DatabaseName, DatabaseOpenOptions};
 use crate::plan_cache::PlanCache;
 use crate::snapshot::{ManagedSnapshotStore, SnapshotConfig};
@@ -221,7 +221,7 @@ impl Database<InMemoryGraph> {
     ) -> Self {
         graph.set_mutation_recorder(Some(recorder.clone() as Arc<dyn MutationRecorder>));
         Self {
-            store: Arc::new(ArcSwap::from(Arc::new(graph))),
+            store: Arc::new(LiveStore::new(Arc::new(graph))),
             writer: Arc::new(Mutex::new(())),
             lock_table: Arc::new(lora_store::LockTable::new()),
             wal: Some(recorder),
@@ -236,7 +236,7 @@ where
     S: GraphStorage + GraphStorageMut + Any + Clone + Send + Sync + 'static,
 {
     /// Build a database from a pre-wrapped, shared store.
-    pub fn new(store: Arc<ArcSwap<S>>) -> Self {
+    pub(crate) fn new(store: Arc<LiveStore<S>>) -> Self {
         Self {
             store,
             writer: Arc::new(Mutex::new(())),
@@ -249,6 +249,6 @@ where
 
     /// Build a database by taking ownership of a bare graph store.
     pub fn from_graph(graph: S) -> Self {
-        Self::new(Arc::new(ArcSwap::from(Arc::new(graph))))
+        Self::new(Arc::new(LiveStore::new(Arc::new(graph))))
     }
 }

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

@@ -2,8 +2,6 @@ use std::any::Any;
 use std::collections::BTreeMap;
 use std::sync::{Arc, Mutex};
 
-use arc_swap::ArcSwap;
-
 use anyhow::{anyhow, Result};
 use lora_ast::{Direction, Document};
 use lora_executor::{lora_value_to_property, ExecuteOptions, LoraValue, QueryResult};
@@ -25,6 +23,7 @@ mod write_guard;
 
 use crate::error::LoraError;
 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;
@@ -72,25 +71,25 @@ pub trait QueryRunner: Send + Sync + 'static {
 /// the WAL handle is `None` and the engine pays only the existing
 /// `MutationRecorder::record` null-pointer check per mutation.
 pub struct Database<S> {
-    /// The current authoritative store, atomically swappable. Reads call
-    /// `store.load_full()` to obtain an `Arc<S>` snapshot — no lock, no
-    /// blocking — and run their executor against `&*snapshot`. Writes
-    /// take the `writer` Mutex (for commit-order serialization), clone
-    /// the current snapshot into a working copy, mutate that copy, append
-    /// to the WAL, then `store.store(Arc::new(staged))` to publish.
-    /// Concurrent reads keep their old `Arc<S>` alive until they drop it,
-    /// which gives natural snapshot isolation.
-    pub(crate) store: Arc<ArcSwap<S>>,
-    /// Serializes commit ordering. Held only across `clone-mutate-WAL-publish`,
-    /// not around any read. Multiple readers proceed concurrently with a
-    /// writer; only writers contend with each other on this Mutex.
+    /// The current authoritative store. Reads call `store.load_full()`
+    /// to obtain an independent `Arc<S>` snapshot; writers take the
+    /// `writer` Mutex and then a brief write-lock on the inner
+    /// `RwLock<Arc<S>>`, mutating in-place via `Arc::make_mut`. When
+    /// no in-flight reader holds a snapshot Arc, `make_mut` returns
+    /// `&mut S` without cloning the graph — that's the single-writer
+    /// fast path that "CREATE one node" / "SET property" depend on
+    /// for graph-size-independent throughput. When concurrent readers
+    /// are alive, `make_mut` clones once and the readers keep
+    /// observing the pre-mutation state via their old Arc.
+    pub(crate) store: Arc<LiveStore<S>>,
+    /// Serializes commit ordering. Held across `mutate-WAL-publish` so
+    /// WAL records are appended in the same order live state advances.
+    /// Readers never touch this Mutex; only writers contend.
     pub(crate) writer: Arc<Mutex<()>>,
-    /// Per-record write locks, plumbed in Phase 4.1. Phase 4.2 keeps
-    /// the writer Mutex serialization model so the lock table sits
-    /// idle for now; it becomes load-bearing in a future phase that
-    /// drops the writer Mutex in favour of ArcSwap CAS for true
-    /// concurrent commits, where two writers with overlapping write
-    /// sets need a real serialization point.
+    /// Per-record write locks. Plumbed for a future phase that allows
+    /// concurrent commits across disjoint write sets; today the writer
+    /// Mutex provides single-writer-at-a-time semantics so this table
+    /// is idle.
     #[allow(dead_code)]
     pub(crate) lock_table: Arc<lora_store::LockTable>,
     pub(crate) wal: Option<Arc<WalRecorder>>,
@@ -159,10 +158,12 @@ where
         self.wal.as_ref()
     }
 
-    /// Handle to the underlying shared store — useful for callers that need
-    /// to snapshot or share the graph across multiple databases.
-    pub fn store(&self) -> &Arc<ArcSwap<S>> {
-        &self.store
+    /// Snapshot the current authoritative graph. Equivalent to the
+    /// historical `database.store().load_full()` pattern, exposed here
+    /// so external callers don't need to name the internal storage
+    /// wrapper.
+    pub fn snapshot(&self) -> Arc<S> {
+        self.store.load_full()
     }
 
     /// Parse a query string into an AST without executing it.

lora_python-0.8.1/crates/lora-database/src/database/occ.rs

@@ -0,0 +1,137 @@
+//! Single-writer auto-commit write path for `InMemoryGraph`.
+//!
+//! Earlier revisions cloned the entire snapshot into a "staged" graph
+//! per mutating query (see `git log` for the OCC + `ArcSwap` design).
+//! That made every CREATE / SET / DELETE pay an O(N+E) graph clone,
+//! which dominated wall-clock for write-heavy benches against large
+//! graphs.
+//!
+//! The current implementation acquires the writer mutex, takes the
+//! `RwLock` write guard inside [`LiveStore`], and uses
+//! `Arc::make_mut` against the live `Arc<S>`. When no in-flight reader
+//! holds a snapshot Arc clone, `make_mut` returns `&mut S` *without*
+//! cloning the graph — restoring v0.6's mutate-in-place cost.
+//! Concurrent readers, when present, force a single CoW clone and keep
+//! observing their pre-mutation snapshot via the Arc they already
+//! hold.
+//!
+//! Trade-off vs. the prior OCC clone-then-publish: a query that
+//! fails mid-execution leaves the live graph partially mutated. The
+//! WAL records are not appended (the buffer is drained without
+//! commit), so durable state stays consistent and recovery from
+//! snapshot+WAL is unaffected. The same caveat applies to the
+//! pessimistic `with_logged_write_guard` path with
+//! `WalAbortPolicy::PoisonIfMutated`.
+
+use std::any::Any;
+use std::collections::BTreeMap;
+use std::sync::{Arc, Mutex};
+use std::time::Instant;
+
+use anyhow::Result;
+use lora_compiler::CompiledQuery;
+use lora_executor::{LoraValue, MutableExecutionContext, MutableExecutor, Row};
+use lora_store::{GraphStorage, GraphStorageMut, MutationEvent, MutationRecorder};
+
+use crate::database::Database;
+use crate::transaction::BufferingRecorder;
+use crate::wal::write_scope::ensure_wal_query_can_start;
+
+use super::replay::install_recorder_if_inmemory;
+
+impl<S> Database<S>
+where
+    S: GraphStorage + GraphStorageMut + Any + Clone + Send + Sync + 'static,
+{
+    /// Single-writer auto-commit write path. Takes the writer mutex,
+    /// mutates the live store in place via `Arc::make_mut`, and (for
+    /// WAL-backed databases) appends a single batched commit record.
+    pub(crate) fn execute_mutating_optimistic(
+        &self,
+        params: BTreeMap<String, LoraValue>,
+        deadline: Option<Instant>,
+        compiled: &Arc<CompiledQuery>,
+    ) -> Result<Vec<Row>> {
+        // Serialize commit ordering so WAL records appear in the same
+        // order writers publish to the live store.
+        let _commit_lock = self
+            .writer
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner());
+
+        // Buffer mutation events tx-locally. We replay them into the
+        // durable WAL only after the executor returns success — a
+        // failed query leaves no on-disk trace.
+        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();
+
+        // Install the buffering recorder *after* `make_mut` so the
+        // (rare) CoW clone that `make_mut` performs when concurrent
+        // readers hold a snapshot doesn't drop the recorder we just
+        // installed — `InMemoryGraph::clone` intentionally drops the
+        // recorder on the cloned copy.
+        let exec_result = {
+            let staged = handle.as_mut();
+            install_recorder_if_inmemory(staged, Some(buffering_rec));
+            let mut executor = MutableExecutor::with_deadline(
+                MutableExecutionContext {
+                    storage: staged,
+                    params,
+                },
+                deadline,
+            );
+            let r = executor.execute_compiled_rows(compiled);
+            install_recorder_if_inmemory(staged, None);
+            r
+        };
+
+        let rows = match exec_result {
+            Ok(rows) => rows,
+            Err(e) => return Err(anyhow::Error::from(e)),
+        };
+
+        let events: Vec<MutationEvent> = std::mem::take(&mut buffer.lock().unwrap());
+
+        if events.is_empty() {
+            // Mutating-shape query that didn't actually mutate
+            // (e.g., MATCH that found nothing to SET). Reinstall the
+            // durable recorder if there is one, then return.
+            if let Some(rec) = self.wal.as_ref() {
+                let staged = handle.as_mut();
+                install_recorder_if_inmemory(
+                    staged,
+                    Some(rec.clone() as Arc<dyn MutationRecorder>),
+                );
+            }
+            return Ok(rows);
+        }
+
+        // Durable WAL append. WAL goes first so a crash between WAL
+        // and the in-memory state stays recoverable: the next boot
+        // replays our events on top of the snapshot.
+        let mut wrote_commit = false;
+        if let Some(rec) = self.wal.as_ref() {
+            ensure_wal_query_can_start(rec)?;
+            wrote_commit = rec.commit_events(events)?.wrote();
+        }
+
+        // Reinstall the durable recorder so the post-publish live
+        // store keeps observing future mutations.
+        if let Some(rec) = self.wal.as_ref() {
+            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)?;
+            }
+        }
+
+        Ok(rows)
+    }
+}

lora_python-0.8.1/crates/lora-database/src/database/replay.rs

@@ -0,0 +1,144 @@
+//! Mutation-event replay helpers used by recovery and any caller that
+//! needs to apply a stream of [`MutationEvent`]s against a graph.
+//!
+//! Two concerns live here:
+//!
+//! * [`install_recorder_if_inmemory`] — best-effort attach/detach of a
+//!   [`MutationRecorder`] when the storage happens to be `InMemoryGraph`.
+//! * [`replay_into`] — the WAL-recovery replay entry point: applies a
+//!   committed event stream to a fresh graph using id-preserving
+//!   create paths, with descriptive errors keyed by event index.
+
+use std::any::Any;
+use std::sync::Arc;
+
+use anyhow::{anyhow, Result};
+
+use lora_store::{GraphStorage, GraphStorageMut, InMemoryGraph, MutationEvent, MutationRecorder};
+
+/// Best-effort: install a mutation recorder on the storage when the
+/// concrete type is `InMemoryGraph`. The WAL's recorder lives on the
+/// store, but `GraphStorage` is an open trait — backends that don't
+/// support recorders are simply skipped (their writes go unobserved
+/// for WAL purposes, which is correct because they don't drive the WAL
+/// in the first place).
+pub(crate) fn install_recorder_if_inmemory<S: GraphStorage + Any + Sized>(
+    store: &mut S,
+    recorder: Option<Arc<dyn MutationRecorder>>,
+) {
+    let any: &mut dyn Any = store;
+    if let Some(graph) = any.downcast_mut::<InMemoryGraph>() {
+        graph.set_mutation_recorder(recorder);
+    }
+}
+
+/// Apply a `MutationEvent` stream to an in-memory graph by dispatching
+/// each variant to the matching store operation.
+///
+/// Creation events are replayed through id-preserving paths, not the
+/// normal allocator-backed mutation methods. That matters after aborted
+/// transactions: an aborted create can consume id `N` in the original
+/// process, be dropped by replay, and leave the next committed create at
+/// id `N + 1`. Reusing the regular allocator would shift ids downward.
+///
+/// Replay must be invoked **before** the `WalRecorder` is installed
+/// on the graph. Otherwise the replay's own mutations would fire the
+/// recorder and re-write the same events to the WAL, doubling them on
+/// the next recovery.
+pub(crate) fn replay_into(graph: &mut InMemoryGraph, events: Vec<MutationEvent>) -> Result<()> {
+    for (idx, event) in events.into_iter().enumerate() {
+        match event {
+            MutationEvent::CreateNode {
+                id,
+                labels,
+                properties,
+            } => {
+                graph
+                    .replay_create_node(id, labels, properties)
+                    .map_err(|e| anyhow!("WAL replay failed at event {idx}: {e}"))?;
+            }
+            MutationEvent::CreateRelationship {
+                id,
+                src,
+                dst,
+                rel_type,
+                properties,
+            } => {
+                graph
+                    .replay_create_relationship(id, src, dst, &rel_type, properties)
+                    .map_err(|e| anyhow!("WAL replay failed at event {idx}: {e}"))?;
+            }
+            MutationEvent::SetNodeProperty {
+                node_id,
+                key,
+                value,
+            } => {
+                if !graph.set_node_property(node_id, key, value) {
+                    return Err(anyhow!(
+                        "WAL replay failed at event {idx}: missing node {node_id} for property set"
+                    ));
+                }
+            }
+            MutationEvent::RemoveNodeProperty { node_id, key } => {
+                if !graph.remove_node_property(node_id, &key) {
+                    return Err(anyhow!(
+                        "WAL replay failed at event {idx}: missing node {node_id} for property removal"
+                    ));
+                }
+            }
+            MutationEvent::AddNodeLabel { node_id, label } => {
+                if !graph.add_node_label(node_id, &label) {
+                    return Err(anyhow!(
+                        "WAL replay failed at event {idx}: missing node {node_id} for label add"
+                    ));
+                }
+            }
+            MutationEvent::RemoveNodeLabel { node_id, label } => {
+                if !graph.remove_node_label(node_id, &label) {
+                    return Err(anyhow!(
+                        "WAL replay failed at event {idx}: missing node {node_id} for label removal"
+                    ));
+                }
+            }
+            MutationEvent::SetRelationshipProperty { rel_id, key, value } => {
+                if !graph.set_relationship_property(rel_id, key, value) {
+                    return Err(anyhow!(
+                        "WAL replay failed at event {idx}: missing relationship {rel_id} for property set"
+                    ));
+                }
+            }
+            MutationEvent::RemoveRelationshipProperty { rel_id, key } => {
+                if !graph.remove_relationship_property(rel_id, &key) {
+                    return Err(anyhow!(
+                        "WAL replay failed at event {idx}: missing relationship {rel_id} for property removal"
+                    ));
+                }
+            }
+            MutationEvent::DeleteRelationship { rel_id } => {
+                if !graph.delete_relationship(rel_id) {
+                    return Err(anyhow!(
+                        "WAL replay failed at event {idx}: missing relationship {rel_id} for delete"
+                    ));
+                }
+            }
+            MutationEvent::DeleteNode { node_id } => {
+                if !graph.delete_node(node_id) {
+                    return Err(anyhow!(
+                        "WAL replay failed at event {idx}: missing or attached node {node_id} for delete"
+                    ));
+                }
+            }
+            MutationEvent::DetachDeleteNode { node_id } => {
+                // After the cascading DeleteRelationship +
+                // DeleteNode events have already replayed, the node
+                // is gone and this becomes a no-op. Calling it
+                // anyway is harmless.
+                graph.detach_delete_node(node_id);
+            }
+            MutationEvent::Clear => {
+                graph.clear();
+            }
+        }
+    }
+    Ok(())
+}

{lora_python-0.8.0 → lora_python-0.8.1}/crates/lora-database/src/lib.rs

@@ -17,6 +17,7 @@
 mod database;
 mod error;
 mod explain;
+mod live_store;
 mod named;
 mod plan_cache;
 mod snapshot;