lora-python 0.13.0__tar.gz → 0.14.0__tar.gz

{lora_python-0.13.0 → lora_python-0.14.0}/Cargo.lock

@@ -773,7 +773,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "lora-ast",
  "lora-builtins-meta",
@@ -784,14 +784,14 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-binding-buffer"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "lora-database",
  "lora-store",
@@ -799,11 +799,11 @@ dependencies = [
 
 [[package]]
 name = "lora-builtins-meta"
-version = "0.13.0"
+version = "0.14.0"
 
 [[package]]
 name = "lora-compiler"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -812,7 +812,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "chacha20poly1305",
@@ -837,7 +837,7 @@ dependencies = [
 
 [[package]]
 name = "lora-executor"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "blake3",
  "crc32fast",
@@ -860,7 +860,7 @@ dependencies = [
 
 [[package]]
 name = "lora-ffi"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -872,7 +872,7 @@ dependencies = [
 
 [[package]]
 name = "lora-io"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "lora-executor",
  "lora-store",
@@ -883,7 +883,7 @@ dependencies = [
 
 [[package]]
 name = "lora-node"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -898,7 +898,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "lora-ast",
  "pest",
@@ -909,7 +909,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -921,7 +921,7 @@ dependencies = [
 
 [[package]]
 name = "lora-query-wasm"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
@@ -935,7 +935,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "axum",
@@ -945,11 +945,12 @@ dependencies = [
  "serde_json",
  "tokio",
  "tower",
+ "tracing",
 ]
 
 [[package]]
 name = "lora-snapshot"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "argon2",
  "blake3",
@@ -964,7 +965,7 @@ dependencies = [
 
 [[package]]
 name = "lora-store"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "crc32fast",
  "js-sys",
@@ -975,7 +976,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wal"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "crc32fast",
  "lora-store",
@@ -985,7 +986,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -1001,7 +1002,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "lora-database",

{lora_python-0.13.0 → lora_python-0.14.0}/Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.13.0"
+version = "0.14.0"
 license = "BUSL-1.1"
 authors = ["LoraDB, Inc."]
 repository = "https://github.com/lora-db/lora"
@@ -15,18 +15,18 @@ 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.13.0" }
-lora-parser = { path = "crates/lora-parser", version = "=0.13.0" }
-lora-builtins-meta = { path = "crates/lora-builtins-meta", version = "=0.13.0" }
-lora-analyzer = { path = "crates/lora-analyzer", version = "=0.13.0" }
-lora-compiler = { path = "crates/lora-compiler", version = "=0.13.0" }
-lora-store = { path = "crates/lora-store", version = "=0.13.0" }
-lora-snapshot = { path = "crates/lora-snapshot", version = "=0.13.0", default-features = false }
-lora-io = { path = "crates/lora-io", version = "=0.13.0" }
-lora-wal = { path = "crates/lora-wal", version = "=0.13.0" }
-lora-executor = { path = "crates/lora-executor", version = "=0.13.0", default-features = false }
-lora-database = { path = "crates/lora-database", version = "=0.13.0" }
-lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.13.0" }
+lora-ast = { path = "crates/lora-ast", version = "=0.14.0" }
+lora-parser = { path = "crates/lora-parser", version = "=0.14.0" }
+lora-builtins-meta = { path = "crates/lora-builtins-meta", version = "=0.14.0" }
+lora-analyzer = { path = "crates/lora-analyzer", version = "=0.14.0" }
+lora-compiler = { path = "crates/lora-compiler", version = "=0.14.0" }
+lora-store = { path = "crates/lora-store", version = "=0.14.0" }
+lora-snapshot = { path = "crates/lora-snapshot", version = "=0.14.0", default-features = false }
+lora-io = { path = "crates/lora-io", version = "=0.14.0" }
+lora-wal = { path = "crates/lora-wal", version = "=0.14.0" }
+lora-executor = { path = "crates/lora-executor", version = "=0.14.0", default-features = false }
+lora-database = { path = "crates/lora-database", version = "=0.14.0" }
+lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.14.0" }
 
 # External crates.
 anyhow = "1"
@@ -37,7 +37,7 @@ tokio = "1"
 smallvec = "2.0.0-alpha.12"
 pest = "2"
 pest_derive = "2"
-serde = { version = "1", features = ["derive"] }
+serde = { version = "1", features = ["derive", "rc"] }
 serde_json = "1.0.149"
 regex = "1"
 unicode-normalization = "0.1"

{lora_python-0.13.0 → lora_python-0.14.0}/PKG-INFO

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

{lora_python-0.13.0 → lora_python-0.14.0}/crates/bindings/lora-python/src/errors.rs

@@ -43,7 +43,11 @@ create_exception!(
 /// the same path.
 pub(crate) fn lora_query_err_from_anyhow(err: impl Into<EngineLoraError>) -> PyErr {
     let lora = err.into();
-    LoraQueryError::new_err(format!("{}: {}", lora.code().as_str(), lora.message()))
+    LoraQueryError::new_err(format!(
+        "{}: {}",
+        lora.code().as_str(),
+        lora.public_message()
+    ))
 }
 
 /// Borrowed-by-reference variant for call sites that don't have an
@@ -51,7 +55,11 @@ pub(crate) fn lora_query_err_from_anyhow(err: impl Into<EngineLoraError>) -> PyE
 #[allow(dead_code)]
 pub(crate) fn lora_query_err_from_anyhow_ref(err: &anyhow::Error) -> PyErr {
     let lora = EngineLoraError::from_anyhow_ref(err);
-    LoraQueryError::new_err(format!("{}: {}", lora.code().as_str(), lora.message()))
+    LoraQueryError::new_err(format!(
+        "{}: {}",
+        lora.code().as_str(),
+        lora.public_message()
+    ))
 }
 
 /// Build a [`LoraQueryError`] for a binding-side message that doesn't

{lora_python-0.13.0 → lora_python-0.14.0}/crates/lora-database/Cargo.toml

@@ -89,3 +89,7 @@ harness = false
 [[bench]]
 name = "index_acceleration"
 harness = false
+
+[[bench]]
+name = "memory"
+harness = false

lora_python-0.14.0/crates/lora-database/benches/memory.rs

@@ -0,0 +1,162 @@
+//! Memory-footprint benchmark for `InMemoryGraph`.
+//!
+//! Run with: `cargo bench -p lora-database --bench memory`
+//!
+//! Unlike the other benches in this directory, this one is *not* a
+//! latency benchmark. It builds representative graph shapes, walks
+//! the new [`MemoryReport`] estimator over each, and prints a
+//! `grep`-friendly summary so a future regression gate can diff two
+//! runs without having to re-derive the methodology.
+//!
+//! Output format (one line per scenario):
+//!
+//! ```text
+//! memreport scenario=chain_100k nodes=100000 rels=99999 \
+//!   total=NNNN graph=NNNN nodes_bytes=NNNN ... bytes_per_node=NNN.N
+//! ```
+//!
+//! The Criterion harness is used only to wire `cargo bench --bench
+//! memory` into the existing workflow; per-scenario timing is *not*
+//! the headline metric (we ignore the iteration count and
+//! re-construct the dataset for every iter to surface allocator
+//! noise, not to micro-measure construction speed).
+
+mod fixtures;
+
+use criterion::{criterion_group, criterion_main, Criterion};
+use fixtures::{
+    build_chain, build_node_graph, build_social_graph, build_star, build_vector_graph, BenchDb,
+};
+use lora_database::{InMemoryGraph, MemoryReport};
+use std::collections::BTreeMap;
+use std::time::Duration;
+
+fn bench_config() -> Criterion {
+    Criterion::default()
+        .warm_up_time(Duration::from_millis(50))
+        .measurement_time(Duration::from_millis(200))
+        .sample_size(10)
+}
+
+/// Render one scenario's report as a `memreport` line. Keep the key
+/// order stable so future tooling can `awk` over it.
+fn print_report(scenario: &str, db: &BenchDb) {
+    let report: MemoryReport = db
+        .service
+        .with_store(|s: &InMemoryGraph| s.memory_estimate());
+
+    // Capture the breakdown via the public field set so any future
+    // additions to `MemoryReport` show up in the output the next time
+    // the bench is regenerated.
+    let mut kv: BTreeMap<&str, u128> = BTreeMap::new();
+    kv.insert("total", report.total_bytes() as u128);
+    kv.insert("graph", report.graph_core_bytes() as u128);
+    kv.insert("indexes", report.secondary_index_bytes() as u128);
+    kv.insert("catalogs", report.catalog_bytes() as u128);
+    kv.insert("nodes_bytes", report.nodes_bytes as u128);
+    kv.insert("rels_bytes", report.relationships_bytes as u128);
+    kv.insert("outgoing_bytes", report.outgoing_bytes as u128);
+    kv.insert("incoming_bytes", report.incoming_bytes as u128);
+    kv.insert("label_index_bytes", report.label_index_bytes as u128);
+    kv.insert("type_index_bytes", report.type_index_bytes as u128);
+    kv.insert("property_index_bytes", report.property_index_bytes as u128);
+    kv.insert("sorted_index_bytes", report.sorted_index_bytes as u128);
+    kv.insert("text_index_bytes", report.text_index_bytes as u128);
+    kv.insert("point_index_bytes", report.point_index_bytes as u128);
+    kv.insert("fulltext_index_bytes", report.fulltext_index_bytes as u128);
+    kv.insert("vector_index_bytes", report.vector_index_bytes as u128);
+
+    let mut line = format!(
+        "memreport scenario={} nodes={} rels={} tomb_nodes={} tomb_rels={}",
+        scenario,
+        report.live_node_count,
+        report.live_relationship_count,
+        report.node_tombstone_count,
+        report.relationship_tombstone_count,
+    );
+    for (k, v) in &kv {
+        line.push_str(&format!(" {k}={v}"));
+    }
+    line.push_str(&format!(
+        " bytes_per_node={:.1} bytes_per_rel={:.1}",
+        report.bytes_per_live_node(),
+        report.bytes_per_live_relationship(),
+    ));
+    println!("{line}");
+}
+
+/// Build a graph and run the documented workloads, capturing both
+/// the post-build report and a post-query report — peak-bytes
+/// regression candidates live in the difference, not the absolute
+/// value.
+fn print_with_query(scenario: &str, db: &BenchDb, query: &str) {
+    print_report(&format!("{scenario}.build"), db);
+    let _ = db.service.execute(query, None).unwrap();
+    print_report(&format!("{scenario}.after_query"), db);
+}
+
+fn bench_memory(c: &mut Criterion) {
+    let mut group = c.benchmark_group("memory_estimate");
+
+    // ---- isolated nodes ----
+    {
+        let db = build_node_graph(10_000);
+        print_report("node_only_10k", &db);
+        group.bench_function("node_only_10k_estimate", |b| {
+            b.iter(|| {
+                let _ = db
+                    .service
+                    .with_store(|s: &InMemoryGraph| s.memory_estimate());
+            });
+        });
+    }
+
+    // ---- chains (1 edge / node) ----
+    for &n in &[1_000usize, 10_000, 100_000] {
+        let db = build_chain(n);
+        print_with_query(
+            &format!("chain_{n}"),
+            &db,
+            "MATCH (n:Chain) RETURN count(n) AS c",
+        );
+    }
+
+    // ---- hub-and-spoke (star) ----
+    for &spokes in &[1_000usize, 10_000, 100_000] {
+        let db = build_star(spokes);
+        print_with_query(
+            &format!("star_{spokes}"),
+            &db,
+            "MATCH (h:Hub)-[:ARM]->(s) RETURN count(s) AS c",
+        );
+    }
+
+    // ---- social graph (mixed fanout + properties) ----
+    {
+        let db = build_social_graph(20_000, 8);
+        print_with_query(
+            "social_20k_x8",
+            &db,
+            "MATCH (a:Person)-[:KNOWS]->(b) RETURN count(b) AS c",
+        );
+    }
+
+    // ---- vector workloads ----
+    {
+        let db = build_vector_graph(5_000, 128, "cosine", "flat");
+        print_report("vector_flat_5k_d128", &db);
+    }
+    {
+        let db = build_vector_graph(5_000, 128, "cosine", "hnsw");
+        print_report("vector_hnsw_5k_d128", &db);
+    }
+
+    group.finish();
+}
+
+criterion_group!(
+    name = benches;
+    config = bench_config();
+    targets = bench_memory
+);
+criterion_main!(benches);

lora_python-0.14.0/crates/lora-database/benches/memory_baseline.json

@@ -0,0 +1,66 @@
+{
+  "_meta": {
+    "default_tolerance_pct": 10,
+    "last_updated": "2026-05-23",
+    "notes": "Captured from `cargo bench -p lora-database --bench memory -- --quick` on Apple Silicon. Numbers are bytes from `MemoryReport::total_bytes()` after the build phase (or after_query for chain/star/social which run a representative MATCH after building). Tolerance is per-scenario; a regression beyond `total * (1 + tolerance_pct/100)` fails the gate. Bump the baseline whenever an intentional storage-shape change shifts a scenario."
+  },
+  "benchmarks": {
+    "node_only_10k": {
+      "total_bytes": 4896966,
+      "bytes_per_node": 428.9,
+      "tolerance_pct": 10
+    },
+    "chain_1000.build": {
+      "total_bytes": 665387,
+      "bytes_per_node": 213.0,
+      "bytes_per_rel": 100.0,
+      "tolerance_pct": 10
+    },
+    "chain_10000.build": {
+      "total_bytes": 5834195,
+      "bytes_per_node": 213.0,
+      "bytes_per_rel": 100.0,
+      "tolerance_pct": 10
+    },
+    "chain_100000.build": {
+      "total_bytes": 57764195,
+      "bytes_per_node": 213.0,
+      "bytes_per_rel": 100.0,
+      "tolerance_pct": 10
+    },
+    "star_1000.build": {
+      "total_bytes": 416075,
+      "bytes_per_node": 212.0,
+      "bytes_per_rel": 99.0,
+      "tolerance_pct": 10
+    },
+    "star_10000.build": {
+      "total_bytes": 4102499,
+      "bytes_per_node": 212.0,
+      "bytes_per_rel": 99.0,
+      "tolerance_pct": 10
+    },
+    "star_100000.build": {
+      "total_bytes": 41452499,
+      "bytes_per_node": 212.0,
+      "bytes_per_rel": 99.0,
+      "tolerance_pct": 10
+    },
+    "social_20k_x8.build": {
+      "total_bytes": 53593249,
+      "bytes_per_node": 543.6,
+      "bytes_per_rel": 205.0,
+      "tolerance_pct": 10
+    },
+    "vector_flat_5k_d128": {
+      "total_bytes": 6829412,
+      "bytes_per_node": 721.0,
+      "tolerance_pct": 10
+    },
+    "vector_hnsw_5k_d128": {
+      "total_bytes": 10459212,
+      "bytes_per_node": 721.0,
+      "tolerance_pct": 15
+    }
+  }
+}

{lora_python-0.13.0 → lora_python-0.14.0}/crates/lora-database/src/database/execute.rs

@@ -75,10 +75,9 @@ where
     ///    mutation record, and `TxCommit` only when mutations occurred,
     ///    then applies the WAL's configured single-thread flush policy.
     /// 4. On Err, `recorder.abort()` clears the pending batch. The
-    ///    engine has no rollback, so the in-memory state may already
-    ///    be partially mutated; the live handle is quarantined while
-    ///    durable recovery stays atomic because no committed batch was
-    ///    written.
+    ///    staged graph is discarded without publishing, so the live
+    ///    in-memory state and durable WAL both remain at the last
+    ///    successful commit.
     /// 5. The recorder's poisoned flag is polled once. If set, the query
     ///    fails loudly with the durability error so the caller can act on it;
     ///    the WAL refuses further appends until the operator restarts the

{lora_python-0.13.0 → lora_python-0.14.0}/crates/lora-database/src/database/graph_api.rs

@@ -62,7 +62,7 @@ where
             store.node_properties(id).map(|props| {
                 props
                     .into_iter()
-                    .map(|(key, value)| (key, LoraValue::from(value)))
+                    .map(|(key, value)| (key.to_string(), LoraValue::from(value)))
                     .collect()
             })
         })
@@ -112,7 +112,7 @@ where
             store.relationship_properties(id).map(|props| {
                 props
                     .into_iter()
-                    .map(|(key, value)| (key, LoraValue::from(value)))
+                    .map(|(key, value)| (key.to_string(), LoraValue::from(value)))
                     .collect()
             })
         })
@@ -186,7 +186,7 @@ where
         key: &str,
         value: LoraValue,
     ) -> Result<Vec<NodeId>> {
-        let value = lora_value_to_property(value).map_err(|e| anyhow!(e))?;
+        let value = lora_value_to_property(value).map_err(anyhow::Error::from)?;
         Ok(self.with_store(|store| store.find_node_ids_by_property(label, key, &value)))
     }
 
@@ -196,7 +196,7 @@ where
         key: &str,
         value: LoraValue,
     ) -> Result<Vec<RelationshipId>> {
-        let value = lora_value_to_property(value).map_err(|e| anyhow!(e))?;
+        let value = lora_value_to_property(value).map_err(anyhow::Error::from)?;
         Ok(self.with_store(|store| store.find_relationship_ids_by_property(rel_type, key, &value)))
     }
 
@@ -208,8 +208,12 @@ where
         properties: BTreeMap<String, LoraValue>,
     ) -> Result<NodeRecord, LoraError> {
         let properties = values_to_properties(properties).map_err(LoraError::from_anyhow)?;
-        self.with_logged_store_mut(|store| Ok(store.create_node(labels, properties)))
-            .map_err(LoraError::from_anyhow)
+        self.with_logged_store_mut(|store| {
+            store
+                .try_create_node(labels, properties)
+                .ok_or_else(|| anyhow!("failed to create node because storage is exhausted"))
+        })
+        .map_err(LoraError::from_anyhow)
     }
 
     pub fn graph_create_relationship(
@@ -232,7 +236,7 @@ where
         key: String,
         value: LoraValue,
     ) -> Result<bool, LoraError> {
-        let value = lora_value_to_property(value).map_err(|e| anyhow!(e))?;
+        let value = lora_value_to_property(value).map_err(anyhow::Error::from)?;
         self.with_logged_store_mut(|store| Ok(store.set_node_property(node_id, key, value)))
             .map_err(LoraError::from_anyhow)
     }
@@ -291,7 +295,7 @@ where
         key: String,
         value: LoraValue,
     ) -> Result<bool, LoraError> {
-        let value = lora_value_to_property(value).map_err(|e| anyhow!(e))?;
+        let value = lora_value_to_property(value).map_err(anyhow::Error::from)?;
         self.with_logged_store_mut(|store| Ok(store.set_relationship_property(rel_id, key, value)))
             .map_err(LoraError::from_anyhow)
     }

