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

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

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

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

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.20.1"
+version = "0.21.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.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" }
+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" }
 
 # External crates.
 anyhow = "1"

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

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

{lora_python-0.20.1 → lora_python-0.21.0}/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.1 → lora_python-0.21.0}/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.21.0/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.21.0/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.1 → lora_python-0.21.0}/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.1 → lora_python-0.21.0}/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)),

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

@@ -1290,7 +1290,14 @@ pub(crate) fn node_by_property_range_scan_rows<S: GraphStorage>(
     for row in base_rows {
         check_optional_deadline(deadline)?;
         let lo_value = op.lo.as_ref().map(|expr| eval_expr(expr, &row, &eval_ctx));
-        let hi_value = op.hi.as_ref().map(|expr| eval_expr(expr, &row, &eval_ctx));
+        // A null upper bound reads as none: the Filter kept above every
+        // index scan still judges each row (a STARTS WITH prefix with no
+        // successor, `string.prefix_end` null, scans to the end).
+        let hi_value = op
+            .hi
+            .as_ref()
+            .map(|expr| eval_expr(expr, &row, &eval_ctx))
+            .filter(|v| !matches!(v, LoraValue::Null));
         let lo_prop = lo_value
             .clone()
             .and_then(|v| lora_value_to_property(v).ok());
@@ -2541,7 +2548,14 @@ pub(crate) fn rel_by_property_range_scan_rows<S: GraphStorage>(
     for row in base_rows {
         check_optional_deadline(deadline)?;
         let lo_value = op.lo.as_ref().map(|expr| eval_expr(expr, &row, &eval_ctx));
-        let hi_value = op.hi.as_ref().map(|expr| eval_expr(expr, &row, &eval_ctx));
+        // A null upper bound reads as none: the Filter kept above every
+        // index scan still judges each row (a STARTS WITH prefix with no
+        // successor, `string.prefix_end` null, scans to the end).
+        let hi_value = op
+            .hi
+            .as_ref()
+            .map(|expr| eval_expr(expr, &row, &eval_ctx))
+            .filter(|v| !matches!(v, LoraValue::Null));
         let lo_prop = lo_value
             .clone()
             .and_then(|v| lora_value_to_property(v).ok());

{lora_python-0.20.1 → lora_python-0.21.0}/crates/lora-executor/src/pull/scan.rs

@@ -567,7 +567,13 @@ impl<'a, S: GraphStorage> RowSource for OrderedRangeScanSource<'a, S> {
             };
             let eval_ctx = self.ctx.eval_ctx();
             let lo = self.op.lo.as_ref().map(|e| eval_expr(e, &row, &eval_ctx));
-            let hi = self.op.hi.as_ref().map(|e| eval_expr(e, &row, &eval_ctx));
+            // A null upper bound reads as none (see the buffered scan).
+            let hi = self
+                .op
+                .hi
+                .as_ref()
+                .map(|e| eval_expr(e, &row, &eval_ctx))
+                .filter(|v| !matches!(v, LoraValue::Null));
             let others = crate::executor::other_kind_node_ids(
                 self.ctx.storage,
                 self.op,

{lora_python-0.20.1 → lora_python-0.21.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "lora-python"
-version = "0.20.1"
+version = "0.21.0"
 description = "Python bindings for the Lora in-memory graph database"
 readme = "README.md"
 license = { text = "BUSL-1.1" }