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

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

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

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

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

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

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

{lora_python-0.20.0 → lora_python-0.20.2}/crates/lora-builtins-meta/src/lib.rs

@@ -259,6 +259,7 @@ pub const BUILTIN_SPECS: &[BuiltinSpec] = &[
     spec("list.compact", 1, Some(1)),
     // -- string.* -----------------------------------------------------------
     spec("string.upper", 1, Some(1)),
+    spec("string.prefix_end", 1, Some(1)),
     spec("string.lower", 1, Some(1)),
     spec("string.capitalize", 1, Some(2)),
     spec("string.case", 2, Some(2)),

{lora_python-0.20.0 → lora_python-0.20.2}/crates/lora-compiler/src/optimizer.rs

@@ -567,6 +567,32 @@ fn collect_index_candidates(
     }
 
     if let Some(candidate) = text_predicate_for_var(predicate, scan.var) {
+        // `x STARTS WITH s` is the range `s <= x < string.prefix_end(s)`,
+        // which a RANGE index answers when there is no TEXT index.
+        if matches!(candidate.predicate, TextPredicate::StartsWith)
+            && !is_tautological_text(&candidate)
+            && first_simple_label(&scan.labels)
+                .is_some_and(|label| stats.has_node_range_index(label, &candidate.key))
+        {
+            out.push(LogicalOp::NodeByPropertyRangeScan(
+                NodeByPropertyRangeScan {
+                    input: scan.input,
+                    var: scan.var,
+                    labels: scan.labels.clone(),
+                    key: candidate.key.clone(),
+                    lo: Some(candidate.query.clone()),
+                    lo_inclusive: true,
+                    hi: Some(ResolvedExpr::Function {
+                        function: lora_analyzer::FunctionId::builtin("string.prefix_end")
+                            .expect("string.prefix_end is a builtin"),
+                        distinct: false,
+                        args: vec![candidate.query.clone()],
+                    }),
+                    hi_inclusive: false,
+                    order: None,
+                },
+            ));
+        }
         if !is_tautological_text(&candidate)
             && first_simple_label(&scan.labels)
                 .is_some_and(|label| stats.has_node_text_index(label, &candidate.key))

{lora_python-0.20.0 → lora_python-0.20.2}/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.2/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.2/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.2/crates/lora-database/tests/starts_with_range_seek.rs

@@ -0,0 +1,61 @@
+//! `x STARTS WITH s` seeks a RANGE index as `s <= x < string.prefix_end(s)`
+//! when no TEXT index covers the property, with the exact same rows.
+
+mod test_helpers;
+use std::collections::BTreeMap;
+
+use lora_database::LoraValue;
+use test_helpers::TestDb;
+
+fn seeded() -> TestDb {
+    let db = TestDb::new();
+    db.run("CREATE INDEX post_video FOR (p:Post) ON (p.video)");
+    db.run(
+        "UNWIND range(1, 200) AS i CREATE (:Post {key: 'p' + i, video: CASE WHEN i % 10 = 0 THEN 'https://x/' + i ELSE null END})",
+    );
+    db.run("CREATE (:Post {key: 'h', video: 'http://y'}), (:Post {key: 'n', video: 42})");
+    db
+}
+
+fn plan(db: &TestDb, q: &str) -> String {
+    format!("{:?}", db.service.explain(q, None).unwrap().tree)
+}
+
+#[test]
+fn starts_with_seeks_the_range_index() {
+    let db = seeded();
+    let q = "MATCH (p:Post) WHERE p.video STARTS WITH 'https://' RETURN count(p) AS n";
+    assert!(
+        plan(&db, q).contains("NodeByPropertyRangeScan"),
+        "{}",
+        plan(&db, q)
+    );
+    assert_eq!(db.scalar(q), 20);
+    // A parameter prefix too.
+    let rows = db.run_with_params(
+        "MATCH (p:Post) WHERE p.video STARTS WITH $s RETURN count(p) AS n",
+        BTreeMap::from([("s".to_string(), LoraValue::String("http".into()))]),
+    );
+    assert_eq!(rows[0]["n"], 21);
+}
+
+#[test]
+fn edge_prefixes_match_exactly() {
+    let db = seeded();
+    let count = |s: &str| {
+        db.run_with_params(
+            "MATCH (p:Post) WHERE p.video STARTS WITH $s RETURN count(p) AS n",
+            BTreeMap::from([("s".to_string(), LoraValue::String(s.into()))]),
+        )[0]["n"]
+            .clone()
+    };
+    // The empty prefix: every string, no successor.
+    assert_eq!(count(""), 21);
+    assert_eq!(count("https://x/20"), 2); // 20 and 200
+    assert_eq!(count("zzz"), 0);
+    assert_eq!(db.scalar("RETURN string.prefix_end('ab') AS v"), "ac");
+    assert_eq!(
+        db.scalar("RETURN string.prefix_end('') AS v"),
+        serde_json::Value::Null
+    );
+}

lora_python-0.20.2/crates/lora-database/tests/string_number_addition.rs

@@ -0,0 +1,46 @@
+//! `+` follows Cypher across types: a string and a number concatenate, a
+//! list and an element append or prepend, null stays null, and any other
+//! mix is an error instead of a silent null.
+
+mod test_helpers;
+use test_helpers::TestDb;
+
+#[test]
+fn a_string_and_a_number_concatenate() {
+    let db = TestDb::new();
+    assert_eq!(db.scalar("RETURN 'p' + 1 AS v"), "p1");
+    assert_eq!(db.scalar("RETURN 1 + 'p' AS v"), "1p");
+    assert_eq!(db.scalar("RETURN 'v' + 2.5 AS v"), "v2.5");
+    assert_eq!(
+        db.column("UNWIND range(1, 3) AS i RETURN 'p' + i AS k", "k"),
+        vec!["p1", "p2", "p3"]
+    );
+}
+
+#[test]
+fn a_list_and_an_element_append_or_prepend() {
+    let db = TestDb::new();
+    assert_eq!(
+        db.scalar("RETURN [1, 2] + 3 AS v"),
+        serde_json::json!([1, 2, 3])
+    );
+    assert_eq!(
+        db.scalar("RETURN 0 + [1, 2] AS v"),
+        serde_json::json!([0, 1, 2])
+    );
+    assert_eq!(
+        db.scalar("RETURN [1] + [2] AS v"),
+        serde_json::json!([1, 2])
+    );
+}
+
+#[test]
+fn null_stays_null_and_other_mixes_are_errors() {
+    let db = TestDb::new();
+    assert_eq!(db.scalar("RETURN 'p' + null AS v"), serde_json::Value::Null);
+    assert_eq!(db.scalar("RETURN null + [1] AS v"), serde_json::Value::Null);
+    let err = db.run_err("RETURN 'p' + true AS v");
+    assert!(err.contains("Cannot add"), "{err}");
+    let err = db.run_err("RETURN {a: 1} + 1 AS v");
+    assert!(err.contains("Cannot add"), "{err}");
+}

{lora_python-0.20.0 → lora_python-0.20.2}/crates/lora-executor/src/eval/binops.rs

@@ -287,15 +287,31 @@ fn int_float_cmp(i: i64, f: f64) -> Option<std::cmp::Ordering> {
 
 fn add_values(lhs: LoraValue, rhs: LoraValue) -> LoraValue {
     match (lhs, rhs) {
+        (LoraValue::Null, _) | (_, LoraValue::Null) => LoraValue::Null,
         (LoraValue::Int(a), LoraValue::Int(b)) => match a.checked_add(b) {
             Some(out) => LoraValue::Int(out),
             None => arithmetic_overflow("integer addition"),
         },
         (LoraValue::String(a), LoraValue::String(b)) => LoraValue::String(a + &b),
+        // A string and a number concatenate, as toString would print the
+        // number: 'p' + 1 is 'p1' (it was a silent null).
+        (LoraValue::String(a), LoraValue::Int(b)) => LoraValue::String(format!("{a}{b}")),
+        (LoraValue::String(a), LoraValue::Float(b)) => LoraValue::String(format!("{a}{b}")),
+        (LoraValue::Int(a), LoraValue::String(b)) => LoraValue::String(format!("{a}{b}")),
+        (LoraValue::Float(a), LoraValue::String(b)) => LoraValue::String(format!("{a}{b}")),
         (LoraValue::List(mut a), LoraValue::List(b)) => {
             a.extend(b);
             LoraValue::List(a)
         }
+        // A list and an element: append or prepend it.
+        (LoraValue::List(mut a), b) => {
+            a.push(b);
+            LoraValue::List(a)
+        }
+        (a, LoraValue::List(mut b)) => {
+            b.insert(0, a);
+            LoraValue::List(b)
+        }
         // Temporal + Duration
         (LoraValue::Date(d), LoraValue::Duration(dur)) => match d.try_add_duration(&dur) {
             Some(out) => LoraValue::Date(out),
@@ -327,8 +343,15 @@ fn add_values(lhs: LoraValue, rhs: LoraValue) -> LoraValue {
             LoraValue::Null
         }
         (a, b) => match (a.as_f64(), b.as_f64()) {
-            (Some(a), Some(b)) => LoraValue::Float(a + b),
-            _ => LoraValue::Null,
+            (Some(x), Some(y)) => LoraValue::Float(x + y),
+            _ => {
+                set_eval_error(format!(
+                    "Cannot add {} and {}",
+                    crate::errors::value_kind(&a),
+                    crate::errors::value_kind(&b)
+                ));
+                LoraValue::Null
+            }
         },
     }
 }

{lora_python-0.20.0 → lora_python-0.20.2}/crates/lora-executor/src/eval/builtins/string_ns.rs

@@ -11,6 +11,7 @@ use crate::value::LoraValue;
 pub(super) fn dispatch(op: &str, args: &[LoraValue]) -> Option<LoraValue> {
     Some(match op {
         "upper" => unary_str(args, |s| s.to_uppercase()),
+        "prefix_end" => prefix_end(args),
         "lower" => unary_str(args, |s| s.to_lowercase()),
         "capitalize" => capitalize(args),
         "case" => case(args),
@@ -60,6 +61,29 @@ fn as_str(v: Option<&LoraValue>) -> Option<&str> {
     }
 }
 
+/// The smallest string greater than every string starting with `s`: the
+/// last character that can be incremented is, and what follows it is
+/// dropped. `x STARTS WITH s` is `s <= x < string.prefix_end(s)`, which a
+/// RANGE index answers. Null when there is no such string (the empty
+/// prefix, or one of only U+10FFFF): every string at or above `s` matches.
+fn prefix_end(args: &[LoraValue]) -> LoraValue {
+    let Some(s) = as_str(args.first()) else {
+        return LoraValue::Null;
+    };
+    let mut chars: Vec<char> = s.chars().collect();
+    while let Some(last) = chars.pop() {
+        let next = match last as u32 {
+            0xD7FF => Some('\u{E000}'),
+            code => char::from_u32(code + 1),
+        };
+        if let Some(next) = next {
+            chars.push(next);
+            return LoraValue::String(chars.into_iter().collect());
+        }
+    }
+    LoraValue::Null
+}
+
 fn unary_str(args: &[LoraValue], f: impl Fn(&str) -> String) -> LoraValue {
     match as_str(args.first()) {
         Some(s) => LoraValue::String(f(s)),