lora-python 0.22.3__tar.gz → 0.24.0__tar.gz

{lora_python-0.22.3 → lora_python-0.24.0}/Cargo.lock

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

{lora_python-0.22.3 → lora_python-0.24.0}/Cargo.toml

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

{lora_python-0.22.3 → lora_python-0.24.0}/PKG-INFO

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

{lora_python-0.22.3 → lora_python-0.24.0}/crates/lora-compiler/src/lib.rs

@@ -10,17 +10,19 @@ pub use plan_tree::{plan_tree_from_compiled, PlanTree, PlanTreeNode};
 
 pub use logical::{
     Aggregation, Argument, Create, Delete, Expand, Filter, Foreach, Limit, LogicalOp, LogicalPlan,
-    Merge, NodeByPointScan, NodeByPropertyRangeScan, NodeByPropertyScan, NodeByTextScan, NodeScan,
-    OptionalMatch, PathBuild, PlanNodeId, PointPredicate, Projection, RelByPointScan,
-    RelByPropertyRangeScan, RelByTextScan, Remove, Set, Sort, SortLimit, TextPredicate, Unwind,
+    Merge, NodeByIdSeek, NodeByPointScan, NodeByPropertyRangeScan, NodeByPropertyScan,
+    NodeByTextScan, NodeScan, OptionalMatch, PathBuild, PlanNodeId, PointPredicate, Projection,
+    RelByIdSeek, RelByPointScan, RelByPropertyRangeScan, RelByTextScan, Remove, Set, Sort,
+    SortLimit, TextPredicate, Unwind,
 };
 pub use optimizer::Optimizer;
 pub use physical::{
     ArgumentExec, CreateExec, DeleteExec, ExpandExec, FilterExec, ForeachExec, HashAggregationExec,
-    LimitExec, MergeExec, NodeByLabelScanExec, NodeByPointScanExec, NodeByPropertyRangeScanExec,
-    NodeByPropertyScanExec, NodeByTextScanExec, NodeScanExec, OptionalMatchExec, PathBuildExec,
-    PhysicalNodeId, PhysicalOp, PhysicalPlan, ProjectionExec, RelByPointScanExec,
-    RelByPropertyRangeScanExec, RelByTextScanExec, RemoveExec, SetExec, SortExec, UnwindExec,
+    LimitExec, MergeExec, NodeByIdSeekExec, NodeByLabelScanExec, NodeByPointScanExec,
+    NodeByPropertyRangeScanExec, NodeByPropertyScanExec, NodeByTextScanExec, NodeScanExec,
+    OptionalMatchExec, PathBuildExec, PhysicalNodeId, PhysicalOp, PhysicalPlan, ProjectionExec,
+    RelByIdSeekExec, RelByPointScanExec, RelByPropertyRangeScanExec, RelByTextScanExec, RemoveExec,
+    SetExec, SortExec, UnwindExec,
 };
 pub use planner::Planner;
 

{lora_python-0.22.3 → lora_python-0.24.0}/crates/lora-compiler/src/logical.rs

