lora-ruby 0.29.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47551a1004dd776c2b4b97bc457cee4cc9b37ba969744656d2099fd8f0daa364
-  data.tar.gz: 9a6d6e8c1e0024583163bdc0e3a533b7d3d848f5727636d99f138a1f872eed13
+  metadata.gz: bb92cbbbc1a715c79951f488d065d6651428754bf356fa2ac9b8d184aafa4e2f
+  data.tar.gz: 4246665a896d1ce95590e22a268465b8eed369cf6677a9395e105f566c412dde
 SHA512:
-  metadata.gz: 1d72c4d2c91487ef02d73c5ad2caa7fd816a2a0bc8f14134f77b027bec2fadeea30dd42f3f20ebe6aa5fd5a351bcc7b565d9c899508fb519767dd2dfe281afb0
-  data.tar.gz: f1c81974261b06bc13b9d4219108f77b9aef3d05c77e7241a64fe53695c0aeb3fe47d8584f942c265525f481b3e9856c46fb977509a738d75421e2cf73c5d988
+  metadata.gz: ca2548fae0133815c95cc2d89e1ae76fd3f648ea1251aa26a7821f2952b98acf5628d5bf612fb43cb2795e5aeb90b7f5df2537da1005ef9700f8a8f8b228bcc0
+  data.tar.gz: d8c3f61ee0f03882999b6432674c00d5e120d66a6f4d3737fac2103bdd533c21dd4c1dfc0242cff6722cf8501dca4c83c305f98f1e51edaaee82746c1d53e18e

data/Cargo.toml

@@ -37,6 +37,7 @@ serde_json = { workspace = true }
 anyhow.workspace = true
 
 lora-database.workspace = true
+web-time.workspace = true
 lora-store.workspace = true
 
 [build-dependencies]

data/README.md

@@ -80,9 +80,9 @@ LoraRuby::Database.create(database_name = nil, options = nil)  # -> Database
 LoraRuby::Database.new(database_name = nil, options = nil)     # -> Database
 LoraRuby::Database.open_wal(wal_dir, options = nil)            # -> Database
 
-db.execute(query, params = nil)       # -> { "columns" => [...], "rows" => [...] }
-db.explain(query, params = nil)       # -> plan Hash; never executes
-db.profile(query, params = nil)       # -> { "plan" => ..., "metrics" => ... }; PROFILE executes writes
+db.execute(query, params = nil, timeout_ms: nil)  # -> { "columns" => [...], "rows" => [...] }
+db.explain(query, params = nil)                   # -> plan Hash; never executes
+db.profile(query, params = nil, timeout_ms: nil)  # -> { "plan" => ..., "metrics" => ... }; PROFILE executes writes
 db.clear                              # -> nil
 db.node_count                         # -> Integer
 db.relationship_count                 # -> Integer
@@ -218,12 +218,26 @@ binding has no interactive transactions: each write takes the lock and
 releases it within one call. So a waiting writer never blocks the writer
 holding the lock, however many threads write at once.
 
-The engine has no cancellation hook, so we pass a `NULL` unblock
-function. A thread interrupted mid-query (`Thread#kill`, `Ctrl-C`) will
-observe the interrupt **after** the current call finishes, including a
-write that was still waiting for the writer lock (it runs, then the
-interrupt fires). Keep queries short if you rely on cooperative
-cancellation.
+### Timeouts and interrupts
+
+Pass `timeout_ms:` to bound a query. When the time runs out the query
+stops at its next check point, rolls back any writes, releases its locks,
+and raises `LoraRuby::QueryError` with code `LORA_TIMEOUT`:
+
+```ruby
+db.execute("MATCH (a), (b) RETURN count(*)", nil, timeout_ms: 2_000)
+db.execute("MATCH (n {id: $id}) RETURN n", { id: 1 }, timeout_ms: 500)
+```
+
+A query with `timeout_ms:` can also be interrupted: `Thread#raise`,
+`Thread#kill`, `Timeout.timeout` and `Ctrl-C` cancel it the same way, and
+the interrupt is then raised as usual. A query without `timeout_ms:` runs
+without a deadline (deadline checks cost a little on large scans) and
+observes an interrupt only **after** it finishes.
+
+`timeout_ms` is a reserved keyword: other keywords are still accepted as
+query params (`db.execute(q, name: "Ada")`), but a param named
+`timeout_ms` has to go in an explicit params hash.
 
 ## Local development
 

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.29.0" unless const_defined?(:VERSION)
+  VERSION = "0.30.0" unless const_defined?(:VERSION)
 end

