lora-ruby 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc78ad82af9cdeddda40129742a043a0a2671a4671ace27e6ed250f10bb81f47
-  data.tar.gz: 409372914f30e7c4d69ad3a4fb70dc328020a0b903c2a0c1d69b64aa61c2358f
+  metadata.gz: c27b39620c0d4484f27a0d1d80ca4bfe85fbf4a7cc9ee85866cdbc15a1f028f0
+  data.tar.gz: 6474c3321d2fef98b602deb92d184778861b4330217ebb882569cd3b828790cc
 SHA512:
-  metadata.gz: 7fb025acfebc7f57a98cb07f745b9ad9ede8cae1532abc4a157d2fd8c0cfc875754299e714b4456dc4f93bed76b10954edb8bc6f5b41012d02f2076510a71ed0
-  data.tar.gz: 884ffd034cd6b174b936bc0c02019e073c4d3106822db1f9f8fa067fd3903a8c9dc619648508d855ee2ab26f522dab6b619c89f35be2d5c9f5fcbbfb2c5496dc
+  metadata.gz: adad8d60ecf6a6df5f7156d0176d43b2981170a57bf7d2239554b94666dd06dcb8ff551c3487025cf2f3812d4465c0f4e5ecd912ed70af97f98474104e742e99
+  data.tar.gz: 63d8a74a82179146ef6dc0c9fc7ff2b30902cee5cda9a44d157953fd61a36b74c4a89a466d4a6f1b4336b2bd6ebcf6ea5dbc14c87a7e527ca999660497f2a90f

data/lib/lora_ruby/version.rb

@@ -10,5 +10,5 @@ module LoraRuby
   # Guard against redefinition so re-requiring this file (or loading
   # both paths) doesn't emit a "warning: already initialized constant"
   # when the native extension loads second with the identical value.
-  VERSION = "0.2.0" unless const_defined?(:VERSION)
+  VERSION = "0.3.0" unless const_defined?(:VERSION)
 end

data/src/lib.rs

