lora-python 0.11.2__tar.gz → 0.11.4__tar.gz

{lora_python-0.11.2 → lora_python-0.11.4}/Cargo.lock

@@ -773,7 +773,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "lora-ast",
  "lora-parser",
@@ -783,14 +783,14 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-binding-buffer"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "lora-database",
  "lora-store",
@@ -798,7 +798,7 @@ dependencies = [
 
 [[package]]
 name = "lora-compiler"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -807,7 +807,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "anyhow",
  "chacha20poly1305",
@@ -826,11 +826,12 @@ dependencies = [
  "serde_json",
  "thiserror",
  "tracing",
+ "web-time",
 ]
 
 [[package]]
 name = "lora-executor"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "blake3",
  "crc32fast",
@@ -848,11 +849,12 @@ dependencies = [
  "thiserror",
  "tracing",
  "unicode-normalization",
+ "web-time",
 ]
 
 [[package]]
 name = "lora-ffi"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -864,7 +866,7 @@ dependencies = [
 
 [[package]]
 name = "lora-node"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -879,7 +881,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "lora-ast",
  "pest",
@@ -890,7 +892,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -902,7 +904,7 @@ dependencies = [
 
 [[package]]
 name = "lora-query-wasm"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
@@ -915,7 +917,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "anyhow",
  "axum",
@@ -929,7 +931,7 @@ dependencies = [
 
 [[package]]
 name = "lora-snapshot"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "argon2",
  "blake3",
@@ -943,7 +945,7 @@ dependencies = [
 
 [[package]]
 name = "lora-store"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "crc32fast",
  "js-sys",
@@ -954,7 +956,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wal"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "crc32fast",
  "lora-store",
@@ -964,7 +966,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -980,7 +982,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.11.2"
+version = "0.11.4"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -1932,6 +1934,16 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "winapi"
 version = "0.3.9"

{lora_python-0.11.2 → lora_python-0.11.4}/Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.11.2"
+version = "0.11.4"
 license = "BUSL-1.1"
 authors = ["LoraDB, Inc."]
 repository = "https://github.com/lora-db/lora"
@@ -15,16 +15,16 @@ 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.11.2" }
-lora-parser = { path = "crates/lora-parser", version = "=0.11.2" }
-lora-analyzer = { path = "crates/lora-analyzer", version = "=0.11.2" }
-lora-compiler = { path = "crates/lora-compiler", version = "=0.11.2" }
-lora-store = { path = "crates/lora-store", version = "=0.11.2" }
-lora-snapshot = { path = "crates/lora-snapshot", version = "=0.11.2", default-features = false }
-lora-wal = { path = "crates/lora-wal", version = "=0.11.2" }
-lora-executor = { path = "crates/lora-executor", version = "=0.11.2", default-features = false }
-lora-database = { path = "crates/lora-database", version = "=0.11.2" }
-lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.11.2" }
+lora-ast = { path = "crates/lora-ast", version = "=0.11.4" }
+lora-parser = { path = "crates/lora-parser", version = "=0.11.4" }
+lora-analyzer = { path = "crates/lora-analyzer", version = "=0.11.4" }
+lora-compiler = { path = "crates/lora-compiler", version = "=0.11.4" }
+lora-store = { path = "crates/lora-store", version = "=0.11.4" }
+lora-snapshot = { path = "crates/lora-snapshot", version = "=0.11.4", default-features = false }
+lora-wal = { path = "crates/lora-wal", version = "=0.11.4" }
+lora-executor = { path = "crates/lora-executor", version = "=0.11.4", default-features = false }
+lora-database = { path = "crates/lora-database", version = "=0.11.4" }
+lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.11.4" }
 
 # External crates.
 anyhow = "1"
@@ -48,3 +48,5 @@ getrandom = "0.2"
 argon2 = "0.5"
 flate2 = "1"
 rayon = "1"
+
+web-time = "1"

{lora_python-0.11.2 → lora_python-0.11.4}/PKG-INFO

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

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-analyzer/src/analyzer/builtin_signatures.rs

@@ -476,10 +476,13 @@ pub const BUILTIN_ALIASES: &[BuiltinAlias] = &[
     alias("type.try_cast", "cast.try"),
     alias("type.can_cast", "cast.can"),
     alias("now", "temporal.now"),
+    alias("datetime", "temporal.now"),
     alias("timestamp", "temporal.timestamp"),
     alias("timezone", "temporal.timezone"),
     alias("new", "uuid.new"),
     alias("random", "math.random"),
+    alias("rand", "math.random"),
+    alias("range", "list.range"),
     // Cypher / historical compatibility aliases.
     alias("head", "list.first"),
     alias("last", "list.last"),

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-database/Cargo.toml

@@ -40,6 +40,7 @@ lora-wal.workspace = true
 
 serde_json.workspace = true
 tracing.workspace = true
+web-time.workspace = true
 
 [dev-dependencies]
 criterion.workspace = true

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-database/src/database/execute.rs

@@ -10,7 +10,9 @@
 
 use std::any::Any;
 use std::collections::BTreeMap;
-use std::time::{Duration, Instant};
+use std::time::Duration;
+
+use web_time::Instant;
 
 use anyhow::Result;
 use lora_ast::Statement;

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-database/src/database/occ.rs

@@ -14,7 +14,7 @@
 use std::any::Any;
 use std::collections::BTreeMap;
 use std::sync::Arc;
-use std::time::Instant;
+use web_time::Instant;
 
 use anyhow::Result;
 use lora_compiler::CompiledQuery;

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-database/src/database/profile.rs

@@ -14,7 +14,7 @@
 use std::any::Any;
 use std::collections::BTreeMap;
 use std::sync::Arc;
-use std::time::Instant;
+use web_time::Instant;
 
 use lora_compiler::plan_tree_from_compiled;
 use lora_executor::{

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-database/src/database/schema.rs

@@ -16,7 +16,8 @@
 
 use std::any::Any;
 use std::collections::BTreeMap;
-use std::time::Instant;
+
+use web_time::Instant;
 
 use anyhow::{anyhow, Result};
 use lora_ast::{

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-database/src/database/write_guard.rs

@@ -35,7 +35,9 @@
 use std::any::{Any, TypeId};
 use std::ops::{Deref, DerefMut};
 use std::sync::{Arc, MutexGuard, TryLockError};
-use std::time::{Duration, Instant};
+use std::time::Duration;
+
+use web_time::Instant;
 
 use anyhow::{anyhow, Result};
 use lora_executor::ExecutorError;

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-database/src/lib.rs

@@ -58,8 +58,8 @@ pub use lora_store::InMemoryGraph;
 // Snapshot surface — re-exported so bindings/servers don't need a direct
 // `lora-store` dependency just to name the meta / error types.
 pub use lora_snapshot::{
-    Compression, EncryptionKey, PasswordKdfParams, SnapshotCredentials, SnapshotEncryption,
-    SnapshotInfo, SnapshotOptions, SnapshotPassword, DATABASE_SNAPSHOT_MAGIC,
+    snapshot_info, Compression, EncryptionKey, PasswordKdfParams, SnapshotCredentials,
+    SnapshotEncryption, SnapshotInfo, SnapshotOptions, SnapshotPassword, DATABASE_SNAPSHOT_MAGIC,
 };
 pub use lora_store::{
     NodeId, NodeRecord, RelationshipId, RelationshipRecord, SnapshotError, SnapshotMeta,

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-database/src/transaction.rs

@@ -1,7 +1,9 @@
 use std::collections::BTreeMap;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, MutexGuard};
-use std::time::{Duration, Instant};
+use std::time::Duration;
+
+use web_time::Instant;
 
 use anyhow::Result;
 use thiserror::Error;

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-database/src/wal/archive/workspace.rs

@@ -1,7 +1,8 @@
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
-use std::time::{SystemTime, UNIX_EPOCH};
+
+use web_time::{SystemTime, UNIX_EPOCH};
 
 use lora_wal::WalError;
 

lora_python-0.11.4/crates/lora-database/tests/unwind_ingestion.rs

@@ -0,0 +1,219 @@
+//! UNWIND-driven bulk-ingestion tests.
+//!
+//! Covers the playground's canonical "fill the graph from a range" pattern:
+//! `UNWIND range(...) AS id CREATE (n {id, computed properties...})`. The
+//! shapes here are exactly what a user pastes into the playground when
+//! seeding a graph for exploration — Cypher-style function names, a CASE
+//! expression in the property map, and a non-trivial per-row workload.
+
+mod test_helpers;
+
+use serde_json::Value as JsonValue;
+use test_helpers::TestDb;
+
+// ============================================================
+// Cypher-compat aliases — these are the names a Neo4j user reaches for first
+// and must resolve to the canonical namespaced builtin without the analyzer
+// raising UnknownFunction.
+// ============================================================
+
+#[test]
+fn range_alias_resolves_to_list_range() {
+    let db = TestDb::new();
+    let rows = db.run("UNWIND range(1, 5) AS k RETURN k");
+    assert_eq!(rows.len(), 5);
+    assert_eq!(
+        rows.iter()
+            .map(|r| r["k"].as_i64().unwrap())
+            .collect::<Vec<_>>(),
+        vec![1, 2, 3, 4, 5],
+    );
+}
+
+#[test]
+fn range_alias_supports_step_argument() {
+    let db = TestDb::new();
+    let rows = db.run("UNWIND range(0, 10, 2) AS k RETURN k");
+    let values: Vec<i64> = rows.iter().map(|r| r["k"].as_i64().unwrap()).collect();
+    assert_eq!(values, vec![0, 2, 4, 6, 8, 10]);
+}
+
+#[test]
+fn rand_alias_resolves_to_math_random() {
+    let db = TestDb::new();
+    let rows = db.run("RETURN rand() AS r");
+    let r = rows[0]["r"].as_f64().unwrap();
+    assert!((0.0..1.0).contains(&r), "rand() outside [0,1): {r}");
+}
+
+#[test]
+fn datetime_alias_resolves_to_temporal_now() {
+    let db = TestDb::new();
+    let rows = db.run("RETURN datetime() AS t");
+    // temporal.now() is rendered as a typed datetime object; the shape
+    // and exact representation belong to temporal.rs — here we just assert
+    // the alias resolved (no error) and produced a non-null value.
+    assert!(!rows[0]["t"].is_null(), "datetime() returned null");
+}
+
+// ============================================================
+// The playground's canonical UNWIND-CREATE pattern.
+// ============================================================
+
+#[test]
+fn unwind_range_creates_nodes_with_properties() {
+    let db = TestDb::new();
+    db.run(
+        "WITH range(1, 100) AS ids \
+         UNWIND ids AS id \
+         CREATE (n:TestRecord { \
+            id: id, \
+            name: 'Record ' + toString(id), \
+            createdAt: datetime(), \
+            randomValue: rand(), \
+            status: CASE \
+                WHEN id % 3 = 0 THEN 'ACTIVE' \
+                WHEN id % 3 = 1 THEN 'PENDING' \
+                ELSE 'ARCHIVED' \
+            END \
+         })",
+    );
+
+    db.assert_count("MATCH (n:TestRecord) RETURN n", 100);
+}
+
+#[test]
+fn unwind_range_case_expression_distributes_across_buckets() {
+    let db = TestDb::new();
+    db.run(
+        "UNWIND range(1, 30) AS id \
+         CREATE (:Bucketed { \
+            id: id, \
+            status: CASE \
+                WHEN id % 3 = 0 THEN 'ACTIVE' \
+                WHEN id % 3 = 1 THEN 'PENDING' \
+                ELSE 'ARCHIVED' \
+            END \
+         })",
+    );
+
+    // 30 ids, divisible by 3 → 10 in each bucket.
+    let active = db
+        .exec_count("MATCH (n:Bucketed {status:'ACTIVE'}) RETURN n")
+        .unwrap();
+    let pending = db
+        .exec_count("MATCH (n:Bucketed {status:'PENDING'}) RETURN n")
+        .unwrap();
+    let archived = db
+        .exec_count("MATCH (n:Bucketed {status:'ARCHIVED'}) RETURN n")
+        .unwrap();
+    assert_eq!((active, pending, archived), (10, 10, 10));
+}
+
+#[test]
+fn unwind_range_tostring_concatenation_produces_unique_names() {
+    let db = TestDb::new();
+    db.run(
+        "UNWIND range(1, 50) AS id \
+         CREATE (:Named { id: id, name: 'Record ' + toString(id) })",
+    );
+
+    // Properties are unique per id, so name distinct count == row count.
+    let names: Vec<JsonValue> = db.column("MATCH (n:Named) RETURN n.name AS name", "name");
+    let mut set = std::collections::BTreeSet::new();
+    for n in &names {
+        set.insert(n.as_str().unwrap().to_string());
+    }
+    assert_eq!(set.len(), 50);
+    assert!(set.contains("Record 1"));
+    assert!(set.contains("Record 50"));
+}
+
+#[test]
+fn unwind_range_returning_created_nodes_yields_one_row_per_id() {
+    let db = TestDb::new();
+    let rows = db.run(
+        "UNWIND range(1, 25) AS id \
+         CREATE (n:Returned { id: id }) \
+         RETURN n.id AS id ORDER BY id",
+    );
+    assert_eq!(rows.len(), 25);
+    for (i, row) in rows.iter().enumerate() {
+        assert_eq!(row["id"].as_i64().unwrap() as usize, i + 1);
+    }
+}
+
+// ============================================================
+// Larger scale: the upper end of what the playground will plausibly accept
+// in a single statement. Kept modest (10k) because the parser/analyzer
+// recompile the entire UNWIND body per query — for true bulk loads the
+// playground should batch in ~2k chunks, see scale.rs.
+// ============================================================
+
+#[test]
+fn unwind_range_ten_thousand_nodes_single_statement() {
+    let db = TestDb::new();
+    db.run(
+        "UNWIND range(1, 10000) AS id \
+         CREATE (:BulkNode { id: id, kind: id % 7 })",
+    );
+
+    assert_eq!(db.service.node_count(), 10_000);
+
+    // Spot-check a value in the middle and at the boundaries.
+    let middle = db.scalar("MATCH (n:BulkNode {id: 5000}) RETURN n.kind");
+    assert_eq!(middle.as_i64().unwrap(), 5000 % 7);
+    let last = db.scalar("MATCH (n:BulkNode {id: 10000}) RETURN n.kind");
+    assert_eq!(last.as_i64().unwrap(), 10_000 % 7);
+}
+
+#[test]
+#[ignore = "100k-in-one-statement is slow; run with --ignored. Real bulk loads should batch."]
+fn unwind_range_one_hundred_thousand_nodes_single_statement() {
+    let db = TestDb::new();
+    db.run(
+        "WITH range(1, 100000) AS ids \
+         UNWIND ids AS id \
+         CREATE (n:TestRecord { \
+            id: id, \
+            name: 'Record ' + toString(id), \
+            randomValue: rand(), \
+            status: CASE \
+                WHEN id % 3 = 0 THEN 'ACTIVE' \
+                WHEN id % 3 = 1 THEN 'PENDING' \
+                ELSE 'ARCHIVED' \
+            END \
+         })",
+    );
+    assert_eq!(db.service.node_count(), 100_000);
+}
+
+#[test]
+fn batched_unwind_range_one_hundred_thousand_nodes() {
+    // The pattern the playground should actually use for large ingest:
+    // many small UNWIND statements rather than one huge one. Mirrors
+    // scale.rs's approach but at a size that's reasonable for the
+    // default `cargo test` run.
+    let db = TestDb::new();
+    const TOTAL: usize = 100_000;
+    const BATCH: usize = 2_000;
+
+    let mut i = 0;
+    while i < TOTAL {
+        let end = (i + BATCH).min(TOTAL);
+        db.run(&format!(
+            "UNWIND range({i}, {}) AS id \
+             CREATE (:Bulk {{ id: id, kind: id % 5 }})",
+            end - 1,
+        ));
+        i = end;
+    }
+
+    assert_eq!(db.service.node_count(), TOTAL);
+
+    let buckets = db.run("MATCH (n:Bulk) RETURN n.kind AS k, count(n) AS c ORDER BY k");
+    assert_eq!(buckets.len(), 5);
+    for row in &buckets {
+        assert_eq!(row["c"].as_i64().unwrap() as usize, TOTAL / 5);
+    }
+}

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-executor/Cargo.toml

@@ -31,6 +31,7 @@ blake3.workspace = true
 crc32fast.workspace = true
 flate2.workspace = true
 getrandom.workspace = true
+web-time.workspace = true
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 rayon = { workspace = true, optional = true }

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-executor/src/eval/builtins/list.rs

@@ -947,7 +947,7 @@ struct SimpleRng {
 
 impl SimpleRng {
     fn new() -> Self {
-        use std::time::{SystemTime, UNIX_EPOCH};
+        use web_time::{SystemTime, UNIX_EPOCH};
         let seed = SystemTime::now()
             .duration_since(UNIX_EPOCH)
             .map(|d| d.as_nanos() as u64)

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-executor/src/eval/builtins/math_ns.rs

@@ -146,7 +146,7 @@ fn sign(args: &[LoraValue]) -> LoraValue {
 }
 
 fn random() -> LoraValue {
-    use std::time::{SystemTime, UNIX_EPOCH};
+    use web_time::{SystemTime, UNIX_EPOCH};
     let nanos = SystemTime::now()
         .duration_since(UNIX_EPOCH)
         .map(|d| d.subsec_nanos())

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-executor/src/eval/builtins/temporal.rs

@@ -52,7 +52,7 @@ fn now(args: &[LoraValue]) -> LoraValue {
 }
 
 fn timestamp() -> LoraValue {
-    use std::time::{SystemTime, UNIX_EPOCH};
+    use web_time::{SystemTime, UNIX_EPOCH};
     let millis = SystemTime::now()
         .duration_since(UNIX_EPOCH)
         .map(|d| d.as_millis() as i64)

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-executor/src/executor/helpers.rs

@@ -34,7 +34,8 @@
 
 use std::cmp::Ordering;
 use std::collections::{BTreeMap, BTreeSet};
-use std::time::Instant;
+
+use web_time::Instant;
 
 use lora_analyzer::symbols::VarId;
 use lora_analyzer::{AggregateFunction, FunctionId, ResolvedExpr, ResolvedMapSelector};

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-executor/src/executor/immutable.rs

@@ -20,8 +20,8 @@ use lora_compiler::CompiledQuery;
 use lora_store::GraphStorage;
 
 use std::collections::BTreeMap;
-use std::time::Instant;
 use tracing::{error, trace};
+use web_time::Instant;
 
 use super::aggregate_rows;
 use super::helpers::{

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-executor/src/executor/mutable.rs

@@ -25,8 +25,8 @@ use lora_compiler::CompiledQuery;
 use lora_store::{GraphStorageMut, NodeId, Properties};
 
 use std::collections::BTreeMap;
-use std::time::Instant;
 use tracing::{debug, error, trace};
+use web_time::Instant;
 
 use super::aggregate_rows;
 use super::helpers::{

{lora_python-0.11.2 → lora_python-0.11.4}/crates/lora-executor/src/profile.rs

@@ -20,7 +20,8 @@
 use std::cell::RefCell;
 use std::collections::BTreeMap;
 use std::sync::{Arc, Mutex};
-use std::time::Instant;
+
+use web_time::Instant;
 
 use lora_compiler::physical::PhysicalNodeId;
 

{lora_python-0.11.2 → lora_python-0.11.4}/pyproject.toml

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