data/src/from_ruby.rs

@@ -228,17 +228,17 @@ fn ruby_hash_to_cypher(ruby: &Ruby, hash: RHash) -> Result<LoraValue, MagnusErro
             }
             "datetime" => {
                 return parse_tagged(ruby, hash, "datetime", |iso| {
-                    LoraDateTime::parse(iso).map(LoraValue::DateTime)
+                    LoraDateTime::parse(iso).map(LoraValue::from)
                 });
             }
             "localdatetime" => {
                 return parse_tagged(ruby, hash, "localdatetime", |iso| {
-                    LoraLocalDateTime::parse(iso).map(LoraValue::LocalDateTime)
+                    LoraLocalDateTime::parse(iso).map(LoraValue::from)
                 });
             }
             "duration" => {
                 return parse_tagged(ruby, hash, "duration", |iso| {
-                    LoraDuration::parse(iso).map(LoraValue::Duration)
+                    LoraDuration::parse(iso).map(LoraValue::from)
                 });
             }
             "point" => return build_point(ruby, hash),
@@ -291,7 +291,7 @@ fn build_point(ruby: &Ruby, hash: RHash) -> Result<LoraValue, MagnusError> {
     let x = read_f64(ruby, hash, "x")?.ok_or_else(|| invalid_params(ruby, "point.x required"))?;
     let y = read_f64(ruby, hash, "y")?.ok_or_else(|| invalid_params(ruby, "point.y required"))?;
     let z = read_f64(ruby, hash, "z")?;
-    Ok(LoraValue::Point(LoraPoint { x, y, z, srid }))
+    Ok(LoraValue::Point(Box::new(LoraPoint { x, y, z, srid })))
 }
 
 fn build_vector(ruby: &Ruby, hash: RHash) -> Result<LoraValue, MagnusError> {
@@ -341,7 +341,7 @@ fn build_vector(ruby: &Ruby, hash: RHash) -> Result<LoraValue, MagnusError> {
 
     let v = LoraVector::try_new(raw, dimension, coordinate_type)
         .map_err(|e| invalid_params(ruby, e.to_string()))?;
-    Ok(LoraValue::Vector(v))
+    Ok(LoraValue::Vector(Box::new(v)))
 }
 
 fn build_binary(ruby: &Ruby, hash: RHash) -> Result<LoraValue, MagnusError> {
@@ -355,7 +355,9 @@ fn build_binary(ruby: &Ruby, hash: RHash) -> Result<LoraValue, MagnusError> {
             .map_err(|_| invalid_params(ruby, "binary.segments entries must be Strings"))?;
         segments.push(unsafe { segment.as_slice().to_vec() });
     }
-    Ok(LoraValue::Binary(LoraBinary::from_segments(segments)))
+    Ok(LoraValue::Binary(Box::new(LoraBinary::from_segments(
+        segments,
+    ))))
 }
 
 fn read_i64(ruby: &Ruby, hash: RHash, key: &str) -> Result<Option<i64>, MagnusError> {

data/src/gvl.rs

@@ -5,6 +5,9 @@ use std::fmt;
 use std::mem::MaybeUninit;
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Mutex;
+
+use lora_database::CancellableDeadline;
 
 /// Calls running with the GVL released right now, process-wide.
 static RELEASED: AtomicUsize = AtomicUsize::new(0);
@@ -81,6 +84,41 @@ impl fmt::Display for GvlPanic {
 /// `database_execute`'s closure is pure Rust on pre-extracted data, so
 /// this is sound.
 pub(crate) fn without_gvl<F, R>(f: F) -> Result<R, GvlPanic>
+where
+    F: FnOnce() -> R,
+    F: Send,
+    R: Send,
+{
+    call_without_gvl(f, None)
+}
+
+/// [`without_gvl`] for a query bounded by `cancel`: when Ruby interrupts
+/// the thread (`Thread#raise`, `Thread#kill`, `Timeout.timeout`, Ctrl-C)
+/// its unblock function cancels the query, which then stops at its next
+/// check point, rolls back, and releases its locks before this returns.
+pub(crate) fn without_gvl_cancellable<F, R>(
+    f: F,
+    cancel: &Mutex<CancellableDeadline>,
+) -> Result<R, GvlPanic>
+where
+    F: FnOnce() -> R,
+    F: Send,
+    R: Send,
+{
+    call_without_gvl(f, Some(cancel))
+}
+
+/// Ruby's unblock function for [`without_gvl_cancellable`]. Runs on the
+/// interrupting thread while the query thread is GVL-free, so it only
+/// touches the (Rust) cancellation state.
+unsafe extern "C" fn cancel_query(data: *mut c_void) {
+    let cancel = &*(data as *const Mutex<CancellableDeadline>);
+    let _ = catch_unwind(AssertUnwindSafe(|| {
+        cancel.lock().unwrap_or_else(|p| p.into_inner()).cancel();
+    }));
+}
+
+fn call_without_gvl<F, R>(f: F, cancel: Option<&Mutex<CancellableDeadline>>) -> Result<R, GvlPanic>
 where
     F: FnOnce() -> R,
     F: Send,
@@ -113,14 +151,21 @@ where
     let _released = Released::enter();
 
     unsafe {
+        // Without a cancellation handle there is no unblock function: the
+        // call cannot be stopped early, and a forced longjmp out of a
+        // mutex-holding section would be worse than waiting.
+        let (ubf, ubf_data) = match cancel {
+            Some(cancel) => (
+                Some(cancel_query as unsafe extern "C" fn(*mut c_void)),
+                cancel as *const Mutex<CancellableDeadline> as *mut c_void,
+            ),
+            None => (None, std::ptr::null_mut()),
+        };
         rb_sys::rb_thread_call_without_gvl(
             Some(trampoline::<F, R>),
             &mut data as *mut _ as *mut c_void,
-            // No unblock function — the engine doesn't implement
-            // cooperative cancellation, and a forced longjmp out of a
-            // mutex-holding section would be worse than waiting.
-            None,
-            std::ptr::null_mut(),
+            ubf,
+            ubf_data,
         );
         data.result.assume_init().map_err(GvlPanic::new)
     }

data/src/lib.rs

@@ -14,7 +14,10 @@
 //! tagged `Hash`es (string keys) with a `"kind"` discriminator.
 
 use std::collections::BTreeMap;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
+use std::thread::JoinHandle;
+use std::time::Duration;
 
 use magnus::{
     function, method, prelude::*, value::ReprValue, Error as MagnusError, RHash, RString, Ruby,
@@ -22,8 +25,9 @@ use magnus::{
 };
 
 use lora_database::{
-    Database as InnerDatabase, DatabaseOpenOptions, ExecuteOptions, InMemoryGraph, QueryResult,
-    ResultFormat, SnapshotConfig, SnapshotOptions, WalConfig,
+    CancellableDeadline, Database as InnerDatabase, DatabaseOpenOptions, ExecuteOptions,
+    InMemoryGraph, LoraError, LoraValue, QueryResult, ResultFormat, SnapshotConfig,
+    SnapshotOptions, WalConfig,
 };
 
 mod errors;
@@ -33,7 +37,7 @@ mod to_ruby;
 
 use errors::{invalid_params, query_error, query_error_from_anyhow};
 use from_ruby::{hash_get_any, read_nonnegative_u64, ruby_optional_to_json, ruby_value_to_params};
-use gvl::without_gvl;
+use gvl::{without_gvl, without_gvl_cancellable};
 use to_ruby::{lora_value_to_ruby, query_plan_to_ruby, query_profile_to_ruby};
 
 // ============================================================================
@@ -83,6 +87,10 @@ fn init(ruby: &Ruby) -> Result<(), MagnusError> {
     database.define_method("save_snapshot", method!(database_save_snapshot, -1))?;
     database.define_method("load_snapshot", method!(database_load_snapshot, -1))?;
 
+    // Wait for databases the GC handed to background droppers before the
+    // process exits, so their WALs are flushed and closed (see `Drop`).
+    unsafe { rb_sys::rb_set_end_proc(Some(finish_background_drops), 0) };
+
     // `LoraRuby::VERSION` is owned by `lib/lora_ruby/version.rb` so the
     // gem can expose a version before the native extension compiles
     // (during `gem build` / `bundle install`). Defining it here too
@@ -141,11 +149,78 @@ impl Database {
     }
 }
 
+/// Drops of persistent databases handed off by the GC, not yet finished.
+static BACKGROUND_DROPS: Mutex<Vec<JoinHandle<()>>> = Mutex::new(Vec::new());
+
+/// Set once the process is exiting: drops then run in place.
+static EXITING: AtomicBool = AtomicBool::new(false);
+
+/// The GC frees an unreachable handle during a sweep, with the GVL held.
+/// Dropping the last handle to a persistent database flushes and closes its
+/// WAL (`fsync`, joining its flusher), which would stall every Ruby thread
+/// for the duration, so that drop moves to a thread of its own, like
+/// `close` runs it GVL-free. An in-memory database, or any drop at exit,
+/// runs in place. Opening a database first waits for pending drops (see
+/// [`wait_background_drops`]) so a reopened WAL directory is free.
+impl Drop for Database {
+    fn drop(&mut self) {
+        let slot = self.db.get_mut().unwrap_or_else(|p| p.into_inner()).take();
+        let Some(db) = slot else { return };
+        if db.wal().is_none() || EXITING.load(Ordering::SeqCst) {
+            return;
+        }
+        let mut pending = BACKGROUND_DROPS.lock().unwrap_or_else(|p| p.into_inner());
+        pending.retain(|handle| !handle.is_finished());
+        // Spawning moves `db` into the closure even when it fails, so a
+        // failed spawn drops it here, in place.
+        if let Ok(handle) = std::thread::Builder::new()
+            .name("lora-ruby-drop".into())
+            .spawn(move || drop(db))
+        {
+            pending.push(handle);
+        }
+    }
+}
+
+/// Join every pending background drop.
+fn join_background_drops() {
+    let pending = std::mem::take(&mut *BACKGROUND_DROPS.lock().unwrap_or_else(|p| p.into_inner()));
+    for handle in pending {
+        let _ = handle.join();
+    }
+}
+
+/// Before opening a database: let GC-dropped databases finish closing, with
+/// the GVL released, so their WAL directories are free again.
+fn wait_background_drops() {
+    let idle = BACKGROUND_DROPS
+        .lock()
+        .map(|pending| pending.iter().all(|h| h.is_finished()))
+        .unwrap_or(false);
+    if idle {
+        BACKGROUND_DROPS
+            .lock()
+            .map(|mut pending| pending.clear())
+            .ok();
+        return;
+    }
+    let _ = without_gvl(join_background_drops);
+}
+
+/// `at_exit` hook: drop in place from now on and wait for pending drops.
+unsafe extern "C" fn finish_background_drops(_data: rb_sys::VALUE) {
+    EXITING.store(true, Ordering::SeqCst);
+    let _ = without_gvl(join_background_drops);
+}
+
 // Constructors — we expose `Database.create` and `Database.new` as
 // singletons so callers can use whichever idiom they prefer; both are
 // cost-equivalent.
 fn database_new(ruby: &Ruby, args: &[Value]) -> Result<Database, MagnusError> {
     let (database_name, options) = database_open_args(ruby, args)?;
+    if database_name.is_some() {
+        wait_background_drops();
+    }
     let db = without_gvl_string_result(ruby, move || open_database(database_name, options))?;
     Ok(Database::from_db(db))
 }
@@ -179,6 +254,7 @@ fn database_open_wal(ruby: &Ruby, args: &[Value]) -> Result<Database, MagnusErro
         ));
     }
     options.wal_dir = Some(wal_dir);
+    wait_background_drops();
     let db = without_gvl_string_result(ruby, move || open_wal_database(options))?;
     Ok(Database::from_db(db))
 }