@@ -16,7 +16,7 @@
 use std::collections::BTreeMap;
 use std::ffi::c_void;
 use std::mem::MaybeUninit;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 
 use magnus::{
     function, method, prelude::*, r_hash::ForEach, value::ReprValue, Error as MagnusError,
@@ -27,8 +27,8 @@ use lora_database::{
     Database as InnerDatabase, ExecuteOptions, InMemoryGraph, LoraValue, QueryResult, ResultFormat,
 };
 use lora_store::{
-    GraphStorage, LoraDate, LoraDateTime, LoraDuration, LoraLocalDateTime, LoraLocalTime,
-    LoraPoint, LoraTime, LoraVector, RawCoordinate, VectorCoordinateType, VectorValues,
+    LoraDate, LoraDateTime, LoraDuration, LoraLocalDateTime, LoraLocalTime, LoraPoint, LoraTime,
+    LoraVector, RawCoordinate, VectorCoordinateType, VectorValues,
 };
 
 // ============================================================================
@@ -71,6 +71,8 @@ fn init(ruby: &Ruby) -> Result<(), MagnusError> {
     )?;
     database.define_method("inspect", method!(database_inspect, 0))?;
     database.define_method("to_s", method!(database_inspect, 0))?;
+    database.define_method("save_snapshot", method!(database_save_snapshot, 1))?;
+    database.define_method("load_snapshot", method!(database_load_snapshot, 1))?;
 
     // `LoraRuby::VERSION` is owned by `lib/lora_ruby/version.rb` so the
     // gem can expose a version before the native extension compiles
@@ -114,18 +116,18 @@ fn invalid_params(ruby: &Ruby, msg: impl Into<String>) -> MagnusError {
 
 /// In-memory Lora graph database handle exposed to Ruby.
 ///
-/// `Arc<Mutex<InMemoryGraph>>` gives us cheap cloning so the mutex guard
-/// can be sent across the GVL-release boundary without borrowing any Ruby
-/// state.
+/// Wraps an `Arc<Database<InMemoryGraph>>`; the same handle is cloned
+/// across the GVL-release boundary for query execution without borrowing
+/// any Ruby state.
 #[magnus::wrap(class = "LoraRuby::Database", free_immediately, size)]
 struct Database {
-    store: Arc<Mutex<InMemoryGraph>>,
+    db: Arc<InnerDatabase<InMemoryGraph>>,
 }
 
 impl Database {
     fn empty() -> Self {
         Self {
-            store: Arc::new(Mutex::new(InMemoryGraph::new())),
+            db: Arc::new(InnerDatabase::in_memory()),
         }
     }
 }
@@ -142,29 +144,73 @@ fn database_create() -> Database {
 }
 
 fn database_clear(rb_self: &Database) {
-    let mut guard = rb_self.store.lock().unwrap_or_else(|p| p.into_inner());
-    *guard = InMemoryGraph::new();
+    rb_self.db.clear();
 }
 
 fn database_node_count(rb_self: &Database) -> u64 {
-    let guard = rb_self.store.lock().unwrap_or_else(|p| p.into_inner());
-    guard.node_count() as u64
+    rb_self.db.node_count() as u64
 }
 
 fn database_relationship_count(rb_self: &Database) -> u64 {
-    let guard = rb_self.store.lock().unwrap_or_else(|p| p.into_inner());
-    guard.relationship_count() as u64
+    rb_self.db.relationship_count() as u64
 }
 
 fn database_inspect(rb_self: &Database) -> String {
-    let guard = rb_self.store.lock().unwrap_or_else(|p| p.into_inner());
     format!(
         "#<LoraRuby::Database nodes={} relationships={}>",
-        guard.node_count(),
-        guard.relationship_count(),
+        rb_self.db.node_count(),
+        rb_self.db.relationship_count(),
     )
 }
 
+fn database_save_snapshot(
+    ruby: &Ruby,
+    rb_self: &Database,
+    path: RString,
+) -> Result<RHash, MagnusError> {
+    let path = path.to_string()?;
+    let db = Arc::clone(&rb_self.db);
+    let meta = without_gvl(move || db.save_snapshot_to(&path))
+        .map_err(|e| query_error(ruby, format!("{e}")))?;
+    snapshot_meta_to_rhash(ruby, meta)
+}
+
+fn database_load_snapshot(
+    ruby: &Ruby,
+    rb_self: &Database,
+    path: RString,
+) -> Result<RHash, MagnusError> {
+    let path = path.to_string()?;
+    let db = Arc::clone(&rb_self.db);
+    let meta = without_gvl(move || db.load_snapshot_from(&path))
+        .map_err(|e| query_error(ruby, format!("{e}")))?;
+    snapshot_meta_to_rhash(ruby, meta)
+}
+
+fn snapshot_meta_to_rhash(
+    ruby: &Ruby,
+    meta: lora_database::SnapshotMeta,
+) -> Result<RHash, MagnusError> {
+    let h = ruby.hash_new();
+    h.aset(
+        ruby.str_new("formatVersion"),
+        ruby.integer_from_i64(meta.format_version as i64),
+    )?;
+    h.aset(
+        ruby.str_new("nodeCount"),
+        ruby.integer_from_i64(meta.node_count as i64),
+    )?;
+    h.aset(
+        ruby.str_new("relationshipCount"),
+        ruby.integer_from_i64(meta.relationship_count as i64),
+    )?;
+    match meta.wal_lsn {
+        Some(lsn) => h.aset(ruby.str_new("walLsn"), ruby.integer_from_i64(lsn as i64))?,
+        None => h.aset(ruby.str_new("walLsn"), ruby.qnil())?,
+    }
+    Ok(h)
+}
+
 /// `execute(query, params = nil)` — `-1` arity so `params` is optional and
 /// we can distinguish "not passed" from `nil`/`{}` (both map to empty
 /// params). Everything that touches Ruby values happens under the GVL;
@@ -202,9 +248,8 @@ fn database_execute(ruby: &Ruby, rb_self: &Database, args: &[Value]) -> Result<R
     // Run the engine with the GVL released. Everything inside the closure
     // is pure Rust — no Ruby values cross the boundary — which keeps this
     // sound.
-    let store = Arc::clone(&rb_self.store);
+    let db = Arc::clone(&rb_self.db);
     let exec_result = without_gvl(move || {
-        let db = InnerDatabase::new(store);
         let options = ExecuteOptions {
             format: ResultFormat::RowArrays,
         };

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lora-ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - LoraDB, Inc.