lora-python 0.11.5__tar.gz → 0.13.0__tar.gz

{lora_python-0.11.5 → lora_python-0.13.0}/Cargo.lock

@@ -773,7 +773,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "lora-ast",
  "lora-builtins-meta",
@@ -784,14 +784,14 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-binding-buffer"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "lora-database",
  "lora-store",
@@ -799,11 +799,11 @@ dependencies = [
 
 [[package]]
 name = "lora-builtins-meta"
-version = "0.11.5"
+version = "0.13.0"
 
 [[package]]
 name = "lora-compiler"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -812,7 +812,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "chacha20poly1305",
@@ -824,6 +824,7 @@ dependencies = [
  "lora-ast",
  "lora-compiler",
  "lora-executor",
+ "lora-io",
  "lora-parser",
  "lora-snapshot",
  "lora-store",
@@ -836,7 +837,7 @@ dependencies = [
 
 [[package]]
 name = "lora-executor"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "blake3",
  "crc32fast",
@@ -859,7 +860,7 @@ dependencies = [
 
 [[package]]
 name = "lora-ffi"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -869,9 +870,20 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "lora-io"
+version = "0.13.0"
+dependencies = [
+ "lora-executor",
+ "lora-store",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
 [[package]]
 name = "lora-node"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -886,7 +898,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "lora-ast",
  "pest",
@@ -897,7 +909,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -909,7 +921,7 @@ dependencies = [
 
 [[package]]
 name = "lora-query-wasm"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
@@ -923,7 +935,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "axum",
@@ -937,7 +949,7 @@ dependencies = [
 
 [[package]]
 name = "lora-snapshot"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "argon2",
  "blake3",
@@ -946,12 +958,13 @@ dependencies = [
  "getrandom",
  "lora-store",
  "serde",
+ "serde_json",
  "thiserror",
 ]
 
 [[package]]
 name = "lora-store"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "crc32fast",
  "js-sys",
@@ -962,7 +975,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wal"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "crc32fast",
  "lora-store",
@@ -972,7 +985,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -988,7 +1001,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.11.5"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "lora-database",

{lora_python-0.11.5 → lora_python-0.13.0}/Cargo.toml

@@ -1,10 +1,10 @@
 [workspace]
-members = ["crates/lora-ast", "crates/lora-parser", "crates/lora-builtins-meta", "crates/lora-analyzer", "crates/lora-compiler", "crates/lora-store", "crates/lora-snapshot", "crates/lora-wal", "crates/lora-executor", "crates/lora-database", "crates/bindings/lora-python"]
+members = ["crates/lora-ast", "crates/lora-parser", "crates/lora-builtins-meta", "crates/lora-analyzer", "crates/lora-compiler", "crates/lora-store", "crates/lora-snapshot", "crates/lora-io", "crates/lora-wal", "crates/lora-executor", "crates/lora-database", "crates/bindings/lora-python"]
 resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.11.5"
+version = "0.13.0"
 license = "BUSL-1.1"
 authors = ["LoraDB, Inc."]
 repository = "https://github.com/lora-db/lora"
@@ -15,17 +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.11.5" }
-lora-parser = { path = "crates/lora-parser", version = "=0.11.5" }
-lora-builtins-meta = { path = "crates/lora-builtins-meta", version = "=0.11.5" }
-lora-analyzer = { path = "crates/lora-analyzer", version = "=0.11.5" }
-lora-compiler = { path = "crates/lora-compiler", version = "=0.11.5" }
-lora-store = { path = "crates/lora-store", version = "=0.11.5" }
-lora-snapshot = { path = "crates/lora-snapshot", version = "=0.11.5", default-features = false }
-lora-wal = { path = "crates/lora-wal", version = "=0.11.5" }
-lora-executor = { path = "crates/lora-executor", version = "=0.11.5", default-features = false }
-lora-database = { path = "crates/lora-database", version = "=0.11.5" }
-lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.11.5" }
+lora-ast = { path = "crates/lora-ast", version = "=0.13.0" }
+lora-parser = { path = "crates/lora-parser", version = "=0.13.0" }
+lora-builtins-meta = { path = "crates/lora-builtins-meta", version = "=0.13.0" }
+lora-analyzer = { path = "crates/lora-analyzer", version = "=0.13.0" }
+lora-compiler = { path = "crates/lora-compiler", version = "=0.13.0" }
+lora-store = { path = "crates/lora-store", version = "=0.13.0" }
+lora-snapshot = { path = "crates/lora-snapshot", version = "=0.13.0", default-features = false }
+lora-io = { path = "crates/lora-io", version = "=0.13.0" }
+lora-wal = { path = "crates/lora-wal", version = "=0.13.0" }
+lora-executor = { path = "crates/lora-executor", version = "=0.13.0", default-features = false }
+lora-database = { path = "crates/lora-database", version = "=0.13.0" }
+lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.13.0" }
 
 # External crates.
 anyhow = "1"

{lora_python-0.11.5 → lora_python-0.13.0}/PKG-INFO

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

{lora_python-0.11.5 → lora_python-0.13.0}/crates/lora-analyzer/src/analyzer/clauses.rs

@@ -54,6 +54,11 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
     pub(super) fn analyze_unwind(&mut self, u: &Unwind) -> Result<ResolvedUnwind, SemanticError> {
         let expr = self.analyze_expr(&u.expr)?;
         let alias = self.declare_fresh_variable(&u.alias.name)?;
+        // UNWIND iterates a list — typically `$rows` from a batched
+        // import, where each element is a map of arbitrary keys. The
+        // analyzer can't know the row shape, so let property access on
+        // the alias skip the graph-catalog check.
+        self.dynamic_property_vars.insert(alias);
 
         Ok(ResolvedUnwind { expr, alias })
     }

{lora_python-0.11.5 → lora_python-0.13.0}/crates/lora-analyzer/src/analyzer/state.rs

@@ -4,12 +4,18 @@ use lora_ast::{
     UpdatingClause,
 };
 use lora_store::GraphCatalog;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 
 pub struct Analyzer<'a, S: GraphCatalog + ?Sized> {
     pub(super) storage: &'a S,
     pub(super) scopes: ScopeStack,
     pub(super) symbols: SymbolTable,
+    /// Variables whose runtime value shape isn't tracked by the analyzer
+    /// (UNWIND-bound elements, anything that may legitimately hold a map
+    /// or list of maps). Property access on these vars must skip the
+    /// graph-catalog check — the caller can't know which keys the data
+    /// carries until rows are bound at execution time.
+    pub(super) dynamic_property_vars: BTreeSet<VarId>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -26,6 +32,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
             storage,
             scopes: ScopeStack::new(),
             symbols: SymbolTable::default(),
+            dynamic_property_vars: BTreeSet::new(),
         }
     }
 
@@ -324,7 +331,13 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
 
     pub(super) fn property_access_allowed(&self, base: &ResolvedExpr, key: &str) -> bool {
         match base {
-            ResolvedExpr::Map(_) => true,
+            // Map literals and query parameters carry their own keys —
+            // there's nothing in the graph catalog to check against.
+            ResolvedExpr::Map(_) | ResolvedExpr::Parameter(_) => true,
+            // Variables whose value shape isn't tracked (UNWIND-bound
+            // row elements, etc.) — the catalog can't speak to keys on
+            // values that come from `$params` at execution time.
+            ResolvedExpr::Variable(id) if self.dynamic_property_vars.contains(id) => true,
             _ => {
                 self.storage.has_property_key(key)
                     || (self.storage.node_count() == 0 && self.storage.relationship_count() == 0)

{lora_python-0.11.5 → lora_python-0.13.0}/crates/lora-analyzer/src/analyzer/tests.rs

@@ -31,6 +31,42 @@ fn create_allows_new_relationship_type_when_graph_is_not_empty() {
     ));
 }
 
+#[test]
+fn unwind_alias_allows_property_access_with_unknown_keys() {
+    // Regression: when the playground import driver runs
+    //     UNWIND $rows AS r CREATE (:Label {`User Id`: r.`User Id`})
+    // against a non-empty graph that has never seen "User Id" as a
+    // property key, the analyzer used to reject `r.\`User Id\`` as an
+    // unknown property. UNWIND-bound vars hold whatever the parameter
+    // payload carries, so property access on them must skip the
+    // catalog check.
+    let mut graph = InMemoryGraph::new();
+    let _ = graph.create_node(vec!["Other".into()], Properties::new());
+
+    let doc = parse_query(
+        "UNWIND $rows AS r CREATE (:People {`User Id`: r.`User Id`, `First Name`: r.`First Name`})",
+    )
+    .unwrap();
+    let mut analyzer = Analyzer::new(&graph);
+    analyzer
+        .analyze(&doc)
+        .expect("UNWIND-bound row variable should allow any property key");
+}
+
+#[test]
+fn parameter_property_access_allowed_with_unknown_keys() {
+    // Parameters are runtime maps the analyzer can't introspect — keys
+    // on `$ctx.foo` must not be gated by the graph catalog either.
+    let mut graph = InMemoryGraph::new();
+    let _ = graph.create_node(vec!["Other".into()], Properties::new());
+
+    let doc = parse_query("RETURN $ctx.user_id AS u").unwrap();
+    let mut analyzer = Analyzer::new(&graph);
+    analyzer
+        .analyze(&doc)
+        .expect("property access on a parameter should skip the catalog check");
+}
+
 // --- Vector function analyzer tests ----------------------------------
 
 #[test]

{lora_python-0.11.5 → lora_python-0.13.0}/crates/lora-database/Cargo.toml

@@ -36,6 +36,7 @@ lora-compiler.workspace = true
 lora-executor = { workspace = true, default-features = false }
 lora-store.workspace = true
 lora-snapshot.workspace = true
+lora-io.workspace = true
 lora-wal.workspace = true
 
 serde_json.workspace = true

{lora_python-0.11.5 → lora_python-0.13.0}/crates/lora-database/benches/fixtures.rs

@@ -22,10 +22,12 @@
 //! | `build_temporal_graph(n)`     | `:Event` / `:FOLLOWS`                | Events with date/time properties |
 //! | `build_spatial_graph(n)`      | `:Location` / `:CONNECTS_TO`         | Locations with point coords      |
 //! | `build_recommendation_graph`  | `:User`, `:Product` / `:BOUGHT`, etc | Bipartite user-product graph     |
+//! | `build_vector_graph(n, d, …)` | `:V`                                 | Vector index k-NN benchmarks     |
 
 use std::collections::BTreeMap;
 
 use lora_database::{Database, ExecuteOptions, InMemoryGraph, LoraValue, ResultFormat};
+use lora_store::{LoraVector, RawCoordinate, VectorCoordinateType};
 
 // ---------------------------------------------------------------------------
 // Wrapper (mirrors TestDb from integration tests but without serde_json dep)
@@ -600,3 +602,76 @@ pub fn build_recommendation_graph(n_users: usize, n_products: usize) -> BenchDb
 
     db
 }
+
+// ---------------------------------------------------------------------------
+// Vector graph builder
+// ---------------------------------------------------------------------------
+
+/// Deterministic LCG → f32 in roughly [-1, 1). Stable across platforms,
+/// no external dep. Used to seed vector fixtures so bench numbers are
+/// comparable across runs.
+fn vector_rng(seed: u64) -> impl FnMut() -> f32 {
+    let mut state = seed.wrapping_mul(0x9E37_79B9_7F4A_7C15).wrapping_add(1);
+    move || {
+        state = state
+            .wrapping_mul(6364136223846793005)
+            .wrapping_add(1442695040888963407);
+        let bits = (state >> 32) as u32 as i32;
+        bits as f32 / (i32::MAX as f32 + 1.0)
+    }
+}
+
+/// Build a graph of `n` `:V` nodes each carrying a `dim`-dimensional
+/// FLOAT32 vector under property `e`, with a pre-created VECTOR index
+/// `vidx`, similarity function `sim` (`"cosine"` or `"euclidean"`),
+/// and index provider `provider` (`"flat"` or `"hnsw"`).
+///
+/// Vectors are deterministic so the same fixture produces identical
+/// content across runs. Used by `bench_vector_knn` to compare flat
+/// vs HNSW throughput.
+pub fn build_vector_graph(n: usize, dim: usize, sim: &str, provider: &str) -> BenchDb {
+    let db = BenchDb::with_capacity_hint(n, 0);
+    db.run(&format!(
+        "CREATE VECTOR INDEX vidx FOR (v:V) ON (v.e) \
+         OPTIONS {{indexConfig: {{ \
+            `vector.dimensions`: {dim}, \
+            `vector.similarity_function`: '{sim}', \
+            `vector.indexProvider`: '{provider}' \
+         }}}}",
+    ));
+
+    let mut rng = vector_rng(0x5EED);
+    // Each vector is dim * 4 bytes stored; intermediate RawCoordinate is
+    // 16 bytes per coord. Keep peak per-batch RSS bounded.
+    let batch = 1_000usize;
+    let mut i = 0usize;
+    while i < n {
+        let end = (i + batch).min(n);
+        let count = end - i;
+        let vecs: Vec<LoraValue> = (0..count)
+            .map(|_| {
+                let coords: Vec<RawCoordinate> = (0..dim)
+                    .map(|_| RawCoordinate::Float(rng() as f64))
+                    .collect();
+                LoraValue::Vector(
+                    LoraVector::try_new(coords, dim as i64, VectorCoordinateType::Float32)
+                        .expect("vector construction"),
+                )
+            })
+            .collect();
+        let params = BTreeMap::from([("vecs".to_string(), LoraValue::List(vecs))]);
+        db.run_with_params("UNWIND $vecs AS e CREATE (:V {e: e})", params);
+        i = end;
+    }
+    db
+}
+
+/// A single deterministic query vector with the given seed and dim.
+pub fn build_vector_query(seed: u64, dim: usize) -> LoraVector {
+    let mut rng = vector_rng(seed);
+    let coords: Vec<RawCoordinate> = (0..dim)
+        .map(|_| RawCoordinate::Float(rng() as f64))
+        .collect();
+    LoraVector::try_new(coords, dim as i64, VectorCoordinateType::Float32)
+        .expect("vector construction")
+}

{lora_python-0.11.5 → lora_python-0.13.0}/crates/lora-database/benches/query_implementations.rs

@@ -595,6 +595,65 @@ fn bench_advanced_query_shapes(c: &mut Criterion) {
     group.finish();
 }
 
+/// k-NN throughput across providers and scales.
+///
+/// Flat: the Phase 1 baseline — every call scores every vector.
+/// HNSW: the Phase 2 approximate index. d=384 matches a typical
+/// sentence-transformer embedding. The 100k cases dominate total
+/// bench time; restrict with e.g.
+/// `cargo bench -- vector_knn/n_100000_cosine_hnsw` during iteration.
+fn bench_vector_knn(c: &mut Criterion) {
+    let mut group = c.benchmark_group("query/vector_knn");
+    group.throughput(Throughput::Elements(1));
+    // 100k flat is ~50ms per query; 100k HNSW is sub-millisecond.
+    // Give criterion enough headroom on both ends without an
+    // intolerable suite runtime.
+    group.measurement_time(Duration::from_secs(5));
+    group.sample_size(20);
+
+    let dim = 384usize;
+    let k = 10usize;
+    let query = build_vector_query(0xDEAD_BEEF, dim);
+
+    // Flat at every scale (baseline curve).
+    for &n in &[1_000usize, 10_000, 100_000] {
+        for &sim in &["cosine", "euclidean"] {
+            let db = build_vector_graph(n, dim, sim, "flat");
+            let name = format!("n_{n}_{sim}_flat_k{k}_d{dim}");
+            group.bench_function(&name, |b| {
+                b.iter(|| {
+                    let params =
+                        BTreeMap::from([("q".to_string(), LoraValue::Vector(query.clone()))]);
+                    run_params(
+                        &db,
+                        "CALL db.index.vector.queryNodes('vidx', 10, $q) YIELD node, score",
+                        params,
+                    );
+                });
+            });
+        }
+    }
+
+    // HNSW only at scales where the ANN structure pays for its
+    // construction cost. n=1k is dominated by procedure overhead and
+    // doesn't move on either backend; skip.
+    for &n in &[10_000usize, 100_000] {
+        let db = build_vector_graph(n, dim, "cosine", "hnsw");
+        let name = format!("n_{n}_cosine_hnsw_k{k}_d{dim}");
+        group.bench_function(&name, |b| {
+            b.iter(|| {
+                let params = BTreeMap::from([("q".to_string(), LoraValue::Vector(query.clone()))]);
+                run_params(
+                    &db,
+                    "CALL db.index.vector.queryNodes('vidx', 10, $q) YIELD node, score",
+                    params,
+                );
+            });
+        });
+    }
+    group.finish();
+}
+
 criterion_group! {
     name = benches;
     config = bench_config();
@@ -606,7 +665,8 @@ criterion_group! {
         bench_writes,
         bench_expressions_and_functions,
         bench_typed_values,
-        bench_advanced_query_shapes
+        bench_advanced_query_shapes,
+        bench_vector_knn
 }
 
 criterion_main!(benches);