lora-python 0.20.0__tar.gz → 0.20.1__tar.gz

{lora_python-0.20.0 → lora_python-0.20.1}/Cargo.lock

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

{lora_python-0.20.0 → lora_python-0.20.1}/Cargo.toml

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

{lora_python-0.20.0 → lora_python-0.20.1}/PKG-INFO

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

{lora_python-0.20.0 → lora_python-0.20.1}/crates/lora-database/benches/README.md

@@ -34,6 +34,7 @@ compare cleanly across branches (build each branch, run the same probe):
 | --- | --- |
 | `heap_probe` | Real retained heap per node / relationship / index entry via a counting allocator (`MemoryReport` is an estimate). `-- --festimap` runs the 25k-node / 100k-relationship shape from the Festimap report |
 | `perf_probe` | Mean latency of common query shapes; `-- <scenario> <seconds>` loops one scenario for an external sampler, `-- --stream` compares `execute()` with `stream()` |
+| `carried_probe` | A 200-row hop / OPTIONAL MATCH with a 10k-element list carried in the row vs none (Festimap E-4; target: within 2x). `-- '<body>'` times another query body |
 | `optional_probe` | Anchored `OPTIONAL MATCH` vs the equivalent pattern comprehension (target: within 3x) |
 | `keyset_probe` | `WHERE n.key > $after ORDER BY n.key LIMIT 20` latency at 20k and 1M nodes (target: under 1 ms p50, flat in label size) |
 | `bulk_probe` | Bulk-load time with no schema vs a uniqueness constraint, range, or full-text index declared first |

lora_python-0.20.1/crates/lora-database/examples/carried_probe.rs

@@ -0,0 +1,51 @@
+//! Festimap E-4 repro: a value the row carries (a collected list) should not
+//! multiply the cost of an operator that makes a row per candidate.
+//! `cargo run --release -p lora-database --example carried_probe [-- '<body>']`
+//! times `MATCH (c:C {key: 'c'}) WITH c, <big> AS big <body>` with `[]` and
+//! with a 10k-element list; the ratio should stay under 2x.
+use std::time::Instant;
+
+use lora_database::{Database, ExecuteOptions, InMemoryGraph, ResultFormat};
+
+fn opts() -> Option<ExecuteOptions> {
+    Some(ExecuteOptions {
+        format: ResultFormat::Rows,
+    })
+}
+
+fn time(db: &Database<InMemoryGraph>, q: &str) -> f64 {
+    for _ in 0..3 {
+        db.execute(q, opts()).unwrap();
+    }
+    let n = 50;
+    let t = Instant::now();
+    for _ in 0..n {
+        db.execute(q, opts()).unwrap();
+    }
+    t.elapsed().as_secs_f64() * 1000.0 / n as f64
+}
+
+fn main() {
+    let db = Database::in_memory();
+    db.execute(
+        "CREATE (c:C {key: 'c'}) WITH c UNWIND range(1, 200) AS i CREATE (:M {i: i})-[:IN]->(c)",
+        opts(),
+    )
+    .unwrap();
+    let bodies: Vec<String> = match std::env::args().nth(1) {
+        Some(body) => vec![body],
+        None => vec![
+            "MATCH (c)<-[:IN]-(m:M) RETURN count(m) AS n, size(big) AS b".into(),
+            "OPTIONAL MATCH (c)<-[:IN]-(m:M) RETURN count(m) AS n, size(big) AS b".into(),
+        ],
+    };
+    for body in bodies {
+        let q = |big: &str| format!("MATCH (c:C {{key: 'c'}}) WITH c, {big} AS big {body}");
+        let small = time(&db, &q("[]"));
+        let large = time(&db, &q("range(1, 10000)"));
+        println!(
+            "{body}\n  []: {small:.3} ms  10k: {large:.3} ms  ratio {:.1}x",
+            large / small
+        );
+    }
+}

lora_python-0.20.1/crates/lora-database/tests/carried_value_sharing.rs

