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

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

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

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

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

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

{lora_python-0.26.0 → 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.26.0 → 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.26.0 → lora_python-0.26.1}/crates/lora-executor/src/pull/scan.rs

@@ -39,14 +39,8 @@ pub struct NodeScanSource<'a, S: GraphStorage> {
     /// The currently-active input row. `None` means the next call
     /// must pull a fresh row from upstream.
     cur_row: Option<Row>,
-    /// One page of node ids for the current input row.
-    cur_ids: Vec<NodeId>,
-    /// Position into `cur_ids`.
-    cur_idx: usize,
-    /// Where the store's id scan resumes for the next page.
-    scan_cursor: u64,
-    /// The store has no more ids for the current input row.
-    scan_done: bool,
+    /// The node ids of the current input row.
+    ids: ScanIds,
     /// Fetch ids a page at a time (see [`StableStoreScope`]); otherwise
     /// all of them before the first row.
     paged: bool,
@@ -54,9 +48,73 @@ pub struct NodeScanSource<'a, S: GraphStorage> {
     cur_emitted: bool,
 }
 
-/// Node ids fetched per page of a streaming scan: a scan holds this many
-/// ids at a time instead of the whole label.
+/// Node ids fetched per page of a streaming scan: a scan holds at most
+/// this many ids at a time instead of the whole label.
 const SCAN_PAGE: usize = 1024;
+/// The first page of a scan. Pages double from here to [`SCAN_PAGE`], so a
+/// `LIMIT 10` does not fetch a thousand ids.
+const FIRST_SCAN_PAGE: usize = 32;
+
+/// The node ids one input row scans: fetched from the store a page at a
+/// time, pages doubling from [`FIRST_SCAN_PAGE`] to [`SCAN_PAGE`], or all
+/// at once.
+struct ScanIds {
+    /// The current page.
+    page: Vec<NodeId>,
+    /// Position into `page`.
+    idx: usize,
+    /// Where the store's id scan resumes for the next page.
+    cursor: u64,
+    /// Ids to fetch for the next page.
+    page_size: usize,
+    /// No page is left to fetch; the current one may still hold ids.
+    done: bool,
+}
+
+impl ScanIds {
+    fn new() -> Self {
+        Self {
+            page: Vec::new(),
+            idx: 0,
+            cursor: 0,
+            page_size: FIRST_SCAN_PAGE,
+            done: false,
+        }
+    }
+
+    /// Start over, for a new input row.
+    fn reset(&mut self) {
+        self.page.clear();
+        self.idx = 0;
+        self.cursor = 0;
+        self.page_size = FIRST_SCAN_PAGE;
+        self.done = false;
+    }
+
+    /// The next id of the current page.
+    #[inline]
+    fn next(&mut self) -> Option<NodeId> {
+        let id = *self.page.get(self.idx)?;
+        self.idx += 1;
+        Some(id)
+    }
+
+    /// Replace the page with the next ids carrying `label`, or of all
+    /// nodes.
+    fn fetch_page<S: GraphStorage>(&mut self, storage: &S, label: Option<&str>) {
+        self.page.clear();
+        self.idx = 0;
+        self.done = !storage.scan_node_ids(label, &mut self.cursor, self.page_size, &mut self.page);
+        self.page_size = (self.page_size * 2).min(SCAN_PAGE);
+    }
+
+    /// Replace the page with all of `ids`, the last page.
+    fn fetch_all(&mut self, ids: Vec<NodeId>) {
+        self.page = ids;
+        self.idx = 0;
+        self.done = true;
+    }
+}
 
 thread_local! {
     /// Set while a read-only pipeline is being built: nothing writes to
@@ -106,21 +164,11 @@ impl<'a, S: GraphStorage> NodeScanSource<'a, S> {
             storage,
             var,
             cur_row: None,
-            cur_ids: Vec::new(),
-            cur_idx: 0,
-            scan_cursor: 0,
-            scan_done: false,
+            ids: ScanIds::new(),
             paged: store_is_stable(),
             cur_emitted: false,
         }
     }