@@ -17,6 +17,7 @@ pub struct LogicalPlan {
 pub enum LogicalOp {
     Argument(Argument),
     NodeScan(NodeScan),
+    NodeByIdSeek(NodeByIdSeek),
     NodeByPropertyScan(NodeByPropertyScan),
     NodeByPropertyRangeScan(NodeByPropertyRangeScan),
     NodeByTextScan(NodeByTextScan),
@@ -24,6 +25,7 @@ pub enum LogicalOp {
     RelByPropertyRangeScan(RelByPropertyRangeScan),
     RelByTextScan(RelByTextScan),
     RelByPointScan(RelByPointScan),
+    RelByIdSeek(RelByIdSeek),
     Expand(Expand),
     Filter(Filter),
     Projection(Projection),
@@ -104,6 +106,23 @@ pub struct NodeScan {
     pub labels: Vec<Vec<String>>,
 }
 
+/// Seek nodes by internal id, rewritten from `Filter(NodeScan)` when the
+/// filter has an `id(var) = value` or `id(var) IN list` conjunct whose
+/// value does not read `var`. Emits each existing node whose id equals
+/// the value (or one of the list's elements, once per distinct id) and
+/// whose labels match `labels`. The `Filter` stays above, so the id test
+/// and every other conjunct are still judged with expression semantics.
+#[derive(Debug, Clone)]
+pub struct NodeByIdSeek {
+    pub input: Option<PlanNodeId>,
+    pub var: VarId,
+    /// Each inner Vec is a disjunctive group (OR). Outer Vec is conjunctive (AND).
+    pub labels: Vec<Vec<String>>,
+    pub ids: ResolvedExpr,
+    /// `false`: `id(var) = ids`. `true`: `ids` is a list, `id(var) IN ids`.
+    pub in_list: bool,
+}
+
 #[derive(Debug, Clone)]
 pub struct NodeByPropertyScan {
     pub input: Option<PlanNodeId>,
@@ -233,6 +252,26 @@ pub struct RelByPointScan {
     pub predicate: PointPredicate,
 }
 
+/// Seek a relationship by internal id, rewritten from
+/// `Filter(Expand(NodeScan(src)))` when the filter has an `id(rel) = value`
+/// or `id(rel) IN list` conjunct. Binds `src`, `rel` and `dst` from the
+/// stored endpoints as the expand would (direction, `types`, both
+/// orientations of an undirected pattern, already-bound variables), and
+/// checks `src_labels` that the replaced scan carried. The `Filter` stays
+/// above.
+#[derive(Debug, Clone)]
+pub struct RelByIdSeek {
+    pub input: Option<PlanNodeId>,
+    pub src: VarId,
+    pub src_labels: Vec<Vec<String>>,
+    pub rel: VarId,
+    pub dst: VarId,
+    pub types: Vec<String>,
+    pub direction: Direction,
+    pub ids: ResolvedExpr,
+    pub in_list: bool,
+}
+
 #[derive(Debug, Clone)]
 pub struct Expand {
     pub input: PlanNodeId,

{lora_python-0.22.3 → lora_python-0.24.0}/crates/lora-compiler/src/optimizer.rs

@@ -176,6 +176,20 @@ impl Optimizer {
                 continue;
             };
 
+            // A seek by internal id reads at most one node per id, so it
+            // beats every other access path whatever the stats say (and an
+            // empty or stale stats snapshot must not keep a scan).
+            if let Some((ids, in_list)) = id_seek_value(&predicate, scan.var, NODE_ID_FUNCTIONS) {
+                plan.nodes[input_id] = LogicalOp::NodeByIdSeek(NodeByIdSeek {
+                    input: scan.input,
+                    var: scan.var,
+                    labels: scan.labels.clone(),
+                    ids,
+                    in_list,
+                });
+                continue;
+            }
+
             let candidates = collect_index_candidates(scan, &predicate, stats);
             let Some(best) = pick_best_candidate(&plan.nodes[input_id], candidates, stats) else {
                 continue;
@@ -209,12 +223,35 @@ impl Optimizer {
             let Some(rel_var) = expand.rel else {
                 continue;
             };
-            // Source must be a root, unconstrained NodeScan; otherwise
-            // replacing it can bypass upstream rows or an already-bound
-            // source variable.
             let LogicalOp::NodeScan(src_scan) = &plan.nodes[expand.input] else {
                 continue;
             };
+            if src_scan.var != expand.src {
+                continue;
+            }
+
+            // `id(r) = value`: seek the relationship and bind its endpoints.
+            // Unlike the index scans below this works under any source
+            // scan: the seek runs once per upstream row, checks the
+            // source's labels, and binds through already-bound variables.
+            if let Some((ids, in_list)) = id_seek_value(&predicate, rel_var, REL_ID_FUNCTIONS) {
+                plan.nodes[filter_input] = LogicalOp::RelByIdSeek(RelByIdSeek {
+                    input: src_scan.input,
+                    src: expand.src,
+                    src_labels: src_scan.labels.clone(),
+                    rel: rel_var,
+                    dst: expand.dst,
+                    types: expand.types.clone(),
+                    direction: expand.direction,
+                    ids,
+                    in_list,
+                });
+                continue;
+            }
+
+            // Source must be a root, unconstrained NodeScan; otherwise
+            // replacing it can bypass upstream rows or an already-bound
+            // source variable.
             if src_scan.input.is_some() || !src_scan.labels.is_empty() {
                 continue;
             }
@@ -292,6 +329,26 @@ fn lower_logical_op(op: LogicalOp) -> PhysicalOp {
 
         LogicalOp::NodeScan(scan) => lower_node_scan(scan),
 
+        LogicalOp::NodeByIdSeek(seek) => PhysicalOp::NodeByIdSeek(NodeByIdSeekExec {
+            input: seek.input,
+            var: seek.var,
+            labels: seek.labels,
+            ids: seek.ids,
+            in_list: seek.in_list,
+        }),
+
+        LogicalOp::RelByIdSeek(seek) => PhysicalOp::RelByIdSeek(RelByIdSeekExec {
+            input: seek.input,
+            src: seek.src,
+            src_labels: seek.src_labels,
+            rel: seek.rel,
+            dst: seek.dst,
+            types: seek.types,
+            direction: seek.direction,
+            ids: seek.ids,
+            in_list: seek.in_list,
+        }),
+
         LogicalOp::NodeByPropertyScan(scan) => {
             PhysicalOp::NodeByPropertyScan(NodeByPropertyScanExec {
                 input: scan.input,
@@ -819,6 +876,14 @@ fn score_logical_op(op: &LogicalOp, stats: &GraphStats) -> Option<u64> {
             // fraction of the labelled set.
             Some(base.div_ceil(5))
         }
+        LogicalOp::NodeByIdSeek(seek) => Some(id_seek_rows(&seek.ids, seek.in_list)),
+        LogicalOp::RelByIdSeek(seek) => {
+            let rows = id_seek_rows(&seek.ids, seek.in_list);
+            Some(match seek.direction {
+                lora_ast::Direction::Undirected => rows.saturating_mul(2),
+                _ => rows,
+            })
+        }
         LogicalOp::Filter(_) => None,
         LogicalOp::Expand(expand) => {
             // Used as the baseline when evaluating rel-index rewrites.
@@ -1294,6 +1359,75 @@ fn text_predicate_for_var(predicate: &ResolvedExpr, var: VarId) -> Option<TextCa
     })
 }
 
+/// The id functions whose result for a node is the node's id.
+pub(crate) const NODE_ID_FUNCTIONS: &[&str] = &["value.id", "node.id"];
+/// The id functions whose result for a relationship is its id.
+pub(crate) const REL_ID_FUNCTIONS: &[&str] = &["value.id", "edge.id"];
+
+/// `true` when `expr` is `f(var)` for one of the id functions `names`.
+pub(crate) fn is_id_of_var(expr: &ResolvedExpr, var: VarId, names: &[&str]) -> bool {
+    matches!(
+        expr,
+        ResolvedExpr::Function { function, distinct: false, args }
+            if args.len() == 1
+                && matches!(&args[0], ResolvedExpr::Variable(v) if *v == var)
+                && names.iter().any(|name| function.eq_ignore_ascii_case(name))
+    )
+}
+
+/// The first `id(var) = value` conjunct of an AND-tree (either side), or
+/// failing that the first `id(var) IN list`, where the value does not read
+/// `var`. Returns the value and whether it is an `IN` list. Equality comes
+/// first: it seeks one id, a list possibly many.
+fn id_seek_value(
+    predicate: &ResolvedExpr,
+    var: VarId,
+    names: &[&str],
+) -> Option<(ResolvedExpr, bool)> {
+    let conjuncts = and_conjuncts(predicate);
+    let free_of_var = |e: &ResolvedExpr| !collect_vars(e).contains(&var);
+    let equality = conjuncts.iter().find_map(|conjunct| {
+        let ResolvedExpr::Binary {
+            lhs,
+            op: BinaryOp::Eq,
+            rhs,
+        } = conjunct
+        else {
+            return None;
+        };
+        if is_id_of_var(lhs, var, names) && free_of_var(rhs) {
+            Some((**rhs).clone())
+        } else if is_id_of_var(rhs, var, names) && free_of_var(lhs) {
+            Some((**lhs).clone())
+        } else {
+            None
+        }
+    });
+    if let Some(value) = equality {
+        return Some((value, false));
+    }
+    conjuncts.iter().find_map(|conjunct| {
+        let ResolvedExpr::Binary {
+            lhs,
+            op: BinaryOp::In,
+            rhs,
+        } = conjunct
+        else {
+            return None;
+        };
+        (is_id_of_var(lhs, var, names) && free_of_var(rhs)).then(|| ((**rhs).clone(), true))
+    })
+}
+
+/// Estimated rows of an id seek: one per id (a literal list's length,
+/// otherwise one).
+fn id_seek_rows(ids: &ResolvedExpr, in_list: bool) -> u64 {
+    match (in_list, ids) {
+        (true, ResolvedExpr::List(items)) => items.len() as u64,
+        _ => 1,
+    }
+}
+
 /// Every `var.key = value` conjunct of an AND-tree, in order, where
 /// `value` does not mention `var`.
 fn property_equalities_for_var(
@@ -1426,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.22.3 → lora_python-0.24.0}/crates/lora-compiler/src/pattern.rs

@@ -265,14 +265,62 @@ impl<'a> PatternPlanner<'a> {
     /// first: true when the last node is clearly cheaper to start from
     /// (already bound, a key seek, or a smaller label).
     fn should_start_from_tail(&self, head: &ResolvedNode, chain: &[ResolvedChain]) -> bool {
-        let Some(last) = chain.last() else {
+        let (Some(first), Some(last)) = (chain.first(), chain.last()) else {
             return false;
         };
-        let head_cost = self.start_cost(head);
-        let tail_cost = self.start_cost(&last.node);
+        let head_cost = self
+            .start_cost(head)
+            .min(self.rel_seek_cost(head, &first.rel));
+        let tail_cost = self
+            .start_cost(&last.node)
+            .min(self.rel_seek_cost(&last.node, &last.rel));
         tail_cost < head_cost
     }
 
+    /// Cost of starting at `end` when the chain's relationship next to it,
+    /// `rel`, can be sought by id (`id(r) = value` pending): the optimizer
+    /// turns `Expand(NodeScan(end))` into a relationship seek, one row.
+    /// `u64::MAX` when it cannot.
+    fn rel_seek_cost(&self, end: &ResolvedNode, rel: &ResolvedRel) -> u64 {
+        let Some(rel_var) = rel.var else {
+            return u64::MAX;
+        };
+        // Inline properties put a Filter between the scan and the expand,
+        // which the seek rewrite does not look through.
+        if end.properties.is_some() || rel.properties.is_some() || rel.range.is_some() {
+            return u64::MAX;
+        }
+        if self.has_pending_id_seek(rel_var, crate::optimizer::REL_ID_FUNCTIONS) {
+            2
+        } else {
+            u64::MAX
+        }
+    }
+
+    /// Whether a pending conjunct `id(var) = value` / `id(var) IN list`
+    /// could be evaluated once `var` is bound (the value reads only
+    /// variables already available).
+    fn has_pending_id_seek(&self, var: VarId, names: &[&str]) -> bool {
+        self.pending.iter().any(|pending| {
+            if !pending
+                .needs
+                .iter()
+                .all(|v| *v == var || self.available.contains(v))
+            {
+                return false;
+            }
+            let ResolvedExpr::Binary { lhs, op, rhs } = &pending.expr else {
+                return false;
+            };
+            let is_id = |e: &ResolvedExpr| crate::optimizer::is_id_of_var(e, var, names);
+            match op {
+                BinaryOp::Eq => is_id(lhs) || is_id(rhs),
+                BinaryOp::In => is_id(lhs),
+                _ => false,
+            }
+        })
+    }
+
     /// Rough number of rows a scan of `node` would start with, if it were
     /// the first node planned from here.
     fn start_cost(&self, node: &ResolvedNode) -> u64 {
@@ -280,6 +328,10 @@ impl<'a> PatternPlanner<'a> {
         if self.available.contains(&var) || self.planner.is_bound(var) {
             return 0;
         }
+        // `id(var) = value`: a seek by id, one row.
+        if self.has_pending_id_seek(var, crate::optimizer::NODE_ID_FUNCTIONS) {
+            return 2;
+        }
         let stats = self.planner.stats();
         let label = match node.labels.as_slice() {
             [group, ..] if group.len() == 1 => Some(group[0].as_str()),
@@ -291,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.22.3 → lora_python-0.24.0}/crates/lora-compiler/src/physical.rs

@@ -18,6 +18,7 @@ pub enum PhysicalOp {
     Argument(ArgumentExec),
     NodeScan(NodeScanExec),
     NodeByLabelScan(NodeByLabelScanExec),
+    NodeByIdSeek(NodeByIdSeekExec),
     NodeByPropertyScan(NodeByPropertyScanExec),
     NodeByPropertyRangeScan(NodeByPropertyRangeScanExec),
     NodeByTextScan(NodeByTextScanExec),
@@ -25,6 +26,7 @@ pub enum PhysicalOp {
     RelByPropertyRangeScan(RelByPropertyRangeScanExec),
     RelByTextScan(RelByTextScanExec),
     RelByPointScan(RelByPointScanExec),
+    RelByIdSeek(RelByIdSeekExec),
     Expand(ExpandExec),
     Filter(FilterExec),
     Projection(ProjectionExec),
@@ -95,6 +97,16 @@ pub struct NodeByLabelScanExec {
     pub labels: Vec<Vec<String>>,
 }
 
+/// See [`crate::logical::NodeByIdSeek`].
+#[derive(Debug, Clone)]
+pub struct NodeByIdSeekExec {
+    pub input: Option<PhysicalNodeId>,
+    pub var: VarId,
+    pub labels: Vec<Vec<String>>,
+    pub ids: ResolvedExpr,
+    pub in_list: bool,
+}
+
 #[derive(Debug, Clone)]
 pub struct NodeByPropertyScanExec {
     pub input: Option<PhysicalNodeId>,
@@ -183,6 +195,20 @@ pub struct RelByPointScanExec {
     pub predicate: crate::logical::PointPredicate,
 }
 
+/// See [`crate::logical::RelByIdSeek`].
+#[derive(Debug, Clone)]
+pub struct RelByIdSeekExec {
+    pub input: Option<PhysicalNodeId>,
+    pub src: VarId,
+    pub src_labels: Vec<Vec<String>>,
+    pub rel: VarId,
+    pub dst: VarId,
+    pub types: Vec<String>,
+    pub direction: Direction,
+    pub ids: ResolvedExpr,
+    pub in_list: bool,
+}
+
 #[derive(Debug, Clone)]
 pub struct ExpandExec {
     pub input: PhysicalNodeId,

{lora_python-0.22.3 → lora_python-0.24.0}/crates/lora-compiler/src/plan_tree.rs

@@ -146,6 +146,37 @@ fn describe(op: &PhysicalOp) -> PlanDescription {
             d.insert("labels".to_string(), label_groups_str(&n.labels));
             PlanDescription::with_children("NodeByLabelScan", d, opt_input(n.input))
         }
+        PhysicalOp::NodeByIdSeek(n) => {
+            d.insert("var".to_string(), var_str(n.var));
+            if !n.labels.is_empty() {
+                d.insert("labels".to_string(), label_groups_str(&n.labels));
+            }
+            d.insert("ids".to_string(), expr_str(&n.ids));
+            if n.in_list {
+                d.insert("mode".to_string(), "in".to_string());
+            }
+            PlanDescription::with_children("NodeByIdSeek", d, opt_input(n.input))
+        }
+        PhysicalOp::RelByIdSeek(n) => {
+            d.insert("rel".to_string(), var_str(n.rel));
+            d.insert("src".to_string(), var_str(n.src));
+            d.insert("dst".to_string(), var_str(n.dst));
+            if !n.src_labels.is_empty() {
+                d.insert("src_labels".to_string(), label_groups_str(&n.src_labels));
+            }
+            if !n.types.is_empty() {
+                d.insert("types".to_string(), n.types.join("|"));
+            }
+            d.insert(
+                "direction".to_string(),
+                direction_str(n.direction).to_string(),
+            );
+            d.insert("ids".to_string(), expr_str(&n.ids));
+            if n.in_list {
+                d.insert("mode".to_string(), "in".to_string());
+            }
+            PlanDescription::with_children("RelByIdSeek", d, opt_input(n.input))
+        }
         PhysicalOp::NodeByPropertyScan(n) => {
             d.insert("var".to_string(), var_str(n.var));
             if !n.labels.is_empty() {