@@ -0,0 +1,163 @@
+//! A value the row carries for other reasons is shared, not copied, when an
+//! operator makes one row per candidate.
+//!
+//! An expand, an OPTIONAL MATCH, a variable-length expand, UNWIND, FOREACH and
+//! the list constructs each clone their working row per candidate. A list
+//! collected earlier in the query (Festimap's E-4: a `CALL` that collects a
+//! page before its counts) used to be copied with it, so a 200-row hop over
+//! a row carrying a 10k-element list ran ~250x slower than the same hop
+//! without it. Large values now sit behind a shared pointer in the row slot,
+//! and a lone variable argument (`size(big)`) is read in place.
+
+mod test_helpers;
+use std::time::Instant;
+
+use test_helpers::TestDb;
+
+fn hub(members: usize) -> TestDb {
+    let db = TestDb::new();
+    db.run(&format!(
+        "CREATE (c:C {{key: 'c'}}) WITH c UNWIND range(1, {members}) AS i \
+         CREATE (:M {{i: i}})-[:IN]->(c)"
+    ));
+    db
+}
+
+/// The query body after `MATCH (c:C {key: 'c'}) WITH c, <big> AS big`, for
+/// each site that makes a row per candidate.
+const SITES: &[(&str, &str)] = &[
+    (
+        "expand",
+        "MATCH (c)<-[:IN]-(m:M) RETURN count(m) AS n, size(big) AS b",
+    ),
+    (
+        "optional match",
+        "OPTIONAL MATCH (c)<-[:IN]-(m:M) RETURN count(m) AS n, size(big) AS b",
+    ),
+    (
+        "expand + filter",
+        "MATCH (c)<-[:IN]-(m:M) WHERE m.i > 10 RETURN count(m) AS n, size(big) AS b",
+    ),
+    (
+        "variable-length expand",
+        "MATCH (c)<-[:IN*1..2]-(m:M) RETURN count(m) AS n, size(big) AS b",
+    ),
+    (
+        "shortest path",
+        "MATCH (m:M) WITH c, big, m MATCH p = shortestPath((c)-[:IN*..2]-(m)) \
+         RETURN count(p) AS n, size(big) AS b",
+    ),
+    (
+        "foreach",
+        "FOREACH (i IN range(1, 200) | SET c.x = i) RETURN size(big) AS b",
+    ),
+    (
+        "unwind + where",
+        "UNWIND range(1, 200) AS i WITH c, big, i WHERE i > 10 RETURN count(i) AS n, size(big) AS b",
+    ),
+    (
+        "call without importing with",
+        "CALL { MATCH (m:M) RETURN m } RETURN count(m) AS n, size(big) AS b",
+    ),
+    (
+        "list comprehension",
+        "RETURN size([i IN range(1, 200) WHERE i > 10 | i]) AS n, size(big) AS b",
+    ),
+    (
+        "reduce",
+        "RETURN reduce(s = 0, i IN range(1, 200) | s + i) AS n, size(big) AS b",
+    ),
+    (
+        "quantifier",
+        "RETURN any(i IN range(1, 200) WHERE i < 0) AS n, size(big) AS b",
+    ),
+];
+
+fn per_query(db: &TestDb, q: &str) -> f64 {
+    db.run(q);
+    // The fastest of several runs: robust against a loaded host.
+    (0..7)
+        .map(|_| {
+            let start = Instant::now();
+            db.run(q);
+            start.elapsed().as_secs_f64()
+        })
+        .fold(f64::MAX, f64::min)
+}
+
+fn query(big: &str, body: &str) -> String {
+    format!("MATCH (c:C {{key: 'c'}}) WITH c, {big} AS big {body}")
+}
+
+#[test]
+fn a_carried_list_does_not_multiply_the_cost_of_a_row_per_candidate() {
+    let db = hub(200);
+    let mut slow = Vec::new();
+    for (site, body) in SITES {
+        let small = per_query(&db, &query("[]", body));
+        let large = per_query(&db, &query("range(1, 10000)", body));
+        // Copying the list per candidate made the row-per-candidate sites
+        // 200-380x slower (17 ms against 0.07 ms for the expand in a release
+        // build); now they run within 2x. Building the list once is the only
+        // cost left; the bound leaves room for a loaded host and a debug
+        // build.
+        if large > small * 5.0 + 0.01 {
+            slow.push(format!("{site}: [] {small:.5}s, 10k {large:.5}s"));
+        }
+    }
+    assert!(slow.is_empty(), "{slow:#?}");
+}
+
+#[test]
+fn a_carried_list_keeps_its_value_through_every_site() {
+    let db = hub(20);
+    for (site, body) in SITES {
+        let rows = db.run(&query("range(1, 50)", body));
+        assert_eq!(rows.len(), 1, "{site}");
+        assert_eq!(rows[0]["b"], 50, "{site}");
+    }
+}
+
+#[test]
+fn shared_values_are_independent_after_a_copy() {
+    let db = hub(3);
+    // The carried list and map reach every row intact, and a value built
+    // from one row's copy does not leak into another's.
+    let rows = db.run(
+        "MATCH (c:C {key: 'c'}) WITH c, range(1, 100) AS big, \
+           {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9} AS cfg \
+         MATCH (c)<-[:IN]-(m:M) \
+         WITH m, big + [m.i] AS mine, cfg \
+         RETURN m.i AS i, size(mine) AS n, mine[-1] AS last, mine[0] AS first, cfg.i AS ci \
+         ORDER BY i",
+    );
+    assert_eq!(rows.len(), 3);
+    for (row, i) in rows.iter().zip(1..) {
+        assert_eq!(row["i"], i);
+        assert_eq!(row["n"], 101);
+        assert_eq!(row["last"], i);
+        assert_eq!(row["first"], 1);
+        assert_eq!(row["ci"], 9);
+    }
+
+    // A large list returned from many rows is returned whole on each.
+    let rows = db.run("WITH range(1, 64) AS big MATCH (m:M) RETURN m.i AS i, big ORDER BY i");
+    assert_eq!(rows.len(), 3);
+    for row in &rows {
+        assert_eq!(row["big"].as_array().unwrap().len(), 64);
+    }
+
+    // OPTIONAL MATCH with no match null-extends and keeps the carried list.
+    let rows = db.run("WITH range(1, 64) AS big OPTIONAL MATCH (x:Nope) RETURN x, size(big) AS b");
+    assert_eq!(rows[0]["x"], serde_json::Value::Null);
+    assert_eq!(rows[0]["b"], 64);
+
+    // FOREACH over rows carrying a list writes once per element.
+    db.run(
+        "MATCH (c:C {key: 'c'}) WITH c, range(1, 100) AS big \
+         FOREACH (i IN range(1, 5) | CREATE (:F {i: i, b: size(big)}))",
+    );
+    let rows = db.run("MATCH (f:F) RETURN count(f) AS n, min(f.b) AS b");
+    assert_eq!(rows[0]["n"], 5);
+    assert_eq!(rows[0]["b"], 100);
+}