{lora_python-0.13.0 → lora_python-0.14.0}/crates/lora-database/src/database/mod.rs

@@ -2,7 +2,7 @@ use std::any::Any;
 use std::collections::BTreeMap;
 use std::sync::{Arc, Mutex};
 
-use anyhow::{anyhow, Result};
+use anyhow::{Error, Result};
 use lora_ast::{Direction, Document};
 use lora_executor::{lora_value_to_property, ExecuteOptions, LoraValue, QueryResult};
 use lora_parser::parse_query;
@@ -48,6 +48,24 @@ pub trait QueryRunner: Send + Sync + 'static {
         options: Option<ExecuteOptions>,
     ) -> Result<QueryResult, LoraError>;
 
+    /// Execute a query with bound parameters. Implementors that cannot bind
+    /// parameters should reject non-empty maps instead of silently ignoring
+    /// them.
+    fn execute_with_params(
+        &self,
+        query: &str,
+        options: Option<ExecuteOptions>,
+        params: BTreeMap<String, LoraValue>,
+    ) -> Result<QueryResult, LoraError> {
+        if params.is_empty() {
+            return self.execute(query, options);
+        }
+        Err(LoraError::new(
+            crate::error::LoraErrorCode::InvalidParams,
+            "query parameters are not supported by this database runner",
+        ))
+    }
+
     /// Compile a query and return its plan without executing it.
     fn explain(
         &self,
@@ -130,8 +148,8 @@ pub(crate) fn values_to_properties(values: BTreeMap<String, LoraValue>) -> Resul
     values
         .into_iter()
         .map(|(key, value)| {
-            let value = lora_value_to_property(value).map_err(|e| anyhow!(e))?;
-            Ok((key, value))
+            let value = lora_value_to_property(value).map_err(Error::from)?;
+            Ok((lora_store::intern_owned(key), value))
         })
         .collect()
 }