-
-    fn reset_scan(&mut self) {
-        self.cur_ids.clear();
-        self.cur_idx = 0;
-        self.scan_cursor = 0;
-        self.scan_done = false;
-    }
 }
 
 impl<'a, S: GraphStorage> RowSource for NodeScanSource<'a, S> {
@@ -130,7 +178,7 @@ impl<'a, S: GraphStorage> RowSource for NodeScanSource<'a, S> {
                 match self.upstream.next_row()? {
                     Some(row) => {
                         self.cur_row = Some(row);
-                        self.reset_scan();
+                        self.ids.reset();
                         self.cur_emitted = false;
                     }
                     None => return Ok(None),
@@ -138,7 +186,7 @@ impl<'a, S: GraphStorage> RowSource for NodeScanSource<'a, S> {
             }
 
             let Some(row_ref) = self.cur_row.as_ref() else {
-                self.reset_scan();
+                self.ids.reset();
                 self.cur_emitted = false;
                 continue;
             };
@@ -165,31 +213,18 @@ impl<'a, S: GraphStorage> RowSource for NodeScanSource<'a, S> {
 
             // Unbound case: yield one row per node id, fetching the ids
             // a page at a time.
-            if self.cur_idx >= self.cur_ids.len() {
-                if self.scan_done {
-                    self.cur_row = None;
-                    continue;
-                }
-                self.cur_ids.clear();
-                self.cur_idx = 0;
-                if self.paged {
-                    self.scan_done = !self.storage.scan_node_ids(
-                        None,
-                        &mut self.scan_cursor,
-                        SCAN_PAGE,
-                        &mut self.cur_ids,
-                    );
-                } else {
-                    self.cur_ids = self.storage.all_node_ids();
-                    self.scan_done = true;
-                }
-                continue;
+            if let Some(id) = self.ids.next() {
+                let mut new_row = row_ref.clone();
+                new_row.insert(self.var, LoraValue::Node(id));
+                return Ok(Some(new_row));
+            }
+            if self.ids.done {
+                self.cur_row = None;
+            } else if self.paged {
+                self.ids.fetch_page(self.storage, None);
+            } else {
+                self.ids.fetch_all(self.storage.all_node_ids());
             }
-            let id = self.cur_ids[self.cur_idx];
-            self.cur_idx += 1;
-            let mut new_row = row_ref.clone();
-            new_row.insert(self.var, LoraValue::Node(id));
-            return Ok(Some(new_row));
         }
     }
 }
@@ -210,10 +245,8 @@ pub struct NodeByLabelScanSource<'a, S: GraphStorage> {
     /// before the first row.
     single_label: Option<&'a str>,
     cur_row: Option<Row>,
-    cur_ids: Vec<NodeId>,
-    cur_idx: usize,
-    scan_cursor: u64,
-    scan_done: bool,
+    /// Candidate ids of the current input row.
+    ids: ScanIds,
     cur_emitted: bool,
 }
 
@@ -238,38 +271,18 @@ impl<'a, S: GraphStorage> NodeByLabelScanSource<'a, S> {
                 _ => None,
             },
             cur_row: None,
-            cur_ids: Vec::new(),
-            cur_idx: 0,
-            scan_cursor: 0,
-            scan_done: false,
+            ids: ScanIds::new(),
             cur_emitted: false,
         }
     }
 
-    fn reset_scan(&mut self) {
-        self.cur_ids.clear();
-        self.cur_idx = 0;
-        self.scan_cursor = 0;
-        self.scan_done = false;
-    }
-
     /// Fetch the next candidates for the current input row.
     fn fill_candidates(&mut self) {
-        self.cur_ids.clear();
-        self.cur_idx = 0;
         match self.single_label {
-            Some(label) => {
-                self.scan_done = !self.storage.scan_node_ids(
-                    Some(label),
-                    &mut self.scan_cursor,
-                    SCAN_PAGE,
-                    &mut self.cur_ids,
-                );
-            }
-            None => {
-                self.cur_ids = scan_node_ids_for_label_groups(self.storage, self.labels);
-                self.scan_done = true;
-            }
+            Some(label) => self.ids.fetch_page(self.storage, Some(label)),
+            None => self
+                .ids
+                .fetch_all(scan_node_ids_for_label_groups(self.storage, self.labels)),
         }
     }
 }
@@ -281,7 +294,7 @@ impl<'a, S: GraphStorage> RowSource for NodeByLabelScanSource<'a, S> {
                 match self.upstream.next_row()? {
                     Some(row) => {
                         self.cur_row = Some(row);
-                        self.reset_scan();
+                        self.ids.reset();
                         self.cur_emitted = false;
                     }
                     None => return Ok(None),
@@ -289,7 +302,7 @@ impl<'a, S: GraphStorage> RowSource for NodeByLabelScanSource<'a, S> {
             }
 
             let Some(row_ref) = self.cur_row.as_ref() else {
-                self.reset_scan();
+                self.ids.reset();
                 self.cur_emitted = false;
                 continue;
             };
@@ -316,13 +329,7 @@ impl<'a, S: GraphStorage> RowSource for NodeByLabelScanSource<'a, S> {
                 continue;
             }
 
-            while self.cur_idx < self.cur_ids.len() {
-                let Some(&id) = self.cur_ids.get(self.cur_idx) else {
-                    return Err(ExecutorError::RuntimeError(
-                        "label scan cursor index moved past candidate ids".into(),
-                    ));
-                };
-                self.cur_idx += 1;
+            while let Some(id) = self.ids.next() {
                 if !self.candidates_prefiltered {
                     let labels_ok = self
                         .storage
@@ -337,9 +344,8 @@ impl<'a, S: GraphStorage> RowSource for NodeByLabelScanSource<'a, S> {
                 return Ok(Some(new_row));
             }
 
-            if self.scan_done {
+            if self.ids.done {
                 self.cur_row = None;
-                self.cur_ids.clear();
             } else {
                 self.fill_candidates();
             }