lora-python 0.23.0__tar.gz → 0.24.1__tar.gz

{lora_python-0.23.0 → lora_python-0.24.1}/Cargo.lock

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

{lora_python-0.23.0 → lora_python-0.24.1}/Cargo.toml

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

{lora_python-0.23.0 → lora_python-0.24.1}/PKG-INFO

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

{lora_python-0.23.0 → lora_python-0.24.1}/crates/lora-compiler/src/optimizer.rs

@@ -1560,7 +1560,7 @@ mod tests {
         };
         s.nodes_by_label.insert(label.to_string(), total);
         if let Some(d) = distinct {
-            s.node_distinct_values
+            std::sync::Arc::make_mut(&mut s.node_distinct_values)
                 .insert((label.to_string(), "id".to_string()), d);
         }
         s

{lora_python-0.23.0 → lora_python-0.24.1}/crates/lora-compiler/src/pattern.rs

@@ -343,10 +343,12 @@ impl<'a> PatternPlanner<'a> {
 
         let mut best = stats.label_count(label).unwrap_or(0);
         for key in self.seekable_keys(var, node) {
-            let indexed = stats
+            // A distinct count exists for every key some node of the label
+            // carries, indexed or not.
+            let counted = stats
                 .node_distinct_values
                 .contains_key(&(label.to_string(), key.clone()));
-            if indexed {
+            if counted {
                 if let Some(rows) = stats.estimate_node_property_equality(label, &key) {
                     best = best.min(rows);
                 }

{lora_python-0.23.0 → lora_python-0.24.1}/crates/lora-database/benches/memory_baseline.json

@@ -1,65 +1,65 @@
 {
   "_meta": {
     "default_tolerance_pct": 10,
-    "last_updated": "2026-09-29",
-    "notes": "Captured from `cargo bench -p lora-database --bench memory -- --quick` on Apple Silicon. Numbers are bytes from `MemoryReport::total_bytes()` after the build phase (or after_query for chain/star/social which run a representative MATCH after building). Tolerance is per-scenario; a regression beyond `total * (1 + tolerance_pct/100)` fails the gate. Bump the baseline whenever an intentional storage-shape change shifts a scenario. 2026-09-29: property maps became key-sorted vectors, index postings inline single ids, adjacency lists inline two edges. These are MemoryReport estimates; `cargo run --release -p lora-database --example heap_probe` measures real allocations. Later the same day: slabs, adjacency and label indexes became chunked copy-on-write vectors and index maps copy-on-write shards (structural sharing for staged writes)."
+    "last_updated": "2026-10-06",
+    "notes": "Captured from `cargo bench -p lora-database --bench memory -- --quick` on Apple Silicon. Numbers are bytes from `MemoryReport::total_bytes()` after the build phase (or after_query for chain/star/social which run a representative MATCH after building). Tolerance is per-scenario; a regression beyond `total * (1 + tolerance_pct/100)` fails the gate. Bump the baseline whenever an intentional storage-shape change shifts a scenario. 2026-09-29: property maps became key-sorted vectors, index postings inline single ids, adjacency lists inline two edges. These are MemoryReport estimates; `cargo run --release -p lora-database --example heap_probe` measures real allocations. Later the same day: slabs, adjacency and label indexes became chunked copy-on-write vectors and index maps copy-on-write shards (structural sharing for staged writes). 2026-10-06: labels and relationship types are interned (no per-record strings) and adjacency entries carry the type and neighbour inline. Later the same day: records are stored as encoded bytes with dictionary-numbered labels, types and keys. And index entries shrank (32-byte key, 16-byte id set, sorted-array RANGE partitions, no second exact-match map)."
   },
   "benchmarks": {
     "node_only_10k": {
-      "total_bytes": 3668174,
-      "bytes_per_node": 309.2,
+      "total_bytes": 969208,
+      "bytes_per_node": 38.7,
       "tolerance_pct": 10
     },
     "chain_1000.build": {
-      "total_bytes": 514627,
-      "bytes_per_node": 173.3,
-      "bytes_per_rel": 100.3,
+      "total_bytes": 187089,
+      "bytes_per_node": 23.7,
+      "bytes_per_rel": 22.1,
       "tolerance_pct": 10
     },
     "chain_10000.build": {
-      "total_bytes": 5161131,
-      "bytes_per_node": 173.3,
-      "bytes_per_rel": 101.2,
+      "total_bytes": 1847401,
+      "bytes_per_node": 23.5,
+      "bytes_per_rel": 23.1,
       "tolerance_pct": 10
     },
     "chain_100000.build": {
-      "total_bytes": 51531835,
-      "bytes_per_node": 173.1,
-      "bytes_per_rel": 100.9,
+      "total_bytes": 18660552,
+      "bytes_per_node": 24,
+      "bytes_per_rel": 24.6,
       "tolerance_pct": 10
     },
     "star_1000.build": {
-      "total_bytes": 346187,
-      "bytes_per_node": 172.3,
-      "bytes_per_rel": 99.3,
+      "total_bytes": 122523,
+      "bytes_per_node": 23.6,
+      "bytes_per_rel": 21.2,
       "tolerance_pct": 10
     },
     "star_10000.build": {
-      "total_bytes": 3594019,
-      "bytes_per_node": 173.2,
-      "bytes_per_rel": 100.2,
+      "total_bytes": 1263627,
+      "bytes_per_node": 24.4,
+      "bytes_per_rel": 22.2,
       "tolerance_pct": 10
     },
     "star_100000.build": {
-      "total_bytes": 35465315,
-      "bytes_per_node": 173.0,
-      "bytes_per_rel": 99.9,
+      "total_bytes": 12944780,
+      "bytes_per_node": 24.9,
+      "bytes_per_rel": 22.8,
       "tolerance_pct": 10
     },
     "social_20k_x8.build": {
-      "total_bytes": 42867985,
-      "bytes_per_node": 383.9,
-      "bytes_per_rel": 165.9,
+      "total_bytes": 11775011,
+      "bytes_per_node": 50.5,
+      "bytes_per_rel": 26.3,
       "tolerance_pct": 10
     },
     "vector_flat_5k_d128": {
-      "total_bytes": 6615020,
-      "bytes_per_node": 681.3,
+      "total_bytes": 5975474,
+      "bytes_per_node": 553.3,
       "tolerance_pct": 10
     },
     "vector_hnsw_5k_d128": {
-      "total_bytes": 10296500,
-      "bytes_per_node": 681.3,
+      "total_bytes": 9656954,
+      "bytes_per_node": 553.3,
       "tolerance_pct": 15
     }
   }

{lora_python-0.23.0 → lora_python-0.24.1}/crates/lora-database/examples/storage_baseline.rs

@@ -563,7 +563,7 @@ fn lat_mode(n: u64) {
     // --- raw store / facade -----------------------------------------
     let snap = db.snapshot();
     bench_batched("raw_with_node(borrow)", samples / 8, |r| {
-        let v = snap.with_node(r % n, |rec| rec.properties.len()).unwrap();
+        let v = snap.with_node(r % n, |rec| rec.properties().len()).unwrap();
         std::hint::black_box(v);
     });
     bench_batched("raw_node(clone record)", samples / 8, |r| {
@@ -595,8 +595,8 @@ fn lat_mode(n: u64) {
         let mut c = 0usize;
         for id in snap.node_ids_by_label("Person") {
             snap.with_node(id, |rec| {
-                if let Some(PropertyValue::Float(f)) = rec.properties.get("score") {
-                    if *f < -1.0 {
+                if let Some(lora_store::ValueRef::Float(f)) = rec.properties().get("score") {
+                    if f < -1.0 {
                         c += 1;
                     }
                 }
@@ -977,6 +977,278 @@ fn idlat_mode(n: u64) {
     }
 }
 
+// ---------------------------------------------------------------------------
+// hop mode: the traversal reads only, repeated in rounds, then a few writes
+// ---------------------------------------------------------------------------
+
+/// `hop <N>`: build the `lat` graph, then run `ROUNDS` rounds (default 5)
+/// of the point and traversal reads, so one process gives several
+/// medians per row to compare A/B builds with. `WRITES=1` adds the
+/// staged-write rows once at the end.
+fn hop_mode(n: u64) {
+    let samples: usize = std::env::var("SAMPLES")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(20_000);
+    let rounds: usize = std::env::var("ROUNDS")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(5);
+    let g = build(n, Props::All, true, true);
+    let db = Database::from_graph(g);
+    run(&db, "CREATE INDEX person_id FOR (p:Person) ON (p.id)");
+    let pid = |r: u64| LoraValue::Int((r % n) as i64);
+    let seek = "MATCH (p:Person {id: $id}) RETURN p.name AS name";
+    let hop1 = "MATCH (p:Person {id: $id})-[:KNOWS]->(m) RETURN m.id AS id";
+    let hop2 = "MATCH (p:Person {id: $id})-[:KNOWS]->()-[:KNOWS]->(m) RETURN m.id AS id";
+    q(&db, seek, params(&[("id", pid(1))]));
+    let types = vec!["KNOWS".to_string()];
+    for round in 0..rounds {
+        println!("round {round}");
+        bench("cy_index_seek", samples, |r| {
+            q(&db, seek, params(&[("id", pid(r))]));
+        });
+        bench("cy_1hop", samples, |r| {
+            q(&db, hop1, params(&[("id", pid(r))]));
+        });
+        bench("cy_2hop", samples, |r| {
+            q(&db, hop2, params(&[("id", pid(r))]));
+        });
+        let snap = db.snapshot();
+        bench_batched("raw_with_node(borrow)", samples / 8, |r| {
+            let v = snap.with_node(r % n, |rec| rec.properties().len()).unwrap();
+            std::hint::black_box(v);
+        });
+        bench_batched("raw_1hop_ids", samples / 8, |r| {
+            std::hint::black_box(snap.expand_ids(r % n, Direction::Right, &types));
+        });
+        bench_batched("raw_2hop_ids", samples / 8, |r| {
+            let mut c = 0usize;
+            for (_, m) in snap.expand_ids(r % n, Direction::Right, &types) {
+                c += snap.expand_ids(m, Direction::Right, &types).len();
+            }
+            std::hint::black_box(c);
+        });
+    }
+    if std::env::var("WRITES").is_err() {
+        return;
+    }
+    let write_samples: usize = std::env::var("WRITE_SAMPLES")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(2_000);
+    let rel_q = "MATCH (a:Person {id: $a}), (b:Person {id: $b}) CREATE (a)-[:KNOWS {w: 1}]->(b)";
+    bench("cy_create_rel(staged)", write_samples, |r| {
+        q(
+            &db,
+            rel_q,
+            params(&[("a", pid(r)), ("b", pid(splitmix(r)))]),
+        );
+    });
+    let mut next = n;
+    bench("db.graph_create_node(api)", write_samples, |_| {
+        let mut p = BTreeMap::new();
+        p.insert("id".to_string(), LoraValue::Int(next as i64));
+        next += 1;
+        db.graph_create_node(vec!["Person".into()], p).unwrap();
+    });
+    run(
+        &db,
+        "CREATE CONSTRAINT acct_key FOR (a:Account) REQUIRE a.key IS UNIQUE",
+    );
+    let set_q = "MATCH (p:Person {id: $id}) SET p.score = $v";
+    bench("cy_set_prop(staged: constraint)", write_samples, |r| {
+        q(
+            &db,
+            set_q,
+            params(&[("id", pid(r)), ("v", LoraValue::Float(2.5))]),
+        );
+    });
+}
+
+// ---------------------------------------------------------------------------
+// wide mode: records with many properties, and values that are not scalars
+// ---------------------------------------------------------------------------
+
+/// `wide <W>`: 20k `:Item` nodes with `W` integer properties `p000..`,
+/// a datetime and a point. Times reading and writing one property of a
+/// wide record, and reads of the datetime and the point.
+fn wide_mode(width: u64) {
+    let n = 20_000u64;
+    let db = Database::in_memory();
+    run(&db, "CREATE INDEX item_id FOR (i:Item) ON (i.id)");
+    let assignments: String = (0..width).map(|k| format!(", p{k:03}: i + {k}")).collect();
+    let mut start = 0;
+    while start < n {
+        let end = (start + 1000).min(n) - 1;
+        run(
+            &db,
+            &format!(
+                "UNWIND range({start}, {end}) AS i CREATE (:Item {{id: i, \
+                 created: datetime('2026-01-01T00:00:00Z') + duration({{minutes: i}}), \
+                 at: point({{latitude: 50.0 + (i % 100) / 100.0, longitude: 4.0}}){assignments}}})"
+            ),
+        );
+        start = end + 1;
+    }
+    let id = |r: u64| LoraValue::Int((r % n) as i64);
+    let last = format!("p{:03}", width.saturating_sub(1));
+    let samples = 10_000;
+    for (name, query) in [
+        (
+            "cy_read_first_prop",
+            "MATCH (i:Item {id: $id}) RETURN i.created AS v".to_string(),
+        ),
+        (
+            "cy_read_last_prop",
+            format!("MATCH (i:Item {{id: $id}}) RETURN i.{last} AS v"),
+        ),
+        (
+            "cy_read_point",
+            "MATCH (i:Item {id: $id}) RETURN i.at AS v".to_string(),
+        ),
+        (
+            "cy_read_whole_node",
+            "MATCH (i:Item {id: $id}) RETURN i".to_string(),
+        ),
+    ] {
+        bench(name, samples, |r| {
+            q(&db, &query, params(&[("id", id(r))]));
+        });
+    }
+    let set_last = format!("MATCH (i:Item {{id: $id}}) SET i.{last} = $v");
+    bench("cy_set_last_prop", samples, |r| {
+        q(
+            &db,
+            &set_last,
+            params(&[("id", id(r)), ("v", LoraValue::Int(r as i64))]),
+        );
+    });
+    bench("cy_set_new_then_remove", samples / 2, |r| {
+        q(
+            &db,
+            "MATCH (i:Item {id: $id}) SET i.zz = 1",
+            params(&[("id", id(r))]),
+        );
+        q(
+            &db,
+            "MATCH (i:Item {id: $id}) REMOVE i.zz",
+            params(&[("id", id(r))]),
+        );
+    });
+    bench("db.graph_set_node_property", samples, |r| {
+        db.graph_set_node_property(r % n, last.clone(), LoraValue::Int(r as i64))
+            .unwrap();
+    });
+    for (name, query) in [
+        (
+            "cy_scan_datetime_filter",
+            "MATCH (i:Item) WHERE i.created > datetime('2026-01-10T00:00:00Z') RETURN count(*) AS c",
+        ),
+        (
+            "cy_scan_point_filter",
+            "MATCH (i:Item) WHERE point.distance(i.at, point({latitude: 50.5, longitude: 4.0})) < 10000 RETURN count(*) AS c",
+        ),
+        ("cy_scan_int_filter", "MATCH (i:Item) WHERE i.p000 > 10000 RETURN count(*) AS c"),
+    ] {
+        let s = bench(name, 30, |_| {
+            q(&db, query, params(&[]));
+        });
+        println!("info {name} ns_per_node={:.1}", s.median / n as f64);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// labels mode: equality lookups that name no label
+// ---------------------------------------------------------------------------
+
+/// `labels <L>`: `L` labels of 1000 nodes each, every node with a unique
+/// `k`. Times an indexed equality lookup on `k` with and without a label:
+/// the lookup without one has to consider every label's nodes.
+fn labels_mode(labels: u64) {
+    let per_label = 1000u64;
+    let mut g = InMemoryGraph::new();
+    for i in 0..labels * per_label {
+        let mut p = Properties::new();
+        p.insert(intern("k"), PropertyValue::Int(i as i64));
+        g.create_node(vec![format!("L{}", i % labels)], p);
+    }
+    let n = labels * per_label;
+    // Build the index before timing.
+    g.find_node_ids_by_property(None, "k", &PropertyValue::Int(0));
+    bench_batched("raw_find_by_prop(label)", 4_000, |r| {
+        let i = r % n;
+        let label = format!("L{}", i % labels);
+        let ids = g.find_node_ids_by_property(Some(&label), "k", &PropertyValue::Int(i as i64));
+        assert_eq!(ids.len(), 1);
+    });
+    bench_batched("raw_find_by_prop(no label)", 4_000, |r| {
+        let i = r % n;
+        let ids = g.find_node_ids_by_property(None, "k", &PropertyValue::Int(i as i64));
+        assert_eq!(ids.len(), 1);
+    });
+    let db = Database::from_graph(g);
+    let query = "MATCH (n {k: $k}) RETURN n.k AS k";
+    // A pattern without a label is planned as a scan of every node, so
+    // this row grows with the graph; keep its sample count in step.
+    let samples = (20_000_000 / n).clamp(20, 20_000) as usize;
+    bench("cy_seek(no label)", samples, |r| {
+        q(&db, query, params(&[("k", LoraValue::Int((r % n) as i64))]));
+    });
+}
+
+// ---------------------------------------------------------------------------
+// scan mode: scans that stop early, and one that does not
+// ---------------------------------------------------------------------------
+
+/// `scan <N>`: build the `lat` graph and time label and all-node scans
+/// cut short by a `LIMIT`, plus one full filtered scan for reference.
+fn scan_mode(n: u64) {
+    let samples: usize = std::env::var("SAMPLES")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(2_000);
+    let scan_samples: usize = std::env::var("SCAN_SAMPLES")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(15);
+    let g = build(n, Props::All, true, true);
+    let db = Database::from_graph(g);
+    for (name, query) in [
+        (
+            "cy_label_scan_limit10",
+            "MATCH (p:Person) RETURN p.id AS id LIMIT 10",
+        ),
+        (
+            "cy_all_scan_limit10",
+            "MATCH (p) RETURN p.id AS id LIMIT 10",
+        ),
+        (
+            "cy_label_scan_filter_limit10",
+            "MATCH (p:Person) WHERE p.score > 0.5 RETURN p.id AS id LIMIT 10",
+        ),
+        (
+            "cy_label_scan_skip_limit",
+            "MATCH (p:Person) RETURN p.id AS id SKIP 5000 LIMIT 10",
+        ),
+    ] {
+        bench(name, samples, |_| {
+            q(&db, query, params(&[]));
+        });
+    }
+    let s = bench("cy_label_scan_filter", scan_samples, |_| {
+        q(
+            &db,
+            "MATCH (p:Person) WHERE p.score > 1000000.0 RETURN p.id AS id",
+            params(&[]),
+        );
+    });
+    println!(
+        "info cy_label_scan_filter ns_per_node={:.2}",
+        s.median / n as f64
+    );
+}
+
 fn main() {
     let args: Vec<String> = std::env::args().collect();
     let _ = Arc::new(0); // keep `Arc` import meaningful under cfg churn
@@ -987,6 +1259,12 @@ fn main() {
         Some("wal") => wal_mode(args[2].parse().unwrap()),
         Some("restart") => restart_mode(args[2].parse().unwrap()),
         Some("idlat") => idlat_mode(args[2].parse().unwrap()),
-        _ => eprintln!("usage: storage_baseline mem <variant> <N> | lat <N> | wal <N> | restart <N> | idlat <N>"),
+        Some("hop") => hop_mode(args[2].parse().unwrap()),
+        Some("scan") => scan_mode(args[2].parse().unwrap()),
+        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>"
+        ),
     }
 }