@@ -260,20 +278,22 @@ where
         f(&*snapshot)
     }
 
-    /// 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 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.
+    /// Run a closure with an exclusive borrow of a staged store, then publish
+    /// it atomically after the closure returns. Reserved for admin paths;
+    /// regular mutation goes through `execute_with_params`.
+    ///
+    /// If the closure panics, the staged copy is dropped and the live store is
+    /// left untouched.
     pub fn with_store_mut<R>(&self, f: impl FnOnce(&mut S) -> R) -> R {
-        let _lock = self
+        let _writer_lock = self
             .writer
             .lock()
             .unwrap_or_else(|poisoned| poisoned.into_inner());
-        let mut handle = self.store.write();
-        f(handle.as_mut())
+        let snapshot = self.store.load_full();
+        let mut staged: S = (*snapshot).clone();
+        let result = f(&mut staged);
+        self.store.store(Arc::new(staged));
+        result
     }
 }
 
@@ -289,6 +309,15 @@ where
         Database::execute(self, query, options)
     }
 
+    fn execute_with_params(
+        &self,
+        query: &str,
+        options: Option<ExecuteOptions>,
+        params: BTreeMap<String, LoraValue>,
+    ) -> Result<QueryResult, LoraError> {
+        Database::execute_with_params(self, query, options, params)
+    }
+
     fn explain(
         &self,
         query: &str,