lora-python 0.16.2__tar.gz → 0.17.0__tar.gz

{lora_python-0.16.2 → lora_python-0.17.0}/Cargo.lock

@@ -773,7 +773,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "lora-ast",
  "lora-builtins-meta",
@@ -784,14 +784,14 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-binding-buffer"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "lora-database",
  "lora-store",
@@ -799,11 +799,11 @@ dependencies = [
 
 [[package]]
 name = "lora-builtins-meta"
-version = "0.16.2"
+version = "0.17.0"
 
 [[package]]
 name = "lora-compiler"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -812,7 +812,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "anyhow",
  "chacha20poly1305",
@@ -837,7 +837,7 @@ dependencies = [
 
 [[package]]
 name = "lora-executor"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "blake3",
  "crc32fast",
@@ -860,7 +860,7 @@ dependencies = [
 
 [[package]]
 name = "lora-ffi"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -872,7 +872,7 @@ dependencies = [
 
 [[package]]
 name = "lora-io"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "lora-executor",
  "lora-store",
@@ -883,7 +883,7 @@ dependencies = [
 
 [[package]]
 name = "lora-node"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -898,7 +898,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "lora-ast",
  "pest",
@@ -909,7 +909,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -921,7 +921,7 @@ dependencies = [
 
 [[package]]
 name = "lora-query-wasm"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
@@ -935,7 +935,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "anyhow",
  "axum",
@@ -950,7 +950,7 @@ dependencies = [
 
 [[package]]
 name = "lora-snapshot"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "argon2",
  "blake3",
@@ -965,7 +965,7 @@ dependencies = [
 
 [[package]]
 name = "lora-store"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "crc32fast",
  "js-sys",
@@ -979,7 +979,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wal"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "crc32fast",
  "lora-store",
@@ -989,7 +989,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -1005,7 +1005,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.16.2"
+version = "0.17.0"
 dependencies = [
  "anyhow",
  "lora-database",

{lora_python-0.16.2 → lora_python-0.17.0}/Cargo.toml

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

{lora_python-0.16.2 → lora_python-0.17.0}/PKG-INFO

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

{lora_python-0.16.2 → lora_python-0.17.0}/crates/lora-builtins-meta/src/lib.rs

@@ -503,6 +503,7 @@ pub const BUILTIN_ALIASES: &[BuiltinAlias] = &[
     alias("range", "list.range"),
     // Cypher / historical compatibility aliases.
     alias("head", "list.first"),
+    alias("first", "list.first"),
     alias("last", "list.last"),
     alias("coalesce", "value.coalesce"),
     alias("tolower", "string.lower"),

{lora_python-0.16.2 → lora_python-0.17.0}/crates/lora-compiler/src/optimizer.rs

@@ -1470,7 +1470,61 @@ fn collect_vars_inner(expr: &ResolvedExpr, out: &mut BTreeSet<VarId>) {
                 }
             }
         }
-        _ => {}
+        // A pattern reads the outer variables it names (`(a)<-[:T]-(x)`
+        // reads `a`). Its own fresh variables are collected too: an
+        // over-approximation, which only ever keeps a predicate in place.
+        ResolvedExpr::ExistsSubquery { pattern, where_ } => {
+            collect_pattern_vars(pattern, out);
+            if let Some(w) = where_ {
+                collect_vars_inner(w, out);
+            }
+        }
+        ResolvedExpr::PatternComprehension {
+            pattern,
+            where_,
+            map_expr,
+        } => {
+            collect_pattern_vars(pattern, out);
+            if let Some(w) = where_ {
+                collect_vars_inner(w, out);
+            }
+            collect_vars_inner(map_expr, out);
+        }
+        ResolvedExpr::Literal(_) | ResolvedExpr::Parameter(_) => {}
+    }
+}
+
+fn collect_pattern_vars(pattern: &lora_analyzer::ResolvedPattern, out: &mut BTreeSet<VarId>) {
+    use lora_analyzer::{ResolvedNode, ResolvedPatternElement};
+    let node = |n: &ResolvedNode, out: &mut BTreeSet<VarId>| {
+        out.extend(n.var);
+        if let Some(p) = &n.properties {
+            collect_vars_inner(p, out);
+        }
+    };
+    for part in &pattern.parts {
+        out.extend(part.binding);
+        match &part.element {
+            ResolvedPatternElement::Node {
+                var, properties, ..
+            } => {
+                out.extend(*var);
+                if let Some(p) = properties {
+                    collect_vars_inner(p, out);
+                }
+            }
+            ResolvedPatternElement::NodeChain { head, chain }
+            | ResolvedPatternElement::ShortestPath { head, chain, .. } => {
+                node(head, out);
+                for link in chain {
+                    out.extend(link.rel.var);
+                    if let Some(p) = &link.rel.properties {
+                        collect_vars_inner(p, out);
+                    }
+                    node(&link.node, out);
+                }
+            }
+        }
     }
 }
 

lora_python-0.17.0/crates/lora-database/tests/comparison_ordering.rs

@@ -0,0 +1,134 @@
+//! `<`, `<=`, `>`, `>=` follow Cypher ordering: lists compare element by
+//! element, null or incomparable operands give null (never false), and
+//! integers compare exactly. Regression for the Festimap brief's P0-5:
+//! `[f.name, f.key] > $after` silently matched nothing.
+
+mod test_helpers;
+use std::collections::BTreeMap;
+
+use lora_database::LoraValue;
+use serde_json::{json, Value};
+use test_helpers::TestDb;
+
+fn scalar(q: &str) -> Value {
+    TestDb::new().scalar(q)
+}
+
+#[test]
+fn keyset_list_comparison_matches_rows_after_the_cursor() {
+    let db = TestDb::new();
+    db.run(
+        "CREATE (:F {key: 'a', name: 'Tomorrowland'}), (:F {key: 'b', name: 'Awakenings'}), \
+         (:F {key: 'c', name: 'Lowlands'}), (:F {key: 'd', name: 'Awakenings'})",
+    );
+    let mut params = BTreeMap::new();
+    params.insert(
+        "after".to_string(),
+        LoraValue::List(vec![
+            LoraValue::String("Awakenings".into()),
+            LoraValue::String("b".into()),
+        ]),
+    );
+    let rows = db.run_with_params(
+        "MATCH (f:F) WHERE [f.name, f.key] > $after RETURN f.key AS k ORDER BY f.name, f.key",
+        params,
+    );
+    let keys: Vec<_> = rows.iter().map(|r| r["k"].clone()).collect();
+    assert_eq!(keys, vec![json!("d"), json!("c"), json!("a")]);
+}
+
+#[test]
+fn lists_of_equal_length_compare_lexicographically() {
+    assert_eq!(scalar("RETURN [1, 2] < [1, 3]"), json!(true));
+    assert_eq!(scalar("RETURN [1, 2] <= [1, 2]"), json!(true));
+    assert_eq!(scalar("RETURN [1, 2] > [1, 2]"), json!(false));
+    assert_eq!(scalar("RETURN [1, 2] >= [1, 2]"), json!(true));
+    assert_eq!(scalar("RETURN [2, 0] > [1, 9]"), json!(true));
+    assert_eq!(scalar("RETURN ['b', 'a'] < ['a', 'z']"), json!(false));
+}
+
+#[test]
+fn a_prefix_sorts_before_the_longer_list() {
+    assert_eq!(scalar("RETURN [1] < [1, 0]"), json!(true));
+    assert_eq!(scalar("RETURN [1, 0] > [1]"), json!(true));
+    assert_eq!(scalar("RETURN [] < [1]"), json!(true));
+    assert_eq!(scalar("RETURN [] >= []"), json!(true));
+    assert_eq!(scalar("RETURN [2] > [1, 5]"), json!(true));
+}
+
+#[test]
+fn nulls_in_lists_decide_only_when_reached() {
+    // The first differing pair decides before the null is reached.
+    assert_eq!(scalar("RETURN [1, null] < [2, 0]"), json!(true));
+    // A null pair before any difference makes the comparison null.
+    assert_eq!(scalar("RETURN [null, 1] < [2, 0]"), Value::Null);
+    assert_eq!(scalar("RETURN [1, null] <= [1, 2]"), Value::Null);
+    assert_eq!(scalar("RETURN [1, 2] > null"), Value::Null);
+}
+
+#[test]
+fn nested_lists_compare_recursively() {
+    assert_eq!(scalar("RETURN [[1, 2], 3] < [[1, 3], 0]"), json!(true));
+}
+
+#[test]
+fn incomparable_operands_are_null_not_false() {
+    assert_eq!(scalar("RETURN 1 < 'a'"), Value::Null);
+    assert_eq!(scalar("RETURN [1] < 1"), Value::Null);
+    assert_eq!(scalar("RETURN [1, 'a'] < [1, 2]"), Value::Null);
+    assert_eq!(
+        scalar("RETURN date('2026-01-01') < datetime('2026-01-02T00:00:00Z')"),
+        Value::Null
+    );
+    // So negating one cannot make it true.
+    assert_eq!(scalar("RETURN NOT (1 < 'a')"), Value::Null);
+    let db = TestDb::new();
+    db.run("CREATE (:N {v: 1}), (:N {v: 'x'})");
+    // 1 < 'm' is null, so NOT keeps it out; 'x' < 'm' is false, so NOT keeps it.
+    assert_eq!(
+        db.column("MATCH (n:N) WHERE NOT (n.v < 'm') RETURN n.v AS v", "v"),
+        vec![json!("x")]
+    );
+}
+
+#[test]
+fn integers_compare_exactly_above_2_pow_53() {
+    assert_eq!(
+        scalar("RETURN 9007199254740993 > 9007199254740992"),
+        json!(true)
+    );
+    assert_eq!(
+        scalar("RETURN [9007199254740993] > [9007199254740992]"),
+        json!(true)
+    );
+    assert_eq!(
+        scalar("RETURN 9007199254740993 > 9007199254740992.0"),
+        json!(true)
+    );
+    assert_eq!(scalar("RETURN 2 > 1.5"), json!(true));
+    assert_eq!(scalar("RETURN 1.5 < 2"), json!(true));
+    assert_eq!(scalar("RETURN 2 >= 2.0"), json!(true));
+    assert_eq!(scalar("RETURN -3 < -2.5"), json!(true));
+    assert_eq!(scalar("RETURN 9223372036854775807 < 1e19"), json!(true));
+    assert_eq!(scalar("RETURN 1 < 0.0 / 0.0"), Value::Null);
+}
+
+#[test]
+fn booleans_order_false_before_true() {
+    assert_eq!(scalar("RETURN false < true"), json!(true));
+    assert_eq!(scalar("RETURN [true, false] > [true, true]"), json!(false));
+}
+
+#[test]
+fn scalar_comparisons_are_unchanged() {
+    assert_eq!(scalar("RETURN 'a' < 'b'"), json!(true));
+    assert_eq!(
+        scalar("RETURN date('2026-01-01') < date('2026-01-02')"),
+        json!(true)
+    );
+    assert_eq!(
+        scalar("RETURN duration('PT1H') < duration('PT2H')"),
+        json!(true)
+    );
+    assert_eq!(scalar("RETURN 1 < null"), Value::Null);
+}

{lora_python-0.16.2 → lora_python-0.17.0}/crates/lora-database/tests/expressions.rs

@@ -329,6 +329,19 @@ fn head_of_empty_list_is_null() {
     assert!(TestDb::new().scalar("RETURN list.first([])").is_null());
 }
 
+/// `first()` is the standard name the support matrix lists (Festimap brief
+/// P2-2); it was unknown while `head()` worked.
+#[test]
+fn first_is_head() {
+    let db = TestDb::new();
+    assert_eq!(db.scalar("RETURN first([1, 2])"), 1);
+    assert_eq!(db.scalar("RETURN FIRST(['a'])"), "a");
+    assert!(db.scalar("RETURN first([])").is_null());
+    assert!(db.scalar("RETURN first(null)").is_null());
+    db.run("CREATE (:L {xs: [3, 4]})");
+    assert_eq!(db.scalar("MATCH (l:L) RETURN first(l.xs)"), 3);
+}
+
 // ============================================================
 // Range function
 // ============================================================

{lora_python-0.16.2 → lora_python-0.17.0}/crates/lora-database/tests/temporal_range_index.rs

@@ -210,10 +210,15 @@ fn comparisons_and_ordering_on_every_temporal_kind() {
             "RETURN ('2024-01-01T02:00:00+02:00'::DATETIME) > ('2024-01-01T00:00:00Z'::DATETIME) AS r",
             false,
         ),
-        ("RETURN ('2024-01-01'::DATE) < ('2024-01-02T00:00:00Z'::DATETIME) AS r", false),
     ] {
         assert_eq!(db.run(q), vec![json!({ "r": want })], "{q}");
     }
+    // Temporals of different kinds do not order against each other: the
+    // comparison is null, as in Cypher (tests/comparison_ordering.rs).
+    assert_eq!(
+        db.run("RETURN ('2024-01-01'::DATE) < ('2024-01-02T00:00:00Z'::DATETIME) AS r"),
+        vec![json!({ "r": null })]
+    );
 
     let rows = db.run(
         "UNWIND [('2024-10-01T00:00'::LOCAL_DATETIME), ('2024-09-01T00:00'::LOCAL_DATETIME), \

lora_python-0.17.0/crates/lora-database/tests/with_predicates.rs

@@ -0,0 +1,117 @@
+//! A `WITH ... WHERE` predicate that reads a projected variable only inside
+//! a pattern (`size([(a)<-[:T]-(x) | 1]) = 0`, `EXISTS { (a)--() }`) must
+//! stay above the projection that binds the variable. The optimizer's
+//! variable walk skipped patterns, so such a predicate was pushed below the
+//! projection and ran with the variable unbound: the pattern matched every
+//! relationship of the type, the query returned no rows, and it cost a
+//! scan per row (Festimap brief G-11: 0 rows in ~1 s instead of 125 in
+//! 0.5 ms).
+
+mod test_helpers;
+
+use std::collections::BTreeMap;
+
+use lora_database::{LoraValue, PlanTreeNode};
+use serde_json::{json, Value};
+use test_helpers::TestDb;
+
+fn graph() -> TestDb {
+    let db = TestDb::new();
+    db.run("CREATE CONSTRAINT m_key IF NOT EXISTS FOR (n:M) REQUIRE n.key IS UNIQUE");
+    db.run(
+        "UNWIND range(1, 40) AS i CREATE (m:M {key: toString(i)}) \
+         WITH m, i WHERE i % 2 = 0 CREATE (:P)-[:SENT]->(m)",
+    );
+    db
+}
+
+fn keys(db: &TestDb, query: &str) -> Vec<Value> {
+    let mut params = BTreeMap::new();
+    params.insert(
+        "keys".to_string(),
+        LoraValue::List((1..=6).map(|i| LoraValue::String(i.to_string())).collect()),
+    );
+    let mut out: Vec<Value> = db
+        .run_with_params(query, params)
+        .into_iter()
+        .map(|r| r["k"].clone())
+        .collect();
+    out.sort_by_key(|v| v.as_str().unwrap_or_default().parse::<i64>().unwrap_or(0));
+    out
+}
+
+fn odd() -> Vec<Value> {
+    vec![json!("1"), json!("3"), json!("5")]
+}
+
+#[test]
+fn pattern_comprehension_after_with_sees_the_projected_variable() {
+    let db = graph();
+    let written = "UNWIND $keys AS k MATCH (a:M) WHERE a.key = k \
+                   WITH a WHERE size([(a)<-[:SENT]-(x) WHERE x:P | 1]) = 0 RETURN a.key AS k";
+    let bound = "UNWIND $keys AS k MATCH (a:M) WHERE a.key = k \
+                 WITH a, size([(a)<-[:SENT]-(x) WHERE x:P | 1]) AS c WHERE c = 0 RETURN a.key AS k";
+    assert_eq!(keys(&db, written), odd());
+    assert_eq!(keys(&db, bound), odd());
+}
+
+#[test]
+fn without_a_seek_and_with_renames_too() {
+    let db = graph();
+    assert_eq!(
+        keys(
+            &db,
+            "MATCH (a:M) WHERE a.key IN $keys WITH a WHERE size([(a)<-[:SENT]-() | 1]) = 0 RETURN a.key AS k"
+        ),
+        odd()
+    );
+    assert_eq!(
+        keys(
+            &db,
+            "MATCH (a:M) WHERE a.key IN $keys WITH a AS b WHERE size([(b)<-[:SENT]-() | 1]) = 0 RETURN b.key AS k"
+        ),
+        odd()
+    );
+    assert_eq!(
+        keys(
+            &db,
+            "MATCH (a:M) WHERE a.key IN $keys WITH a WHERE NOT EXISTS { (a)<-[:SENT]-() } RETURN a.key AS k"
+        ),
+        odd()
+    );
+}
+
+fn operators(node: &PlanTreeNode, out: &mut Vec<String>) {
+    out.push(node.operator.clone());
+    for child in &node.children {
+        operators(child, out);
+    }
+}
+
+#[test]
+fn the_seek_feeding_the_with_is_kept() {
+    let db = graph();
+    let plan = db
+        .service
+        .explain(
+            "UNWIND $keys AS k MATCH (a:M) WHERE a.key = k \
+             WITH a WHERE size([(a)<-[:SENT]-(x) | 1]) = 0 RETURN a.key AS k",
+            None,
+        )
+        .unwrap();
+    let mut ops = Vec::new();
+    operators(&plan.tree.root, &mut ops);
+    assert!(ops.iter().any(|o| o == "NodeByPropertyScan"), "{ops:?}");
+    assert!(!ops.iter().any(|o| o == "NodeScan"), "{ops:?}");
+    // RETURN's projection, then the pattern predicate, then the WITH's
+    // projection that binds `a`: the predicate stays above it.
+    let with_projection = ops
+        .iter()
+        .enumerate()
+        .filter(|(_, o)| *o == "Projection")
+        .nth(1)
+        .map(|(i, _)| i)
+        .unwrap();
+    let first_filter = ops.iter().position(|o| o == "Filter").unwrap();
+    assert!(first_filter < with_projection, "{ops:?}");
+}