lora-python 0.22.1__tar.gz → 0.22.2__tar.gz

{lora_python-0.22.1 → lora_python-0.22.2}/Cargo.lock

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

{lora_python-0.22.1 → lora_python-0.22.2}/Cargo.toml

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

{lora_python-0.22.1 → lora_python-0.22.2}/PKG-INFO

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

{lora_python-0.22.1 → lora_python-0.22.2}/crates/lora-compiler/src/planner.rs

@@ -186,9 +186,14 @@ impl Planner {
     }
 
     fn plan_match(&mut self, input: Option<PlanNodeId>, m: &ResolvedMatch) -> PlanNodeId {
-        if let (true, Some(upstream)) = (m.optional, input) {
+        if m.optional {
             // OPTIONAL MATCH: build the inner sub-plan that reads from Argument,
             // then wrap it in an OptionalMatch node that provides null-extension.
+            //
+            // A leading OPTIONAL MATCH has no upstream clause; openCypher
+            // drives it from the single empty unit row, so an empty match
+            // still yields one row with the pattern's variables null.
+            let upstream = input.unwrap_or_else(|| self.plan_unit_input());
 
             // Collect variables introduced by this pattern (for null-extension).
             let new_vars = pattern_binders(&m.pattern);

{lora_python-0.22.1 → lora_python-0.22.2}/crates/lora-database/tests/aggregation.rs

@@ -975,12 +975,9 @@ fn agg_collect_with_optional_match_filters_nulls() {
     // People with projects should have exactly 1 project each
     let bob = rows.iter().find(|r| r["name"] == "Bob").unwrap();
     assert_eq!(bob["projects"].as_array().unwrap().len(), 1);
-    // People without projects: collect may include null or be empty
-    // — test documents actual behavior rather than assuming reference semantics
+    // People without projects: collect() ignores nulls, so the list is empty.
     let dave = rows.iter().find(|r| r["name"] == "Dave").unwrap();
-    let dave_projects = dave["projects"].as_array().unwrap();
-    // Dave has no assignments, so list should be empty or contain a single null
-    assert!(dave_projects.len() <= 1);
+    assert_eq!(dave["projects"], serde_json::json!([]));
 }
 
 // ============================================================

lora_python-0.22.2/crates/lora-database/tests/collect_nulls.rs

@@ -0,0 +1,200 @@
+//! `collect()` ignores null values (openCypher): a null item is dropped,
+//! so a group whose values are all null collects to `[]`. Only top-level
+//! nulls go — a list or map that merely CONTAINS null is a value and is
+//! kept as-is.
+//!
+//! Regression: collect() kept nulls, so `UNWIND [1, null] AS x RETURN
+//! collect(x)` gave `[1, null]` and an unmatched OPTIONAL MATCH collected
+//! to `[null]`. Every case runs on each execution path (`execute`, the
+//! pull pipeline, both transaction modes).
+
+mod test_helpers;
+
+use lora_database::{Database, ExecuteOptions, InMemoryGraph, ResultFormat, Row, TransactionMode};
+use serde_json::{json, Value as JsonValue};
+use test_helpers::TestDb;
+
+#[derive(Clone, Copy, Debug)]
+enum Path {
+    Execute,
+    Stream,
+    TxReadWrite,
+    TxReadOnly,
+}
+
+const READ_PATHS: [Path; 4] = [
+    Path::Execute,
+    Path::Stream,
+    Path::TxReadWrite,
+    Path::TxReadOnly,
+];
+const WRITE_PATHS: [Path; 3] = [Path::Execute, Path::Stream, Path::TxReadWrite];
+
+fn rows_json(rows: Vec<Row>) -> Vec<JsonValue> {
+    rows.into_iter()
+        .map(|row| serde_json::to_value(row).unwrap())
+        .collect()
+}
+
+fn run_on(db: &Database<InMemoryGraph>, path: Path, query: &str) -> Vec<JsonValue> {
+    let run = || -> Result<Vec<JsonValue>, String> {
+        match path {
+            Path::Execute => {
+                let result = db
+                    .execute(
+                        query,
+                        Some(ExecuteOptions {
+                            format: ResultFormat::Rows,
+                        }),
+                    )
+                    .map_err(|e| e.to_string())?;
+                let json = serde_json::to_value(result).unwrap();
+                Ok(json
+                    .get("rows")
+                    .and_then(JsonValue::as_array)
+                    .cloned()
+                    .unwrap_or_default())
+            }
+            Path::Stream => {
+                let mut stream = db.stream(query).map_err(|e| e.to_string())?;
+                let mut rows = Vec::new();
+                while let Some(row) = stream.next_row().map_err(|e| e.to_string())? {
+                    rows.push(row);
+                }
+                stream.finish().map_err(|e| e.to_string())?;
+                Ok(rows_json(rows))
+            }
+            Path::TxReadWrite | Path::TxReadOnly => {
+                let mode = if matches!(path, Path::TxReadOnly) {
+                    TransactionMode::ReadOnly
+                } else {
+                    TransactionMode::ReadWrite
+                };
+                let mut tx = db.begin_transaction(mode).map_err(|e| e.to_string())?;
+                let rows = tx.execute_rows(query).map_err(|e| e.to_string())?;
+                tx.commit().map_err(|e| e.to_string())?;
+                Ok(rows_json(rows))
+            }
+        }
+    };
+    run().unwrap_or_else(|e| panic!("{path:?}: `{query}` failed: {e}"))
+}
+
+fn seeded() -> TestDb {
+    let db = TestDb::new();
+    db.run("CREATE (:P {k: 1})-[:X]->(:Q {v: 10}), (:P {k: 2})");
+    db
+}
+
+fn assert_read(query: &str, expected: JsonValue) {
+    for path in READ_PATHS {
+        let db = seeded();
+        let got = JsonValue::Array(run_on(&db.service, path, query));
+        assert_eq!(got, expected, "{path:?}: `{query}`");
+    }
+}
+
+#[test]
+fn top_level_nulls_are_dropped() {
+    assert_read(
+        "UNWIND [1, null, 2] AS x RETURN collect(x) AS xs",
+        json!([{"xs": [1, 2]}]),
+    );
+    assert_read(
+        "UNWIND [null, null] AS x RETURN collect(x) AS xs",
+        json!([{"xs": []}]),
+    );
+    assert_read(
+        "UNWIND [1, null] AS x WITH collect(x) AS xs RETURN size(xs) AS n",
+        json!([{"n": 1}]),
+    );
+}
+
+#[test]
+fn unmatched_optional_match_collects_to_empty() {
+    assert_read(
+        "OPTIONAL MATCH (u:Missing) RETURN collect(u) AS us",
+        json!([{"us": []}]),
+    );
+    assert_read(
+        "MATCH (p:P) OPTIONAL MATCH (p)-[:X]->(q:Q) \
+         RETURN p.k AS k, collect(q.v) AS vs ORDER BY k",
+        json!([{"k": 1, "vs": [10]}, {"k": 2, "vs": []}]),
+    );
+    assert_read(
+        "MATCH (p:P) OPTIONAL MATCH (p)-[:X]->(q:Q) \
+         WITH p, collect(q) AS qs RETURN p.k AS k, size(qs) AS n ORDER BY k",
+        json!([{"k": 1, "n": 1}, {"k": 2, "n": 0}]),
+    );
+}
+
+#[test]
+fn grouped_collect_drops_nulls_per_group() {
+    assert_read(
+        "UNWIND [{g: 1, v: null}, {g: 1, v: 2}, {g: 2, v: null}] AS r \
+         RETURN r.g AS g, collect(r.v) AS vs ORDER BY g",
+        json!([{"g": 1, "vs": [2]}, {"g": 2, "vs": []}]),
+    );
+}
+
+#[test]
+fn collect_distinct_drops_nulls() {
+    assert_read(
+        "UNWIND [1, null, 1, null, 2] AS x RETURN collect(DISTINCT x) AS xs",
+        json!([{"xs": [1, 2]}]),
+    );
+    assert_read(
+        "UNWIND [null] AS x RETURN collect(DISTINCT x) AS xs",
+        json!([{"xs": []}]),
+    );
+}
+
+#[test]
+fn collect_alongside_streaming_aggregates() {
+    // count/sum fold in streaming form; collect stays buffered. Mixing
+    // them in one projection exercises both shapes together.
+    assert_read(
+        "UNWIND [1, null, 3] AS x \
+         RETURN count(x) AS c, count(*) AS all, sum(x) AS s, collect(x) AS xs",
+        json!([{"c": 2, "all": 3, "s": 4, "xs": [1, 3]}]),
+    );
+}
+
+#[test]
+fn collect_inside_call_subquery() {
+    assert_read(
+        "UNWIND [1, 2] AS x \
+         CALL { WITH x UNWIND [x, null] AS y RETURN collect(y) AS ys } \
+         RETURN x, ys ORDER BY x",
+        json!([{"x": 1, "ys": [1]}, {"x": 2, "ys": [2]}]),
+    );
+    assert_read(
+        "CALL { OPTIONAL MATCH (u:Missing) RETURN collect(u) AS us } RETURN us",
+        json!([{"us": []}]),
+    );
+}
+
+#[test]
+fn values_that_contain_null_are_kept() {
+    assert_read(
+        "UNWIND [[1, null], null, {a: null}, []] AS x RETURN collect(x) AS xs",
+        json!([{"xs": [[1, null], {"a": null}, []]}]),
+    );
+    assert_read(
+        "UNWIND [[null], [null], null] AS x RETURN collect(DISTINCT x) AS xs",
+        json!([{"xs": [[null]]}]),
+    );
+}
+
+#[test]
+fn collect_after_a_write_drops_nulls() {
+    for path in WRITE_PATHS {
+        let db = seeded();
+        let rows = run_on(
+            &db.service,
+            path,
+            "UNWIND [1, null] AS x CREATE (n:N {v: x}) RETURN collect(n.v) AS vs",
+        );
+        assert_eq!(rows, vec![json!({"vs": [1]})], "{path:?}");
+    }
+}

lora_python-0.22.2/crates/lora-database/tests/optional_match_leading.rs

@@ -0,0 +1,224 @@
+//! An OPTIONAL MATCH that opens the query is driven by the single empty
+//! unit row, like every other leading clause. openCypher (and Neo4j) then
+//! return ONE row with the pattern's variables null when nothing matches.
+//!
+//! Regression: the planner only wrapped an OPTIONAL MATCH in its
+//! null-extending operator when an upstream clause existed, so a leading
+//! one planned as a plain MATCH and an empty match silently returned no
+//! rows (`OPTIONAL MATCH (u:Missing) RETURN u IS NULL` gave `[]`).
+//!
+//! Every case runs on each execution path: `Database::execute`, the pull
+//! pipeline (`Database::stream`), and `Transaction::execute_rows` in both
+//! transaction modes (read-only cases only for `ReadOnly`).
+
+mod test_helpers;
+
+use lora_database::{Database, ExecuteOptions, InMemoryGraph, ResultFormat, Row, TransactionMode};
+use serde_json::{json, Value as JsonValue};
+use test_helpers::TestDb;
+
+#[derive(Clone, Copy, Debug)]
+enum Path {
+    Execute,
+    Stream,
+    TxReadWrite,
+    TxReadOnly,
+}
+
+const READ_PATHS: [Path; 4] = [
+    Path::Execute,
+    Path::Stream,
+    Path::TxReadWrite,
+    Path::TxReadOnly,
+];
+const WRITE_PATHS: [Path; 3] = [Path::Execute, Path::Stream, Path::TxReadWrite];
+
+fn rows_json(rows: Vec<Row>) -> Vec<JsonValue> {
+    rows.into_iter()
+        .map(|row| serde_json::to_value(row).unwrap())
+        .collect()
+}
+
+fn run_on(db: &Database<InMemoryGraph>, path: Path, query: &str) -> Vec<JsonValue> {
+    let run = || -> Result<Vec<JsonValue>, String> {
+        match path {
+            Path::Execute => {
+                let result = db
+                    .execute(
+                        query,
+                        Some(ExecuteOptions {
+                            format: ResultFormat::Rows,
+                        }),
+                    )
+                    .map_err(|e| e.to_string())?;
+                let json = serde_json::to_value(result).unwrap();
+                Ok(json
+                    .get("rows")
+                    .and_then(JsonValue::as_array)
+                    .cloned()
+                    .unwrap_or_default())
+            }
+            Path::Stream => {
+                let mut stream = db.stream(query).map_err(|e| e.to_string())?;
+                let mut rows = Vec::new();
+                while let Some(row) = stream.next_row().map_err(|e| e.to_string())? {
+                    rows.push(row);
+                }
+                stream.finish().map_err(|e| e.to_string())?;
+                Ok(rows_json(rows))
+            }
+            Path::TxReadWrite | Path::TxReadOnly => {
+                let mode = if matches!(path, Path::TxReadOnly) {
+                    TransactionMode::ReadOnly
+                } else {
+                    TransactionMode::ReadWrite
+                };
+                let mut tx = db.begin_transaction(mode).map_err(|e| e.to_string())?;
+                let rows = tx.execute_rows(query).map_err(|e| e.to_string())?;
+                tx.commit().map_err(|e| e.to_string())?;
+                Ok(rows_json(rows))
+            }
+        }
+    };
+    run().unwrap_or_else(|e| panic!("{path:?}: `{query}` failed: {e}"))
+}
+
+fn seeded() -> TestDb {
+    let db = TestDb::new();
+    db.run("CREATE (:P {k: 1})-[:X]->(:Q {v: 10}), (:P {k: 2})");
+    db
+}
+
+fn assert_read(query: &str, expected: JsonValue) {
+    for path in READ_PATHS {
+        let db = seeded();
+        let got = JsonValue::Array(run_on(&db.service, path, query));
+        assert_eq!(got, expected, "{path:?}: `{query}`");
+    }
+}
+
+#[test]
+fn empty_leading_optional_match_yields_one_null_row() {
+    assert_read(
+        "OPTIONAL MATCH (u:Missing) RETURN u IS NULL AS missing",
+        json!([{"missing": true}]),
+    );
+    assert_read("OPTIONAL MATCH (u:Missing) RETURN u", json!([{"u": null}]));
+    assert_read(
+        "OPTIONAL MATCH (u:Missing) WITH u RETURN u",
+        json!([{"u": null}]),
+    );
+    assert_read(
+        "OPTIONAL MATCH (a:P)-[:Nope]->(b) RETURN a, b",
+        json!([{"a": null, "b": null}]),
+    );
+}
+
+#[test]
+fn aggregates_over_an_empty_leading_optional_match_are_unchanged() {
+    assert_read(
+        "OPTIONAL MATCH (u:Missing) RETURN count(u) AS n",
+        json!([{"n": 0}]),
+    );
+    assert_read(
+        "OPTIONAL MATCH (u:Missing) RETURN count(*) AS n",
+        json!([{"n": 1}]),
+    );
+}
+
+#[test]
+fn matching_leading_optional_match_returns_only_its_rows() {
+    assert_read(
+        "OPTIONAL MATCH (p:P) RETURN p.k AS k ORDER BY k",
+        json!([{"k": 1}, {"k": 2}]),
+    );
+    assert_read(
+        "OPTIONAL MATCH (p:P)-[:X]->(q:Q) RETURN p.k AS k, q.v AS v",
+        json!([{"k": 1, "v": 10}]),
+    );
+}
+
+#[test]
+fn where_that_filters_everything_yields_one_null_row() {
+    assert_read(
+        "OPTIONAL MATCH (p:P) WHERE p.k > 99 RETURN p",
+        json!([{"p": null}]),
+    );
+    assert_read(
+        "OPTIONAL MATCH (p:P) WHERE p.k = 2 RETURN p.k AS k",
+        json!([{"k": 2}]),
+    );
+}
+
+#[test]
+fn several_leading_optional_matches() {
+    assert_read(
+        "OPTIONAL MATCH (a:Missing) OPTIONAL MATCH (b:AlsoMissing) RETURN a, b",
+        json!([{"a": null, "b": null}]),
+    );
+    assert_read(
+        "OPTIONAL MATCH (a:Missing) OPTIONAL MATCH (p:P) RETURN a, p.k AS k ORDER BY k",
+        json!([{"a": null, "k": 1}, {"a": null, "k": 2}]),
+    );
+    assert_read(
+        "OPTIONAL MATCH (p:P) OPTIONAL MATCH (p)-[:X]->(q) RETURN p.k AS k, q.v AS v ORDER BY k",
+        json!([{"k": 1, "v": 10}, {"k": 2, "v": null}]),
+    );
+}
+
+#[test]
+fn optional_match_after_zero_rows_stays_zero_rows() {
+    assert_read(
+        "MATCH (n:Missing) WITH n OPTIONAL MATCH (m:Missing) RETURN m",
+        json!([]),
+    );
+    assert_read(
+        "MATCH (n:Missing) OPTIONAL MATCH (n)-[:X]->(m) RETURN m",
+        json!([]),
+    );
+}
+
+#[test]
+fn optional_match_after_an_input_row_is_unchanged() {
+    assert_read(
+        "UNWIND [1] AS x OPTIONAL MATCH (u:Missing) RETURN x, u",
+        json!([{"x": 1, "u": null}]),
+    );
+}
+
+#[test]
+fn leading_optional_match_inside_call_subquery() {
+    assert_read(
+        "UNWIND [1, 2] AS x CALL { OPTIONAL MATCH (u:Missing) RETURN u } RETURN x, u ORDER BY x",
+        json!([{"x": 1, "u": null}, {"x": 2, "u": null}]),
+    );
+}
+
+#[test]
+fn write_after_an_empty_leading_optional_match_runs_once() {
+    for path in WRITE_PATHS {
+        let db = seeded();
+        run_on(
+            &db.service,
+            path,
+            "OPTIONAL MATCH (u:Missing) CREATE (:Log)",
+        );
+        assert_eq!(
+            db.scalar("MATCH (l:Log) RETURN count(l) AS n"),
+            json!(1),
+            "{path:?}"
+        );
+
+        let rows = run_on(
+            &db.service,
+            path,
+            "OPTIONAL MATCH (p:P) CREATE (:Log {k: p.k}) RETURN count(*) AS n",
+        );
+        assert_eq!(rows, vec![json!({"n": 2})], "{path:?}");
+        assert_eq!(
+            db.scalar("MATCH (l:Log) RETURN count(l) AS n"),
+            json!(3),
+            "{path:?}"
+        );
+    }
+}

{lora_python-0.22.1 → lora_python-0.22.2}/crates/lora-executor/src/executor/helpers.rs

@@ -967,6 +967,10 @@ pub(crate) fn compute_aggregate_expr<S: GraphStorage>(
                     }
 
                     let mut values = eval_aggregate_arg_values(&args[0], rows, eval_ctx)?;
+                    // openCypher: collect() ignores null values. Only a
+                    // top-level null is dropped; a list or map that
+                    // merely contains nulls is kept as-is.
+                    values.retain(|v| !matches!(v, LoraValue::Null));
 
                     if *distinct {
                         values = dedup_values(values);

{lora_python-0.22.1 → lora_python-0.22.2}/pyproject.toml

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