lora-python 0.25.1__tar.gz → 0.25.3__tar.gz

{lora_python-0.25.1 → lora_python-0.25.3}/Cargo.lock

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

{lora_python-0.25.1 → lora_python-0.25.3}/Cargo.toml

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

{lora_python-0.25.1 → lora_python-0.25.3}/PKG-INFO

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

{lora_python-0.25.1 → lora_python-0.25.3}/crates/lora-database/tests/carried_value_sharing.rs

@@ -2,7 +2,8 @@
 //! 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
+//! the list constructs each clone their working row per candidate, and a
+//! grouping key, DISTINCT and UNION each key every row. 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
@@ -67,6 +68,40 @@ const SITES: &[(&str, &str)] = &[
         "reduce",
         "RETURN reduce(s = 0, i IN range(1, 200) | s + i) AS n, size(big) AS b",
     ),
+    (
+        "grouping key",
+        "MATCH (c)<-[:IN]-(m:M) WITH big, count(m) AS n RETURN n, size(big) AS b",
+    ),
+    (
+        "grouping key of a buffered aggregate",
+        "MATCH (c)<-[:IN]-(m:M) WITH big, collect(m) AS ms RETURN size(ms) AS n, size(big) AS b",
+    ),
+    (
+        "distinct",
+        "MATCH (c)<-[:IN]-(m:M) WITH DISTINCT m, big RETURN count(m) AS n, size(big) AS b",
+    ),
+    (
+        "coalesce",
+        "MATCH (c)<-[:IN]-(m:M) WITH m, coalesce(big, []) AS l RETURN count(m) AS n, size(l) AS b",
+    ),
+    (
+        "case",
+        "MATCH (c)<-[:IN]-(m:M) WITH m, CASE WHEN m.i > 0 THEN big ELSE [] END AS l \
+         RETURN count(m) AS n, size(l) AS b",
+    ),
+    (
+        "function of a coalesce",
+        "MATCH (c)<-[:IN]-(m:M) WHERE size(coalesce(big, [])) >= 0 RETURN count(m) AS n, size(big) AS b",
+    ),
+    (
+        "comparison",
+        "MATCH (c)<-[:IN]-(m:M) WHERE big <> [m.i] RETURN count(m) AS n, size(big) AS b",
+    ),
+    (
+        "quantifier over the carried list",
+        "MATCH (c)<-[:IN]-(m:M) WHERE any(x IN big WHERE x = 1) OR size(big) = 0 \
+         RETURN count(m) AS n, size(big) AS b",
+    ),
     (
         "quantifier",
         "RETURN any(i IN range(1, 200) WHERE i < 0) AS n, size(big) AS b",
@@ -152,6 +187,63 @@ fn shared_values_are_independent_after_a_copy() {
     assert_eq!(rows[0]["x"], serde_json::Value::Null);
     assert_eq!(rows[0]["b"], 64);
 
+    // Grouping and DISTINCT tell equal lists from different ones, shared
+    // or not.
+    let rows = db.run(
+        "MATCH (m:M) WITH m, CASE WHEN m.i = 3 THEN range(2, 65) ELSE range(1, 64) END AS big \
+         WITH big, count(m) AS n RETURN big[0] AS first, n ORDER BY first",
+    );
+    assert_eq!(rows.len(), 2);
+    assert_eq!((&rows[0]["first"], &rows[0]["n"]), (&1.into(), &2.into()));
+    assert_eq!((&rows[1]["first"], &rows[1]["n"]), (&2.into(), &1.into()));
+    let rows = db.run(
+        "WITH range(1, 64) AS big MATCH (m:M) WITH big, m.i % 2 AS odd \
+         WITH DISTINCT big, odd RETURN size(big) AS b, odd ORDER BY odd",
+    );
+    assert_eq!(rows.len(), 2);
+    assert_eq!(rows[0]["b"], 64);
+    let rows = db.run(
+        "WITH range(1, 64) AS big MATCH (m:M) RETURN big \
+         UNION WITH range(1, 64) AS big RETURN big",
+    );
+    assert_eq!(rows.len(), 1);
+
+    // coalesce and CASE hand back the carried list or the fallback, per row.
+    let rows = db.run(
+        "WITH range(1, 64) AS big MATCH (m:M) \
+         WITH m, big, CASE WHEN m.i = 2 THEN null ELSE big END AS maybe \
+         WITH m, coalesce(maybe, [m.i]) AS l, CASE m.i WHEN 3 THEN big ELSE [] END AS k \
+         RETURN m.i AS i, size(l) AS l, size(k) AS k, l = k AS same ORDER BY i",
+    );
+    let got: Vec<_> = rows
+        .iter()
+        .map(|r| {
+            (
+                r["l"].as_i64().unwrap(),
+                r["k"].as_i64().unwrap(),
+                r["same"].as_bool().unwrap(),
+            )
+        })
+        .collect();
+    assert_eq!(got, [(64, 0, false), (1, 0, false), (64, 64, true)]);
+
+    // An error in a coalesce argument past the first non-null one still fails.
+    db.run_err("WITH range(1, 64) AS big RETURN coalesce(big, 1 / 0) AS l");
+
+    // Quantifiers, comprehensions and reduce walk the carried list.
+    let rows = db.run(
+        "WITH range(1, 64) AS big MATCH (m:M) \
+         RETURN m.i AS i, all(x IN big WHERE x > 0) AS a, none(x IN big WHERE x = m.i) AS n, \
+                size([x IN big WHERE x > m.i | x * 2]) AS c, reduce(s = 0, x IN big | s + x) AS r \
+         ORDER BY i",
+    );
+    for (row, i) in rows.iter().zip(1..) {
+        assert_eq!(row["a"], true);
+        assert_eq!(row["n"], false);
+        assert_eq!(row["c"], 64 - i);
+        assert_eq!(row["r"], 2080);
+    }
+
     // FOREACH over rows carrying a list writes once per element.
     db.run(
         "MATCH (c:C {key: 'c'}) WITH c, range(1, 100) AS big \

{lora_python-0.25.1 → lora_python-0.25.3}/crates/lora-database/tests/projection.rs

@@ -442,6 +442,30 @@ fn extended_map_projection() {
     assert_eq!(person["extra"], "val");
 }
 
+#[test]
+fn map_projection_of_null_is_null() {
+    // openCypher: `null {.key}` is null, whatever the selectors. A missing
+    // node (OPTIONAL MATCH, `head([])`) projects as null, and `collect`
+    // then drops it.
+    let db = TestDb::new();
+    db.run("CREATE (:N {key: 'lonely'})");
+    for query in [
+        "WITH null AS f RETURN f {.key} AS m",
+        "WITH null AS f RETURN f {.key, x: 1} AS m",
+        "WITH null AS f RETURN f {.*} AS m",
+        "OPTIONAL MATCH (f:Missing) RETURN f {.key} AS m",
+        "MATCH (n:N) RETURN head([(n)-[:AT]->(f) | f]) {.key} AS m",
+    ] {
+        let rows = db.run(query);
+        assert!(rows[0]["m"].is_null(), "{query}: {:?}", rows[0]["m"]);
+    }
+    let rows = db.run(
+        "MATCH (n:N) WITH head([(n)-[:AT]->(f) | f]) AS f \
+         RETURN collect(f {.key}) AS m",
+    );
+    assert_eq!(rows[0]["m"], serde_json::json!([]));
+}
+
 #[test]
 fn pattern_comprehension_in_return() {
     // Lora: pattern comprehension in RETURN

{lora_python-0.25.1 → lora_python-0.25.3}/crates/lora-executor/src/eval/binops.rs

@@ -58,6 +58,51 @@ pub(super) fn eval_in(lhs: &LoraValue, rhs: &LoraValue) -> LoraValue {
     }
 }
 
+/// `=`, `<>`, `<`, `>`, `<=`, `>=`. Takes its operands by reference: a
+/// comparison against a list the row carries must not copy it.
+pub(super) fn eval_comparison(op: &BinaryOp, lhs: &LoraValue, rhs: &LoraValue) -> LoraValue {
+    match op {
+        // Lora null semantics: any comparison involving null returns null.
+        BinaryOp::Eq => {
+            if matches!(lhs, LoraValue::Null) || matches!(rhs, LoraValue::Null) {
+                LoraValue::Null
+            } else {
+                LoraValue::Bool(value_eq(lhs, rhs))
+            }
+        }
+        BinaryOp::Ne => {
+            if matches!(lhs, LoraValue::Null) || matches!(rhs, LoraValue::Null) {
+                LoraValue::Null
+            } else {
+                LoraValue::Bool(!value_eq(lhs, rhs))
+            }
+        }
+
+        // Cypher ordering: null or incomparable operands give null; lists
+        // compare element by element. Two temporals of different kinds are
+        // an error rather than Cypher's null: `d >= date()` against a
+        // DATETIME `d` would otherwise drop every row without a word.
+        BinaryOp::Lt | BinaryOp::Gt | BinaryOp::Le | BinaryOp::Ge => {
+            match compare_values(lhs, rhs) {
+                None => {
+                    if let Some(msg) = temporal_kind_mismatch(lhs, rhs) {
+                        set_eval_error(msg);
+                    }
+                    LoraValue::Null
+                }
+                Some(ord) => LoraValue::Bool(match op {
+                    BinaryOp::Lt => ord.is_lt(),
+                    BinaryOp::Gt => ord.is_gt(),
+                    BinaryOp::Le => ord.is_le(),
+                    _ => ord.is_ge(),
+                }),
+            }
+        }
+
+        _ => LoraValue::Null,
+    }
+}
+
 pub(super) fn eval_binary(op: &BinaryOp, lhs: LoraValue, rhs: LoraValue) -> LoraValue {
     match op {
         // Lora three-valued boolean logic:
@@ -99,41 +144,8 @@ pub(super) fn eval_binary(op: &BinaryOp, lhs: LoraValue, rhs: LoraValue) -> Lora
             }
         }
 
-        // Lora null semantics: any comparison involving null returns null.
-        BinaryOp::Eq => {
-            if matches!(lhs, LoraValue::Null) || matches!(rhs, LoraValue::Null) {
-                LoraValue::Null
-            } else {
-                LoraValue::Bool(value_eq(&lhs, &rhs))
-            }
-        }
-        BinaryOp::Ne => {
-            if matches!(lhs, LoraValue::Null) || matches!(rhs, LoraValue::Null) {
-                LoraValue::Null
-            } else {
-                LoraValue::Bool(!value_eq(&lhs, &rhs))
-            }
-        }
-
-        // Cypher ordering: null or incomparable operands give null; lists
-        // compare element by element. Two temporals of different kinds are
-        // an error rather than Cypher's null: `d >= date()` against a
-        // DATETIME `d` would otherwise drop every row without a word.
-        BinaryOp::Lt | BinaryOp::Gt | BinaryOp::Le | BinaryOp::Ge => {
-            match compare_values(&lhs, &rhs) {
-                None => {
-                    if let Some(msg) = temporal_kind_mismatch(&lhs, &rhs) {
-                        set_eval_error(msg);
-                    }
-                    LoraValue::Null
-                }
-                Some(ord) => LoraValue::Bool(match op {
-                    BinaryOp::Lt => ord.is_lt(),
-                    BinaryOp::Gt => ord.is_gt(),
-                    BinaryOp::Le => ord.is_le(),
-                    _ => ord.is_ge(),
-                }),
-            }
+        BinaryOp::Eq | BinaryOp::Ne | BinaryOp::Lt | BinaryOp::Gt | BinaryOp::Le | BinaryOp::Ge => {
+            eval_comparison(op, &lhs, &rhs)
         }
 
         BinaryOp::Add => add_values(lhs, rhs),