@@ -499,72 +575,164 @@ where
         .map_err(|e| query_error_from_anyhow(ruby, e))
 }
 
-/// `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;
-/// only the pure-Rust engine call is run GVL-released.
-fn database_execute(ruby: &Ruby, rb_self: &Database, args: &[Value]) -> Result<RHash, MagnusError> {
-    let (query, params_value): (String, Option<Value>) = match args.len() {
-        1 => {
-            let q = RString::try_convert(args[0])?.to_string()?;
-            (q, None)
-        }
-        2 => {
-            let q = RString::try_convert(args[0])?.to_string()?;
-            let p = if args[1].is_nil() {
-                None
-            } else {
-                Some(args[1])
-            };
-            (q, p)
-        }
-        n => {
-            return Err(MagnusError::new(
-                ruby.exception_arg_error(),
-                format!("wrong number of arguments (given {n}, expected 1..2)"),
-            ));
+/// Run `call` with the GVL released. With a `timeout` it runs under a
+/// cancellable deadline: it fails with `LORA_TIMEOUT` once the timeout
+/// passes, and a Ruby interrupt of this thread (`Thread#raise`,
+/// `Thread#kill`, `Timeout.timeout`, Ctrl-C) cancels it. A cancelled query
+/// rolls back and releases its locks; the interrupt is then delivered
+/// instead of the timeout error.
+///
+/// Without a timeout the query runs without a deadline and cannot be
+/// interrupted: the engine reads the clock at every deadline check, which
+/// costs roughly 10% on scans, so plain calls do not pay for it.
+fn run_query<T>(
+    ruby: &Ruby,
+    timeout: Option<Duration>,
+    call: impl FnOnce(Option<web_time::Instant>) -> Result<T, LoraError> + Send,
+) -> Result<T, MagnusError>
+where
+    T: Send,
+{
+    let Some(timeout) = timeout else {
+        return without_gvl_lora_result(ruby, move || call(None));
+    };
+    let cancel = Mutex::new(CancellableDeadline::new(Some(timeout)));
+    let deadline = cancel.lock().unwrap_or_else(|p| p.into_inner()).deadline();
+    let outcome = without_gvl_cancellable(move || call(Some(deadline)), &cancel);
+    if cancel
+        .lock()
+        .unwrap_or_else(|p| p.into_inner())
+        .is_cancelled()
+    {
+        ruby.thread_check_ints()?;
+    }
+    outcome
+        .map_err(|panic| query_error(ruby, panic.to_string()))?
+        .map_err(|e| query_error_from_anyhow(ruby, e))
+}
+
+/// Arguments of `execute` / `profile`: `(query, params = nil, timeout_ms: nil)`.
+struct QueryArgs {
+    query: String,
+    params: Option<BTreeMap<String, LoraValue>>,
+    timeout: Option<Duration>,
+}
+
+/// Parse `(query, params = nil, timeout_ms: nil)`. Keywords other than
+/// `timeout_ms` are query parameters when no positional `params` hash is
+/// given, so `execute(q, name: "Ada")` keeps working.
+fn parse_query_args(ruby: &Ruby, args: &[Value]) -> Result<QueryArgs, MagnusError> {
+    // SAFETY: called from a method body, while Ruby's frame for this
+    // call is current.
+    let keywords_given = unsafe { rb_sys::rb_keyword_given_p() } != 0;
+    let (positional, keywords) = match (keywords_given, args.split_last()) {
+        (true, Some((last, rest))) => (rest, Some(RHash::try_convert(*last)?)),
+        _ => (args, None),
+    };
+    let (query, params_value) = parse_query_params(ruby, positional)?;
+
+    let mut timeout = None;
+    let mut keyword_params = None;
+    if let Some(keywords) = keywords {
+        let timeout_value = keywords.delete(ruby.to_symbol("timeout_ms"))?;
+        timeout = parse_timeout_ms(ruby, timeout_value)?;
+        if !keywords.is_empty() {
+            if params_value.is_some() {
+                return Err(MagnusError::new(
+                    ruby.exception_arg_error(),
+                    "unknown keyword: only timeout_ms is accepted next to a params hash",
+                ));
+            }
+            keyword_params = Some(keywords.as_value());
         }
+    }
+    let params = match params_value.or(keyword_params) {
+        Some(v) => Some(ruby_value_to_params(ruby, v)?),
+        None => None,
+    };
+    Ok(QueryArgs {
+        query,
+        params,
+        timeout,
+    })
+}
+
+/// `timeout_ms:` is `nil` (no timeout) or a positive integer.
+fn parse_timeout_ms(ruby: &Ruby, value: Option<Value>) -> Result<Option<Duration>, MagnusError> {
+    let Some(value) = value.filter(|v| !v.is_nil()) else {
+        return Ok(None);
     };
+    let ms = read_nonnegative_u64(ruby, value)?;
+    if ms == 0 {
+        return Err(invalid_params(
+            ruby,
+            "timeout_ms must be a positive integer",
+        ));
+    }
+    Ok(Some(Duration::from_millis(ms)))
+}
 
+/// `execute(query, params = nil, timeout_ms: 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; only the pure-Rust engine call is run GVL-released.
+fn database_execute(ruby: &Ruby, rb_self: &Database, args: &[Value]) -> Result<RHash, MagnusError> {
     // Parse params while we still hold the GVL — touching Ruby `RHash` /
     // `RArray` from a GVL-released region is undefined behaviour.
-    let params_map = match params_value {
-        Some(v) => ruby_value_to_params(ruby, v)?,
-        None => BTreeMap::new(),
-    };
+    let QueryArgs {
+        query,
+        params,
+        timeout,
+    } = parse_query_args(ruby, args)?;
+    let params_map = params.unwrap_or_default();
 
     // Run the engine with the GVL released. Everything inside the closure
     // is pure Rust — no Ruby values cross the boundary — which keeps this
-    // sound.
+    // sound. `Rows` hands back the engine's rows without the per-cell
+    // clones of the `RowArrays` projection; the columns are the first
+    // row's names, exactly as `RowArrays` infers them.
     let db = database_inner(ruby, rb_self)?;
-    let exec_result = without_gvl_lora_result(ruby, move || {
-        let options = ExecuteOptions {
-            format: ResultFormat::RowArrays,
-        };
-        db.execute_with_params(&query, Some(options), params_map)
+    let exec_result = run_query(ruby, timeout, move |deadline| {
+        let options = Some(ExecuteOptions {
+            format: ResultFormat::Rows,
+        });
+        match deadline {
+            Some(deadline) => {
+                db.execute_with_params_deadline(&query, options, params_map, deadline)
+            }
+            None => db.execute_with_params(&query, options, params_map),
+        }
     })?;
 
-    let row_arrays = match exec_result {
-        QueryResult::RowArrays(r) => r,
-        _ => return Err(query_error(ruby, "expected RowArrays result")),
+    let rows = match exec_result {
+        QueryResult::Rows(r) => r.rows,
+        _ => return Err(query_error(ruby, "expected Rows result")),
     };
 
     let out = ruby.hash_new();
     let columns = ruby.ary_new();
-    for c in &row_arrays.columns {
-        columns.push(ruby.str_new(c))?;
+    let mut column_names = Vec::new();
+    if let Some(first) = rows.first() {
+        for (_, name, _) in first.iter_named() {
+            columns.push(ruby.str_new(&name))?;
+            // A frozen key is stored as is; an unfrozen one would be
+            // copied and frozen again for every row.
+            let key = ruby.str_new(&name);
+            key.freeze();
+            column_names.push(key);
+        }
     }
     out.aset(ruby.str_new("columns"), columns)?;
 
-    let rows = ruby.ary_new();
-    for row in &row_arrays.rows {
+    let rows_out = ruby.ary_new_capa(rows.len());
+    for row in &rows {
         let row_hash = ruby.hash_new();
-        for (col, val) in row_arrays.columns.iter().zip(row.iter()) {
-            row_hash.aset(ruby.str_new(col), lora_value_to_ruby(ruby, val)?)?;
+        for (name, (_, val)) in column_names.iter().zip(row.iter()) {
+            row_hash.aset(*name, lora_value_to_ruby(ruby, val)?)?;
         }
-        rows.push(row_hash)?;
+        rows_out.push(row_hash)?;
     }
-    out.aset(ruby.str_new("rows"), rows)?;
+    out.aset(ruby.str_new("rows"), rows_out)?;
     Ok(out)
 }
 
@@ -582,20 +750,22 @@ fn database_explain(ruby: &Ruby, rb_self: &Database, args: &[Value]) -> Result<R
     query_plan_to_ruby(ruby, &plan)
 }
 
-/// `profile(query, params = nil)` — execute a query and return the plan
+/// `profile(query, params = nil, timeout_ms: nil)` — execute a query and return the plan
 /// plus runtime metrics as a Ruby `Hash`.
 ///
 /// **PROFILE executes the query for real.** Mutating queries are
 /// persisted exactly as in `execute`. Use `explain` to inspect a
 /// mutating plan without running it.
 fn database_profile(ruby: &Ruby, rb_self: &Database, args: &[Value]) -> Result<RHash, MagnusError> {
-    let (query, params_value) = parse_query_params(ruby, args)?;
-    let params_map = match params_value {
-        Some(v) => Some(ruby_value_to_params(ruby, v)?),
-        None => None,
-    };
+    let QueryArgs {
+        query,
+        params,
+        timeout,
+    } = parse_query_args(ruby, args)?;
     let db = database_inner(ruby, rb_self)?;
-    let prof = without_gvl_lora_result(ruby, move || db.profile(&query, params_map))?;
+    let prof = run_query(ruby, timeout, move |deadline| {
+        db.profile_with_deadline(&query, params, deadline)
+    })?;
     query_profile_to_ruby(ruby, &prof)
 }
 

metadata

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