{lora_python-0.20.0 → lora_python-0.20.1}/crates/lora-executor/src/eval/expr.rs

@@ -106,10 +106,7 @@ pub fn eval_expr<S: GraphStorage>(
             function,
             distinct: _,
             args,
-        } => {
-            let args: Vec<LoraValue> = args.iter().map(|a| eval_expr(a, row, ctx)).collect();
-            eval_function(*function, &args, ctx)
-        }
+        } => eval_call(*function, args, row, ctx),
 
         ResolvedExpr::Parameter(name) => ctx.params.get(name).cloned().unwrap_or(LoraValue::Null),
 
@@ -128,7 +125,7 @@ pub fn eval_expr<S: GraphStorage>(
                     let mut inner_row = row.clone();
                     let mut count = 0usize;
                     for item in items {
-                        inner_row.insert(*variable, item);
+                        inner_row.insert_inline(*variable, item);
                         if eval_expr(predicate, &inner_row, ctx).is_truthy() {
                             count += 1;
                         }
@@ -159,7 +156,7 @@ pub fn eval_expr<S: GraphStorage>(
                     for item in items {
                         // 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(*variable, item);
+                        inner_row.insert_inline(*variable, item);
                         if let Some(f) = filter {
                             if !eval_expr(f, &inner_row, ctx).is_truthy() {
                                 continue;
@@ -197,8 +194,8 @@ pub fn eval_expr<S: GraphStorage>(
                     let mut inner_row = row.clone();
                     let mut acc = init_val;
                     for item in items {
-                        inner_row.insert(*accumulator, acc);
-                        inner_row.insert(*variable, item);
+                        inner_row.insert_inline(*accumulator, acc);
+                        inner_row.insert_inline(*variable, item);
                         acc = eval_expr(expr, &inner_row, ctx);
                     }
                     acc
@@ -373,6 +370,22 @@ fn eval_ref<'r, S: GraphStorage>(
     }
 }
 
+/// A function call. A lone variable argument (`size(big)`, `head(list)`) is
+/// read in place instead of copied per call.
+fn eval_call<S: GraphStorage>(
+    function: lora_analyzer::FunctionId,
+    args: &[ResolvedExpr],
+    row: &Row,
+    ctx: &EvalContext<'_, S>,
+) -> LoraValue {
+    if let [ResolvedExpr::Variable(var)] = args {
+        let value = row.get(*var).unwrap_or(&NULL);
+        return eval_function(function, std::slice::from_ref(value), ctx);
+    }
+    let args: Vec<LoraValue> = args.iter().map(|a| eval_expr(a, row, ctx)).collect();
+    eval_function(function, &args, ctx)
+}
+
 fn eval_exists_subquery<S: GraphStorage>(
     pattern: &lora_analyzer::ResolvedPattern,
     where_: Option<&ResolvedExpr>,

{lora_python-0.20.0 → lora_python-0.20.1}/crates/lora-executor/src/executor/helpers.rs

@@ -73,6 +73,43 @@ pub(super) fn check_deadline_at(deadline: Instant) -> ExecResult<()> {
     }
 }
 
+/// Project `item` from `source` into `projected`. A bare variable takes the
+/// source's slot as is, so a large value it holds is shared, not copied.
+#[inline]
+pub(crate) fn project_item<S: GraphStorage>(
+    projected: &mut Row,
+    source: &Row,
+    item: &lora_analyzer::ResolvedProjection,
+    eval_ctx: &EvalContext<'_, S>,
+) -> ExecResult<()> {
+    if let ResolvedExpr::Variable(var) = &item.expr {
+        if projected.insert_named_from(item.output, item.name.clone(), source, *var) {
+            return Ok(());
+        }
+    }
+    let value =
+        eval_expr_result(&item.expr, source, eval_ctx).map_err(ExecutorError::RuntimeError)?;
+    projected.insert_named(item.output, item.name.clone(), value);
+    Ok(())
+}
+
+/// [`project_item`] for a projection that keeps the row's existing bindings.
+#[inline]
+pub(crate) fn project_item_in_place<S: GraphStorage>(
+    row: &mut Row,
+    item: &lora_analyzer::ResolvedProjection,
+    eval_ctx: &EvalContext<'_, S>,
+) -> ExecResult<()> {
+    if let ResolvedExpr::Variable(var) = &item.expr {
+        if row.insert_named_from_self(item.output, item.name.clone(), *var) {
+            return Ok(());
+        }
+    }
+    let value = eval_expr_result(&item.expr, row, eval_ctx).map_err(ExecutorError::RuntimeError)?;
+    row.insert_named(item.output, item.name.clone(), value);
+    Ok(())
+}
+
 pub(super) fn filter_rows_checked<S: GraphStorage>(
     input_rows: Vec<Row>,
     predicate: &ResolvedExpr,
@@ -98,17 +135,13 @@ pub(super) fn project_rows_checked<S: GraphStorage>(
         if op.include_existing {
             let mut projected = row;
             for item in &op.items {
-                let value = eval_expr_result(&item.expr, &projected, eval_ctx)
-                    .map_err(ExecutorError::RuntimeError)?;
-                projected.insert_named(item.output, item.name.clone(), value);
+                project_item_in_place(&mut projected, item, eval_ctx)?;
             }
             out.push(projected);
         } else {
             let mut projected = Row::new();
             for item in &op.items {
-                let value = eval_expr_result(&item.expr, &row, eval_ctx)
-                    .map_err(ExecutorError::RuntimeError)?;
-                projected.insert_named(item.output, item.name.clone(), value);
+                project_item(&mut projected, &row, item, eval_ctx)?;
             }
             out.push(projected);
         }

{lora_python-0.20.0 → lora_python-0.20.1}/crates/lora-executor/src/executor/immutable.rs

@@ -11,7 +11,7 @@
 use crate::errors::{ExecResult, ExecutorError};
 use crate::eval::{clear_eval_error, EvalContext};
 #[cfg(all(feature = "parallel", not(target_arch = "wasm32")))]
-use crate::eval::{eval_expr, eval_expr_result, eval_truthy_result};
+use crate::eval::{eval_expr, eval_truthy_result};
 use crate::value::{LoraValue, Row};
 use crate::{project_rows, ExecuteOptions, QueryResult};
 
@@ -36,6 +36,7 @@ use super::helpers::{
     node_matches_label_groups, node_matches_property_filter, scan_node_ids_for_label_groups,
 };
 use super::{merge_optional_rows, optional_match_rows};
+use super::{project_item, project_item_in_place};
 use super::{sort_row_bound, sort_rows_with_top_k};
 
 #[cfg(all(feature = "parallel", not(target_arch = "wasm32")))]
@@ -167,7 +168,7 @@ impl<'a, S: GraphStorage> Executor<'a, S> {
         let mut out = Row::new();
 
         for (var, name, value) in row.into_iter_named() {
-            out.insert_named(var, name, self.hydrate_value(value));
+            out.insert_named_inline(var, name, self.hydrate_value(value));
         }
 
         out
@@ -704,17 +705,13 @@ impl<'a, S: GraphStorage> Executor<'a, S> {
                 if op.include_existing {
                     let mut projected = row;
                     for item in &op.items {
-                        let value = eval_expr_result(&item.expr, &projected, &eval_ctx)
-                            .map_err(ExecutorError::RuntimeError)?;
-                        projected.insert_named(item.output, item.name.clone(), value);
+                        project_item_in_place(&mut projected, item, &eval_ctx)?;
                     }
                     Ok(projected)
                 } else {
                     let mut projected = Row::new();
                     for item in &op.items {
-                        let value = eval_expr_result(&item.expr, &row, &eval_ctx)
-                            .map_err(ExecutorError::RuntimeError)?;
-                        projected.insert_named(item.output, item.name.clone(), value);
+                        project_item(&mut projected, &row, item, &eval_ctx)?;
                     }
                     Ok(projected)
                 }

{lora_python-0.20.0 → lora_python-0.20.1}/crates/lora-executor/src/executor/mod.rs

@@ -71,6 +71,7 @@ pub(crate) use helpers::{
     scan_node_ids_for_label_groups, GroupValueKey, NodePropertyCandidates,
 };
 pub(crate) use helpers::{other_kind_node_ids, OrderedRangeCursor, OtherKindScan};
+pub(crate) use helpers::{project_item, project_item_in_place};
 pub(crate) use optional::{
     merge_optional_rows, null_extend_optional_row, optional_can_correlate, optional_match_rows,
     optional_rows_compatible,

{lora_python-0.20.0 → lora_python-0.20.1}/crates/lora-executor/src/executor/mutable.rs

@@ -243,7 +243,7 @@ impl<'a, S: GraphStorageMut> MutableExecutor<'a, S> {
         let mut out = Row::new();
 
         for (var, name, value) in row.into_iter_named() {
-            out.insert_named(var, name, self.hydrate_value(value));
+            out.insert_named_inline(var, name, self.hydrate_value(value));
         }
 
         out

{lora_python-0.20.0 → lora_python-0.20.1}/crates/lora-executor/src/executor/optional.rs

@@ -92,7 +92,9 @@ pub(crate) fn optional_rows_compatible(input_row: &Row, inner_row: &Row) -> bool
     input_row
         .iter()
         .all(|(var, val)| match inner_row.get(*var) {
-            Some(inner_val) => inner_val == val,
+            // A seeded inner row shares the outer row's large values: the
+            // pointer check skips comparing a carried list element-wise.
+            Some(inner_val) => std::ptr::eq(inner_val, val) || inner_val == val,
             None => true,
         })
 }

{lora_python-0.20.0 → lora_python-0.20.1}/crates/lora-executor/src/pull/hydration.rs

@@ -27,7 +27,7 @@ impl<'a, S: GraphStorage> RowSource for HydratingSource<'a, S> {
             Some(row) => {
                 let mut out = Row::new();
                 for (var, name, value) in row.into_iter_named() {
-                    out.insert_named(var, name, hydrate_value(value, self.storage));
+                    out.insert_named_inline(var, name, hydrate_value(value, self.storage));
                 }
                 Ok(Some(out))
             }
@@ -40,7 +40,7 @@ impl<'a, S: GraphStorage> RowSource for HydratingSource<'a, S> {
 pub fn hydrate_row<S: GraphStorage>(row: Row, storage: &S) -> Row {
     let mut out = Row::new();
     for (var, name, value) in row.into_iter_named() {
-        out.insert_named(var, name, hydrate_value(value, storage));
+        out.insert_named_inline(var, name, hydrate_value(value, storage));
     }
     out
 }