lora-python 0.21.0__tar.gz → 0.22.0__tar.gz

{lora_python-0.21.0 → lora_python-0.22.0}/Cargo.lock

@@ -854,7 +854,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "lora-ast",
  "lora-builtins-meta",
@@ -865,14 +865,14 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-binding-buffer"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "lora-database",
  "lora-store",
@@ -880,11 +880,11 @@ dependencies = [
 
 [[package]]
 name = "lora-builtins-meta"
-version = "0.21.0"
+version = "0.22.0"
 
 [[package]]
 name = "lora-compiler"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -893,7 +893,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "anyhow",
  "chacha20poly1305",
@@ -918,7 +918,7 @@ dependencies = [
 
 [[package]]
 name = "lora-executor"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "blake3",
  "crc32fast",
@@ -941,7 +941,7 @@ dependencies = [
 
 [[package]]
 name = "lora-ffi"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -953,7 +953,7 @@ dependencies = [
 
 [[package]]
 name = "lora-io"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "lora-executor",
  "lora-store",
@@ -964,7 +964,7 @@ dependencies = [
 
 [[package]]
 name = "lora-node"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -979,7 +979,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "lora-ast",
  "pest",
@@ -990,7 +990,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -1003,7 +1003,7 @@ dependencies = [
 
 [[package]]
 name = "lora-query-wasm"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
@@ -1017,7 +1017,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "anyhow",
  "axum",
@@ -1032,7 +1032,7 @@ dependencies = [
 
 [[package]]
 name = "lora-snapshot"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "argon2",
  "blake3",
@@ -1047,7 +1047,7 @@ dependencies = [
 
 [[package]]
 name = "lora-store"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "crc32fast",
  "jiff",
@@ -1062,7 +1062,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wal"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "crc32fast",
  "lora-store",
@@ -1072,7 +1072,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -1088,7 +1088,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.21.0"
+version = "0.22.0"
 dependencies = [
  "anyhow",
  "lora-database",

{lora_python-0.21.0 → lora_python-0.22.0}/Cargo.toml

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

{lora_python-0.21.0 → lora_python-0.22.0}/PKG-INFO

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

lora_python-0.22.0/crates/lora-database/tests/timeouts.rs

@@ -0,0 +1,211 @@
+//! Query deadlines and cancellation reach every execution path.
+//!
+//! Regression coverage for two gaps: writes whose input runs on the pull
+//! pipeline never checked their deadline, and a bounded write that timed
+//! out on the in-place fast path could leave a partial write behind.
+
+mod test_helpers;
+
+use std::collections::BTreeMap;
+use std::time::{Duration, Instant};
+
+use lora_database::{CancellableDeadline, LoraErrorCode};
+use test_helpers::TestDb;
+
+const N: usize = 20_000;
+
+fn seeded() -> TestDb {
+    let db = TestDb::new();
+    db.run(&format!("UNWIND range(1, {N}) AS i CREATE (:A {{i: i}})"));
+    db.run(&format!("UNWIND range(1, {N}) AS i CREATE (:B {{i: i}})"));
+    db
+}
+
+fn timed_out(db: &TestDb, query: &str, timeout: Duration) -> Duration {
+    let start = Instant::now();
+    let err = db
+        .service
+        .execute_with_params_timeout(query, None, BTreeMap::new(), timeout)
+        .expect_err("query should time out");
+    assert_eq!(err.code(), LoraErrorCode::Timeout, "{err}");
+    start.elapsed()
+}
+
+#[test]
+fn streaming_write_honours_its_deadline_and_leaves_nothing() {
+    let db = seeded();
+    // CREATE over a 4e8-row cartesian product runs on the pull pipeline.
+    let took = timed_out(
+        &db,
+        "MATCH (a:A), (b:B) CREATE (:Pair)",
+        Duration::from_millis(50),
+    );
+    assert!(took < Duration::from_secs(2), "took {took:?}");
+    db.assert_count("MATCH (p:Pair) RETURN p", 0);
+    // The writer lock was released.
+    db.run("CREATE (:After)");
+    db.assert_count("MATCH (x:After) RETURN x", 1);
+}
+
+#[test]
+fn filter_that_never_yields_still_times_out() {
+    let db = seeded();
+    // The condition reads both variables, so it cannot be pushed down to
+    // either scan (a lone `a.i = -1` now becomes an empty index seek) and
+    // the filter really does reject all 4e8 rows of the product.
+    let took = timed_out(
+        &db,
+        "MATCH (a:A), (b:B) WHERE a.i + b.i = -1 SET a.hit = true",
+        Duration::from_millis(50),
+    );
+    assert!(took < Duration::from_secs(2), "took {took:?}");
+}
+
+#[test]
+fn cancellation_stops_a_running_query() {
+    let db = std::sync::Arc::new(seeded());
+    let mut handle = CancellableDeadline::new(None);
+    let deadline = handle.deadline();
+    let shared = db.clone();
+    let worker = std::thread::spawn(move || {
+        let service = &shared.service;
+        service.execute_with_params_deadline(
+            "MATCH (a:A), (b:B) RETURN count(*) AS c",
+            None,
+            BTreeMap::new(),
+            deadline,
+        )
+    });
+    std::thread::sleep(Duration::from_millis(50));
+    let start = Instant::now();
+    handle.cancel();
+    let err = worker
+        .join()
+        .unwrap()
+        .expect_err("cancelled query must fail");
+    assert_eq!(err.code(), LoraErrorCode::Timeout);
+    assert!(start.elapsed() < Duration::from_secs(2));
+}
+
+// ---------------------------------------------------------------------------
+// Deadlines inside expression evaluation
+// ---------------------------------------------------------------------------
+//
+// `@loradb/lora-graphql` compiles relationship-filter quantifiers to
+// `size([(a)-[:R]->(b) WHERE <pred> | 1]) > 0`, nested for nested filters.
+// Those comprehensions run inside one expression evaluation, below the
+// operator boundaries the pipeline checks, so a three-level nested filter
+// once ran 15 s past a 1 s deadline and returned rows.
+
+/// ~5k festivals, ~2k users, ~23k user->festival and ~4k user->user
+/// FOLLOWS edges, spread deterministically.
+fn follows_graph() -> TestDb {
+    let db = TestDb::new();
+    db.run("CREATE INDEX FOR (n:Festival) ON (n.i)");
+    db.run("CREATE INDEX FOR (n:User) ON (n.i)");
+    db.run("UNWIND range(0, 4999) AS i CREATE (:Festival {i: i, key: 'f' + toString(i)})");
+    db.run(
+        "UNWIND range(0, 1999) AS i \
+         CREATE (:User {i: i, key: 'u' + toString(i), name: 'user ' + toString(i)})",
+    );
+    db.run(
+        "UNWIND range(0, 22999) AS i \
+         MATCH (u:User {i: (i * 7919) % 2000}), (f:Festival {i: (i * 104729) % 5000}) \
+         CREATE (u)-[:FOLLOWS]->(f)",
+    );
+    db.run(
+        "UNWIND range(0, 3999) AS i \
+         MATCH (a:User {i: (i * 7919) % 2000}), (b:User {i: (i * 6007 + 1) % 2000}) \
+         CREATE (a)-[:FOLLOWS]->(b)",
+    );
+    db
+}
+
+/// No user name contains 'zz', so every level of the nested filter runs
+/// to completion: about a second of work in a release build.
+const NESTED_FILTER: &str = "MATCH (f:Festival) \
+     WHERE size([(f)<-[:FOLLOWS]-(u:User) \
+       WHERE size([(u)-[:FOLLOWS]->(g:Festival) \
+         WHERE size([(g)<-[:FOLLOWS]-(w:User) WHERE w.name CONTAINS 'zz' | 1]) > 0 \
+       | 1]) > 0 \
+     | 1]) > 0 \
+     RETURN f.key";
+
+#[test]
+fn nested_pattern_comprehension_honours_its_deadline() {
+    let db = follows_graph();
+    let timeout = Duration::from_millis(150);
+    // Without a LIMIT the read runs on the buffered executor, whose filter
+    // loop never checked the deadline; with one it streams. Both must stop.
+    for query in [
+        NESTED_FILTER.to_string(),
+        format!("{NESTED_FILTER} ORDER BY f.key LIMIT 10"),
+        format!("{NESTED_FILTER} LIMIT 1"),
+    ] {
+        let took = timed_out(&db, &query, timeout);
+        assert!(
+            took < timeout + Duration::from_millis(150),
+            "{query}: took {took:?} for a {timeout:?} deadline"
+        );
+    }
+}
+
+#[test]
+fn nested_pattern_comprehension_stops_on_cancel() {
+    let db = std::sync::Arc::new(follows_graph());
+    let mut handle = CancellableDeadline::new(None);
+    let deadline = handle.deadline();
+    let shared = db.clone();
+    let worker = std::thread::spawn(move || {
+        shared
+            .service
+            .execute_with_params_deadline(NESTED_FILTER, None, BTreeMap::new(), deadline)
+    });
+    std::thread::sleep(Duration::from_millis(50));
+    let start = Instant::now();
+    handle.cancel();
+    let err = worker
+        .join()
+        .unwrap()
+        .expect_err("cancelled query must fail");
+    assert_eq!(err.code(), LoraErrorCode::Timeout);
+    assert!(
+        start.elapsed() < Duration::from_millis(150),
+        "stopped {:?} after cancel",
+        start.elapsed()
+    );
+}
+
+#[test]
+fn list_comprehension_reduce_and_quantifiers_honour_their_deadline() {
+    let db = TestDb::new();
+    let timeout = Duration::from_millis(200);
+    for query in [
+        // One row, one expression: no operator boundary inside the work.
+        "RETURN size([x IN range(1, 3000) WHERE size([y IN range(1, 3000) WHERE x * y = -1]) > 0]) AS n",
+        "RETURN reduce(acc = 0, x IN range(1, 3000) | acc + size([y IN range(1, 3000) WHERE x = y])) AS n",
+        "RETURN any(x IN range(1, 3000) WHERE any(y IN range(1, 3000) WHERE x * y = -1)) AS n",
+        "RETURN all(x IN range(1, 3000) WHERE none(y IN range(1, 3000) WHERE x * y = -1)) AS n",
+    ] {
+        let took = timed_out(&db, query, timeout);
+        assert!(
+            took < timeout + Duration::from_millis(150),
+            "{query}: took {took:?} for a {timeout:?} deadline"
+        );
+    }
+}
+
+#[test]
+fn cartesian_match_stops_close_to_its_deadline() {
+    let db = seeded();
+    let timeout = Duration::from_millis(300);
+    let took = timed_out(
+        &db,
+        "MATCH (a:A), (b:B) WHERE a.i + b.i = -1 RETURN a.i",
+        timeout,
+    );
+    assert!(
+        took < timeout + Duration::from_millis(150),
+        "took {took:?} for a {timeout:?} deadline"
+    );
+}

{lora_python-0.21.0 → lora_python-0.22.0}/crates/lora-executor/src/cancel.rs

@@ -108,8 +108,20 @@ pub(crate) fn is_cancelled(deadline: Instant) -> bool {
 
 thread_local! {
     static ACTIVE: std::cell::Cell<Option<Instant>> = const { std::cell::Cell::new(None) };
+    /// Iterations of expression-level loops since the last clock read.
+    static EVAL_TICK: std::cell::Cell<u32> = const { std::cell::Cell::new(0) };
+    /// Set once an expression-level check saw the active deadline pass
+    /// (or its query cancelled). Sticky for the rest of the query on this
+    /// thread so every enclosing loop unwinds at its next iteration.
+    static EVAL_TRIPPED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
 }
 
+/// Expression-level loop iterations between two clock reads. One
+/// iteration is at least a row clone plus a storage lookup, so 256 of them
+/// cost tens of microseconds: the check stays far below 1% of the work
+/// while a deadline is still noticed within a millisecond or so.
+const EVAL_CHECK_STRIDE: u32 = 256;
+
 /// Makes a query's deadline visible to everything that runs on this
 /// thread while the query executes, including pull pipelines that
 /// operators build lazily mid-query (`OPTIONAL MATCH`, `CALL {}`) and
@@ -123,6 +135,10 @@ pub(crate) struct DeadlineScope {
 impl DeadlineScope {
     pub(crate) fn enter(deadline: Option<Instant>) -> Self {
         let prev = ACTIVE.with(|a| a.get());
+        if prev.is_none() {
+            // A new query on this thread: forget a trip left by the last.
+            EVAL_TRIPPED.with(|t| t.set(false));
+        }
         ACTIVE.with(|a| a.set(deadline.or(prev)));
         Self { prev }
     }
@@ -132,7 +148,46 @@ impl Drop for DeadlineScope {
     fn drop(&mut self) {
         let prev = self.prev;
         ACTIVE.with(|a| a.set(prev));
+        if prev.is_none() {
+            EVAL_TRIPPED.with(|t| t.set(false));
+        }
+    }
+}
+
+/// Cheap per-iteration check for loops that run inside one expression
+/// evaluation (pattern and list comprehensions, `reduce`, list
+/// quantifiers, pattern expansion). Those loops sit below every operator
+/// boundary the pipeline checks, so without this a single `WHERE` could
+/// run arbitrarily far past the query's deadline. Reads the clock every
+/// [`EVAL_CHECK_STRIDE`] calls; once it fires it stays fired for the rest
+/// of the query, and `eval_expr_result` then reports the timeout.
+#[inline]
+pub(crate) fn eval_deadline_hit() -> bool {
+    if EVAL_TRIPPED.with(|t| t.get()) {
+        return true;
     }
+    let tick = EVAL_TICK.with(|t| {
+        let n = t.get().wrapping_add(1);
+        t.set(n);
+        n
+    });
+    if !tick.is_multiple_of(EVAL_CHECK_STRIDE) {
+        return false;
+    }
+    match active_deadline() {
+        Some(deadline) if deadline_reached(deadline) => {
+            EVAL_TRIPPED.with(|t| t.set(true));
+            true
+        }
+        _ => false,
+    }
+}
+
+/// Whether an expression on this thread stopped early because the active
+/// query's deadline passed: its value is incomplete and must not be used.
+#[inline]
+pub(crate) fn eval_tripped() -> bool {
+    EVAL_TRIPPED.with(|t| t.get())
 }
 
 /// The deadline of the query currently executing on this thread, if any.

{lora_python-0.21.0 → lora_python-0.22.0}/crates/lora-executor/src/errors.rs

@@ -106,6 +106,19 @@ pub enum ExecutorError {
 
 pub type ExecResult<T> = Result<T, ExecutorError>;
 
+impl ExecutorError {
+    /// The error for a failed expression evaluation: the query timeout
+    /// when the expression stopped on the deadline, a runtime error
+    /// carrying its message otherwise.
+    pub(crate) fn from_eval(message: String) -> Self {
+        if message == crate::eval::DEADLINE_EXCEEDED {
+            ExecutorError::QueryTimeout
+        } else {
+            ExecutorError::RuntimeError(message)
+        }
+    }
+}
+
 pub fn value_kind(value: &LoraValue) -> String {
     match value {
         LoraValue::Null => "null".into(),

{lora_python-0.21.0 → lora_python-0.22.0}/crates/lora-executor/src/eval/expr.rs

@@ -25,6 +25,13 @@ use super::binops::{eval_binary, eval_in, eval_unary, value_eq};
 use super::errors::{clear_eval_error, take_eval_error};
 use super::functions::eval_function;
 
+/// The message [`eval_expr_result`] fails with when an expression stopped
+/// because the query's deadline passed or the query was cancelled.
+/// [`crate::ExecutorError`] maps it back to `QueryTimeout`.
+pub const DEADLINE_EXCEEDED: &str = "query deadline exceeded";
+
+use crate::cancel::eval_deadline_hit;
+
 pub struct EvalContext<'a, S: GraphStorage> {
     pub storage: &'a S,
     pub params: &'a BTreeMap<String, LoraValue>,
@@ -125,6 +132,9 @@ pub fn eval_expr<S: GraphStorage>(
                     let mut inner_row = row.clone();
                     let mut count = 0usize;
                     for item in items {
+                        if eval_deadline_hit() {
+                            return LoraValue::Null;
+                        }
                         inner_row.insert_inline(*variable, item);
                         if eval_expr(predicate, &inner_row, ctx).is_truthy() {
                             count += 1;
@@ -154,6 +164,9 @@ pub fn eval_expr<S: GraphStorage>(
                     let mut result = Vec::with_capacity(items.len());
                     let mut inner_row = row.clone();
                     for item in items {
+                        if eval_deadline_hit() {
+                            return LoraValue::Null;
+                        }
                         // When no map_expr, we need the item after filter —
                         // stash it in the row binding and read it back if kept.
                         inner_row.insert_inline(*variable, item);
@@ -194,6 +207,9 @@ pub fn eval_expr<S: GraphStorage>(
                     let mut inner_row = row.clone();
                     let mut acc = init_val;
                     for item in items {
+                        if eval_deadline_hit() {
+                            return LoraValue::Null;
+                        }
                         inner_row.insert_inline(*accumulator, acc);
                         inner_row.insert_inline(*variable, item);
                         acc = eval_expr(expr, &inner_row, ctx);
@@ -409,6 +425,9 @@ fn eval_exists_subquery<S: GraphStorage>(
         let is_last_part = part_idx + 1 == pattern.parts.len();
         let mut next_rows = Vec::new();
         for current_row in &candidate_rows {
+            if eval_deadline_hit() {
+                return LoraValue::Null;
+            }
             match &part.element {
                 ResolvedPatternElement::Node {
                     var,
@@ -470,6 +489,9 @@ fn eval_exists_subquery<S: GraphStorage>(
                                         step.rel.direction,
                                         &step.rel.types,
                                         |rel_id, dst_id| {
+                                            if eval_deadline_hit() {
+                                                return Err(());
+                                            }
                                             if let Some(bound) = dst_bound {
                                                 if dst_id != bound {
                                                     return Ok::<(), ()>(());
@@ -544,7 +566,7 @@ fn exists_candidate_matches<S: GraphStorage>(
     ctx: &EvalContext<'_, S>,
 ) -> bool {
     where_
-        .map(|where_expr| eval_expr(where_expr, row, ctx).is_truthy())
+        .map(|where_expr| !eval_deadline_hit() && eval_expr(where_expr, row, ctx).is_truthy())
         .unwrap_or(true)
 }
 
@@ -565,6 +587,9 @@ fn eval_pattern_comprehension<S: GraphStorage>(
     for part in &pattern.parts {
         let mut next_rows = Vec::new();
         for current_row in &candidate_rows {
+            if eval_deadline_hit() {
+                return LoraValue::Null;
+            }
             match &part.element {
                 lora_analyzer::ResolvedPatternElement::Node {
                     var,
@@ -617,6 +642,9 @@ fn eval_pattern_comprehension<S: GraphStorage>(
                                         step.rel.direction,
                                         &step.rel.types,
                                         |rel_id, dst_id| {
+                                            if eval_deadline_hit() {
+                                                return Err(());
+                                            }
                                             if dst_bound.is_some_and(|bound| bound != dst_id)
                                                 || rel_bound.is_some_and(|bound| bound != rel_id)
                                             {
@@ -671,16 +699,22 @@ fn eval_pattern_comprehension<S: GraphStorage>(
     }
 
     if let Some(where_expr) = where_ {
-        candidate_rows.retain(|r| eval_expr(where_expr, r, ctx).is_truthy());
+        candidate_rows
+            .retain(|r| !eval_deadline_hit() && eval_expr(where_expr, r, ctx).is_truthy());
+    }
+    if crate::cancel::eval_tripped() {
+        return LoraValue::Null;
     }
 
     // Map each matched row through the map expression
-    LoraValue::List(
-        candidate_rows
-            .iter()
-            .map(|r| eval_expr(map_expr, r, ctx))
-            .collect(),
-    )
+    let mut out = Vec::with_capacity(candidate_rows.len());
+    for r in &candidate_rows {
+        if eval_deadline_hit() {
+            return LoraValue::Null;
+        }
+        out.push(eval_expr(map_expr, r, ctx));
+    }
+    LoraValue::List(out)
 }
 
 /// A copy of `row` holding only `reads`, the variables a pattern subquery
@@ -754,6 +788,9 @@ fn match_node_pattern<S: GraphStorage>(
 
     let mut out = Vec::new();
     for id in candidate_ids {
+        if eval_deadline_hit() {
+            break;
+        }
         let matched = ctx
             .storage
             .with_node(id, |n| {
@@ -833,7 +870,7 @@ impl<S: GraphStorage> VarLengthWalk<'_, '_, S> {
         if hops >= self.min_hops {
             self.emit(node, path, out);
         }
-        if hops >= self.max_hops {
+        if hops >= self.max_hops || eval_deadline_hit() {
             return;
         }
         let mut next = Vec::new();
@@ -976,6 +1013,10 @@ pub fn eval_expr_result<S: GraphStorage>(
 ) -> Result<LoraValue, String> {
     clear_eval_error();
     let value = eval_expr(expr, row, ctx);
+    if crate::cancel::eval_tripped() {
+        clear_eval_error();
+        return Err(DEADLINE_EXCEEDED.to_string());
+    }
     match take_eval_error() {
         Some(err) => Err(err),
         None => Ok(value),

{lora_python-0.21.0 → lora_python-0.22.0}/crates/lora-executor/src/eval/mod.rs

@@ -36,4 +36,4 @@ mod regex;
 mod vector;
 
 pub use errors::clear_eval_error;
-pub use expr::{eval_expr, eval_expr_result, eval_truthy_result, EvalContext};
+pub use expr::{eval_expr, eval_expr_result, eval_truthy_result, EvalContext, DEADLINE_EXCEEDED};