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

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

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

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

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

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

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

{lora_python-0.25.3 → lora_python-0.26.1}/crates/lora-database/examples/storage_baseline.rs

@@ -12,6 +12,7 @@
 //!
 //! Modes:
 //!   storage_baseline mem <variant> <N>   one variant, retained heap + RSS
+//!   storage_baseline build <N> [rounds] bulk-build timings, node and relationship phases
 //!   storage_baseline lat <N>             latency suite + snapshot save/load
 //!   storage_baseline wal <N>             Cypher ingest with WAL, then recover()
 //!
@@ -36,12 +37,20 @@ use lora_store::{intern, GraphStorage, GraphStorageMut, Properties, PropertyValu
 
 struct Counting;
 static LIVE: AtomicIsize = AtomicIsize::new(0);
+/// High-water mark of `LIVE` since the last [`reset_peak`].
+static PEAK: AtomicIsize = AtomicIsize::new(0);
+
+#[inline]
+fn grew(delta: isize) {
+    let now = LIVE.fetch_add(delta, Ordering::Relaxed) + delta;
+    PEAK.fetch_max(now, Ordering::Relaxed);
+}
 
 unsafe impl GlobalAlloc for Counting {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
         let p = System.alloc(layout);
         if !p.is_null() {
-            LIVE.fetch_add(layout.size() as isize, Ordering::Relaxed);
+            grew(layout.size() as isize);
         }
         p
     }
@@ -52,10 +61,7 @@ unsafe impl GlobalAlloc for Counting {
     unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
         let p = System.realloc(ptr, layout, new_size);
         if !p.is_null() {
-            LIVE.fetch_add(
-                new_size as isize - layout.size() as isize,
-                Ordering::Relaxed,
-            );
+            grew(new_size as isize - layout.size() as isize);
         }
         p
     }
@@ -68,6 +74,15 @@ fn live() -> isize {
     LIVE.load(Ordering::Relaxed)
 }
 
+/// Start a new high-water mark at the current live heap.
+fn reset_peak() {
+    PEAK.store(live(), Ordering::Relaxed);
+}
+
+fn peak() -> isize {
+    PEAK.load(Ordering::Relaxed)
+}
+
 fn rss_bytes() -> u64 {
     let out = std::process::Command::new("ps")
         .args(["-o", "rss=", "-p", &std::process::id().to_string()])
@@ -164,6 +179,34 @@ fn build(n: u64, props: Props, rels: bool, rel_props: bool) -> InMemoryGraph {
     g
 }
 
+/// Bulk-build timings: the node phase and the relationship phase of
+/// [`build`] separately, `rounds` times in one process (compare minimums).
+fn build_mode(n: u64, rounds: usize) {
+    for round in 0..rounds {
+        let t = Instant::now();
+        let mut g = InMemoryGraph::new();
+        for i in 0..n {
+            g.create_node(vec!["Person".to_string()], node_props(i, Props::All));
+        }
+        let nodes_s = t.elapsed().as_secs_f64();
+        let t = Instant::now();
+        let w = intern("w");
+        for i in 0..n {
+            for k in 0..DEGREE {
+                let mut p = Properties::new();
+                p.insert(w.clone(), PropertyValue::Int(((i + k) % 100) as i64));
+                g.create_relationship(i, target(i, k, n), "KNOWS", p)
+                    .expect("rel");
+            }
+        }
+        let rels_s = t.elapsed().as_secs_f64();
+        let t = Instant::now();
+        drop(g);
+        let drop_s = t.elapsed().as_secs_f64();
+        println!("build round={round} nodes_s={nodes_s:.3} rels_s={rels_s:.3} drop_s={drop_s:.3}");
+    }
+}
+
 // ---------------------------------------------------------------------------
 // mem mode
 // ---------------------------------------------------------------------------
@@ -182,6 +225,9 @@ fn mem_mode(variant: &str, n: u64) {
     let rss0 = rss_bytes();
     let live0 = live();
     let t = Instant::now();
+    // Index variants: the index statement's heap high-water mark above
+    // what the graph holds once it returns (its temporaries).
+    let mut index_transient = None;
     let (nodes, rels, props_per_node, keep): (u64, u64, u64, Box<dyn std::any::Any>) = match variant
     {
         "bare" => (n, 0, 0, Box::new(build(n, Props::None, false, false))),
@@ -200,6 +246,7 @@ fn mem_mode(variant: &str, n: u64) {
         "range_idx" | "unique" | "hash_idx" | "range_idx_name" => {
             let g = build(n, Props::All, true, true);
             let db = Database::from_graph(g);
+            reset_peak();
             match variant {
                 "range_idx" => run(&db, "CREATE INDEX person_id FOR (p:Person) ON (p.id)"),
                 "range_idx_name" => run(&db, "CREATE INDEX person_name FOR (p:Person) ON (p.name)"),
@@ -216,6 +263,7 @@ fn mem_mode(variant: &str, n: u64) {
                 }
                 _ => unreachable!(),
             }
+            index_transient = Some(peak() - live());
             (n, n * DEGREE, 4, Box::new(db))
         }
         other => panic!("unknown variant {other}"),
@@ -223,19 +271,25 @@ fn mem_mode(variant: &str, n: u64) {
     let build_s = t.elapsed().as_secs_f64();
     let bytes = (live() - live0) as f64;
     let rss = rss_bytes().saturating_sub(rss0) as f64;
-    let estimate = if let Some(g) = keep.downcast_ref::<InMemoryGraph>() {
-        g.memory_estimate().total_bytes() as f64
-    } else if let Some(db) = keep.downcast_ref::<Database<InMemoryGraph>>() {
-        db.with_store(|g| g.memory_estimate().total_bytes()) as f64
+    let report = if let Some(g) = keep.downcast_ref::<InMemoryGraph>() {
+        Some(g.memory_estimate())
     } else {
-        0.0
+        keep.downcast_ref::<Database<InMemoryGraph>>()
+            .map(|db| db.with_store(|g| g.memory_estimate()))
     };
+    let estimate = report.as_ref().map_or(0.0, |r| r.total_bytes() as f64);
+    if std::env::var_os("MEM_REPORT").is_some() {
+        if let Some(r) = &report {
+            eprintln!("{r:#?}");
+        }
+    }
     println!(
         "mem variant={variant} nodes={nodes} rels={rels} props_per_node={props_per_node} \
          live_bytes={bytes:.0} rss_delta={rss:.0} estimate={estimate:.0} \
-         live_per_element={:.1} rss_per_element={:.1} build_s={build_s:.2}",
+         live_per_element={:.1} rss_per_element={:.1} build_s={build_s:.2}{}",
         bytes / (nodes + rels) as f64,
-        rss / (nodes + rels) as f64
+        rss / (nodes + rels) as f64,
+        index_transient.map_or(String::new(), |b| format!(" index_transient_bytes={b}")),
     );
     drop(keep);
 }
@@ -1255,6 +1309,10 @@ fn main() {
     let _ = Duration::ZERO;
     match args.get(1).map(String::as_str) {
         Some("mem") => mem_mode(&args[2], args[3].parse().unwrap()),
+        Some("build") => build_mode(
+            args[2].parse().unwrap(),
+            args.get(3).map_or(5, |r| r.parse().unwrap()),
+        ),
         Some("lat") => lat_mode(args[2].parse().unwrap()),
         Some("wal") => wal_mode(args[2].parse().unwrap()),
         Some("restart") => restart_mode(args[2].parse().unwrap()),
@@ -1264,7 +1322,7 @@ fn main() {
         Some("labels") => labels_mode(args[2].parse().unwrap()),
         Some("wide") => wide_mode(args[2].parse().unwrap()),
         _ => eprintln!(
-            "usage: storage_baseline mem <variant> <N> | lat <N> | wal <N> | restart <N> | idlat <N> | hop <N> | scan <N> | labels <L> | wide <W>"
+            "usage: storage_baseline mem <variant> <N> | build <N> [rounds] | lat <N> | wal <N> | restart <N> | idlat <N> | hop <N> | scan <N> | labels <L> | wide <W>"
         ),
     }
 }

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

@@ -641,3 +641,33 @@ fn return_exists_subquery_in_projection() {
                 EXISTS { MATCH (p)-[:MANAGES]->() } AS is_manager",
     );
 }
+
+// ============================================================
+// Dynamic property access
+// ============================================================
+
+#[test]
+fn dynamic_property_access_on_node_and_relationship() {
+    let db = TestDb::new();
+    db.run("CREATE (:User {name: 'Alice', age: 30})-[:KNOWS {since: 2020}]->(:User {name: 'Bob'})");
+    let rows = db.run(
+        "MATCH (a:User {name: 'Alice'})-[r:KNOWS]->() \
+         WITH a, r, 'name' AS k \
+         RETURN a[k] AS name, a['age'] AS age, a['missing'] AS missing, r['since'] AS since, \
+                [key IN keys(a) | a[key] = a.name OR a[key] = a.age] AS same",
+    );
+    assert_eq!(rows[0]["name"], "Alice");
+    assert_eq!(rows[0]["age"], 30);
+    assert!(rows[0]["missing"].is_null());
+    assert_eq!(rows[0]["since"], 2020);
+    assert_eq!(rows[0]["same"], serde_json::json!([true, true]));
+}
+
+#[test]
+fn dynamic_property_access_with_a_null_or_non_string_key_is_null() {
+    let db = TestDb::new();
+    db.run("CREATE (:User {name: 'Alice'})");
+    let rows = db.run("MATCH (n:User) RETURN n[null] AS a, n[1] AS b");
+    assert!(rows[0]["a"].is_null());
+    assert!(rows[0]["b"].is_null());
+}

{lora_python-0.25.3 → lora_python-0.26.1}/crates/lora-database/tests/streaming_scans.rs

@@ -32,6 +32,25 @@ fn paged_scans_return_every_node_once() {
     db.assert_count("MATCH (n:Missing) RETURN n", 0);
 }
 
+/// Pages start at 32 ids and double up to 1024: counts on and around
+/// each boundary (32, 32 + 64, ..., and past the first 1024-id page).
+#[test]
+fn paged_scans_end_on_and_around_page_boundaries() {
+    for n in [1, 31, 32, 33, 96, 97, 2016, 2017, 3040, 3041] {
+        let db = TestDb::new();
+        db.run(&format!("UNWIND range(1, {n}) AS i CREATE (:L {{i: i}})"));
+        db.assert_count("MATCH (n:L) RETURN n", n);
+        db.assert_count("MATCH (n) RETURN n", n);
+        db.assert_count("MATCH (n:L) RETURN n LIMIT 33", n.min(33));
+        let expected: Vec<i64> = (1..=n as i64).collect();
+        assert_eq!(
+            db.sorted_ints("MATCH (n:L) RETURN n.i AS i", "i"),
+            expected,
+            "n = {n}"
+        );
+    }
+}
+
 #[test]
 fn a_scan_feeding_a_write_does_not_see_that_write() {
     let db = seeded();

{lora_python-0.25.3 → lora_python-0.26.1}/crates/lora-executor/src/eval/expr.rs

@@ -261,6 +261,10 @@ pub fn eval_expr<S: GraphStorage>(
                 (LoraValue::Map(m), LoraValue::String(key)) => {
                     m.get(&key).cloned().unwrap_or(LoraValue::Null)
                 }
+                // `n[k]` reads the property `n.k` would.
+                (LoraValue::Node(_) | LoraValue::Relationship(_), LoraValue::String(key)) => {
+                    eval_property(&base, &key, ctx)
+                }
                 _ => LoraValue::Null,
             }
         }