lora-python 0.26.3__tar.gz → 0.27.1__tar.gz

{lora_python-0.26.3 → lora_python-0.27.1}/Cargo.lock

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

{lora_python-0.26.3 → lora_python-0.27.1}/Cargo.toml

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

{lora_python-0.26.3 → lora_python-0.27.1}/PKG-INFO

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

{lora_python-0.26.3 → lora_python-0.27.1}/crates/lora-compiler/src/lib.rs

@@ -3,6 +3,7 @@ pub mod optimizer;
 pub mod physical;
 pub mod plan_tree;
 
+mod param_fold;
 mod pattern;
 mod planner;
 
@@ -16,6 +17,7 @@ pub use logical::{
     Remove, Set, Sort, SortLimit, TextPredicate, Unwind,
 };
 pub use optimizer::Optimizer;
+pub use param_fold::NullnessOf;
 pub use physical::{
     ArgumentExec, CreateExec, DeleteExec, ExpandExec, FilterExec, ForeachExec, HashAggregationExec,
     LimitExec, MergeExec, NodeByIdSeekExec, NodeByLabelScanExec, NodeByPointScanExec,
@@ -36,6 +38,21 @@ pub struct CompiledQuery {
     pub parameters: std::collections::BTreeSet<String>,
     /// Additional UNION branches, each compiled independently.
     pub unions: Vec<CompiledUnionBranch>,
+    /// Parameters a filter tests with `IS NULL` / `IS NOT NULL`, with the
+    /// nullness the plan folded the test for (`Some(true)`: null; `None`:
+    /// unknown, not folded). The plan is valid only for parameters with
+    /// the same nullness; see [`CompiledQuery::fits`].
+    pub null_params: std::collections::BTreeMap<String, Option<bool>>,
+}
+
+impl CompiledQuery {
+    /// Whether this plan was built for parameters with the nullness
+    /// `nullness` reports.
+    pub fn fits(&self, nullness: NullnessOf<'_>) -> bool {
+        self.null_params
+            .iter()
+            .all(|(name, assumed)| nullness(name) == *assumed)
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -54,7 +71,21 @@ impl Compiler {
     /// then falls back to the conservative "commit any matching
     /// rewrite" behaviour that the runtime executor handles safely.
     pub fn compile(query: &ResolvedQuery, stats: &GraphStats) -> CompiledQuery {
-        let physical = compile_physical(query, stats);
+        Self::compile_for(query, stats, &|_| None)
+    }
+
+    /// [`Self::compile`] for parameters whose nullness `nullness` knows:
+    /// `$p IS NULL` and `$p IS NOT NULL` in a filter fold to constants, so
+    /// `$p IS NULL OR n.k IN $p` plans as the `IN` alone (or as no filter).
+    /// The result records what it assumed in
+    /// [`CompiledQuery::null_params`].
+    pub fn compile_for(
+        query: &ResolvedQuery,
+        stats: &GraphStats,
+        nullness: NullnessOf<'_>,
+    ) -> CompiledQuery {
+        let mut null_params = std::collections::BTreeMap::new();
+        let physical = compile_physical(query, stats, nullness, &mut null_params);
         let unions = query
             .unions
             .iter()
@@ -66,7 +97,7 @@ impl Compiler {
                 };
                 CompiledUnionBranch {
                     all: union_part.all,
-                    physical: compile_physical(&branch_query, stats),
+                    physical: compile_physical(&branch_query, stats, nullness, &mut null_params),
                 }
             })
             .collect();
@@ -75,13 +106,20 @@ impl Compiler {
             physical,
             unions,
             parameters: query.parameters.clone(),
+            null_params,
         }
     }
 }
 
-fn compile_physical(query: &ResolvedQuery, stats: &GraphStats) -> PhysicalPlan {
+fn compile_physical(
+    query: &ResolvedQuery,
+    stats: &GraphStats,
+    nullness: NullnessOf<'_>,
+    null_params: &mut std::collections::BTreeMap<String, Option<bool>>,
+) -> PhysicalPlan {
     let mut planner = Planner::with_stats(stats);
-    let logical = planner.plan(query);
+    let mut logical = planner.plan(query);
+    param_fold::fold_parameter_null_tests(&mut logical, nullness, null_params);
 
     let mut optimizer = Optimizer::new();
     let optimized = optimizer.optimize(logical, stats);

{lora_python-0.26.3 → lora_python-0.27.1}/crates/lora-compiler/src/optimizer.rs

@@ -874,9 +874,7 @@ fn score_logical_op(op: &LogicalOp, stats: &GraphStats) -> Option<u64> {
         }
         LogicalOp::NodeByPointScan(scan) => {
             let base = label_estimate(&scan.labels, stats)?;
-            // Spatial probes: bbox/distance usually returns a small
-            // fraction of the labelled set.
-            Some(base.div_ceil(5))
+            Some(point_scan_estimate(&scan.predicate, base))
         }
         LogicalOp::NodeByIdSeek(seek) => Some(id_seek_rows(&seek.ids, seek.in_list)),
         LogicalOp::RelByIdSeek(seek) => {
@@ -1008,50 +1006,90 @@ fn is_tautological_point(candidate: &PointCandidate) -> bool {
 /// `{longitude: 180, latitude: 90}::POINT` covers every WGS-84 point.
 /// Detecting the literal form avoids a trigram lookup that would yield
 /// every indexed row only to be re-filtered to the same set.
-fn is_world_bbox(lower_left: &ResolvedExpr, upper_right: &ResolvedExpr) -> bool {
-    /// Cypher parses `-180` as `Unary{Neg, Literal(180)}`, not as a
-    /// negative integer literal — peel one such layer so the
-    /// world-bbox detection works on natural query forms.
-    fn const_number(expr: &ResolvedExpr) -> Option<f64> {
-        match expr {
-            ResolvedExpr::Literal(LiteralValue::Float(v)) => Some(*v),
-            ResolvedExpr::Literal(LiteralValue::Integer(v)) => Some(*v as f64),
-            ResolvedExpr::Unary {
-                op: lora_ast::UnaryOp::Neg,
-                expr,
-            } => const_number(expr).map(|v| -v),
-            ResolvedExpr::Unary {
-                op: lora_ast::UnaryOp::Pos,
-                expr,
-            } => const_number(expr),
-            _ => None,
-        }
+/// Cypher parses `-180` as `Unary{Neg, Literal(180)}`, not as a negative
+/// integer literal: peel one such layer so the box checks below work on
+/// natural query forms.
+fn const_number(expr: &ResolvedExpr) -> Option<f64> {
+    match expr {
+        ResolvedExpr::Literal(LiteralValue::Float(v)) => Some(*v),
+        ResolvedExpr::Literal(LiteralValue::Integer(v)) => Some(*v as f64),
+        ResolvedExpr::Unary {
+            op: lora_ast::UnaryOp::Neg,
+            expr,
+        } => const_number(expr).map(|v| -v),
+        ResolvedExpr::Unary {
+            op: lora_ast::UnaryOp::Pos,
+            expr,
+        } => const_number(expr),
+        _ => None,
     }
+}
 
-    fn point_lon_lat(expr: &ResolvedExpr) -> Option<(f64, f64)> {
-        let items = point_literal_map(expr)?;
-        let mut lon: Option<f64> = None;
-        let mut lat: Option<f64> = None;
-        for (key, value) in items {
-            let n = const_number(value)?;
-            match key.as_str() {
-                "longitude" | "x" => lon = Some(n),
-                "latitude" | "y" => lat = Some(n),
-                _ => {}
+/// `(x, y)` of a literal `point({...})`, and whether it names longitude
+/// and latitude (rather than cartesian `x` / `y`).
+fn literal_point(expr: &ResolvedExpr) -> Option<(f64, f64, bool)> {
+    let items = point_literal_map(expr)?;
+    let mut lon: Option<f64> = None;
+    let mut lat: Option<f64> = None;
+    let mut geographic = false;
+    for (key, value) in items {
+        let n = const_number(value)?;
+        match key.as_str() {
+            "longitude" => {
+                lon = Some(n);
+                geographic = true;
             }
+            "latitude" => lat = Some(n),
+            "x" => lon = Some(n),
+            "y" => lat = Some(n),
+            _ => {}
         }
-        Some((lon?, lat?))
     }
+    Some((lon?, lat?, geographic))
+}
 
-    let Some((ll_lon, ll_lat)) = point_lon_lat(lower_left) else {
+fn is_world_bbox(lower_left: &ResolvedExpr, upper_right: &ResolvedExpr) -> bool {
+    let Some((ll_lon, ll_lat, _)) = literal_point(lower_left) else {
         return false;
     };
-    let Some((ur_lon, ur_lat)) = point_lon_lat(upper_right) else {
+    let Some((ur_lon, ur_lat, _)) = literal_point(upper_right) else {
         return false;
     };
     ll_lon <= -180.0 && ll_lat <= -90.0 && ur_lon >= 180.0 && ur_lat >= 90.0
 }
 
+/// Rows a point-index probe is estimated to return out of `base`.
+///
+/// A literal geographic box covers its share of the globe. A box built
+/// from parameters or from the row (one per venue of a page, say) cannot
+/// be measured, and is taken as narrow: such a box is drawn around a
+/// place, so it beats an equality on a country or a kind, though not a
+/// unique key. Other probes keep the fifth they always had.
+fn point_scan_estimate(predicate: &PointPredicate, base: u64) -> u64 {
+    match predicate {
+        PointPredicate::WithinBBox {
+            lower_left,
+            upper_right,
+        } => match (literal_point(lower_left), literal_point(upper_right)) {
+            (Some((ll_lon, ll_lat, true)), Some((ur_lon, ur_lat, _))) => {
+                // A box with its lower-left east of its upper-right
+                // crosses the antimeridian.
+                let width = if ur_lon >= ll_lon {
+                    ur_lon - ll_lon
+                } else {
+                    360.0 - (ll_lon - ur_lon)
+                };
+                let height = (ur_lat - ll_lat).max(0.0);
+                let share = (width.clamp(0.0, 360.0) * height.min(180.0)) / (360.0 * 180.0);
+                ((base as f64 * share).ceil() as u64).clamp(1, base.max(1))
+            }
+            (Some(_), Some(_)) => base.div_ceil(5),
+            _ => 2.min(base.max(1)),
+        },
+        PointPredicate::WithinDistance { .. } => base.div_ceil(5),
+    }
+}
+
 fn point_literal_map(expr: &ResolvedExpr) -> Option<&Vec<(String, ResolvedExpr)>> {
     let ResolvedExpr::Function { function, args, .. } = expr else {
         return None;

lora_python-0.27.1/crates/lora-compiler/src/param_fold.rs

@@ -0,0 +1,197 @@
+//! Fold `$p IS NULL` / `$p IS NOT NULL` when the plan is built for known
+//! parameters.
+//!
+//! An optional filter written as `$kinds IS NULL OR n.kind IN $kinds` is a
+//! disjunction the index picker cannot use, so the seek falls to another
+//! conjunct, however unselective, and every candidate it yields is held
+//! until the filter drops it. With the parameter's value known, the test
+//! is a constant: `false OR n.kind IN $kinds` is `n.kind IN $kinds`, which
+//! the picker seeks like any `IN`, and `true OR …` drops the disjunction.
+//!
+//! The plan is then only valid for parameters with the same nullness;
+//! [`CompiledQuery::null_params`](crate::CompiledQuery::null_params)
+//! records what was assumed, and the plan cache keys on it.
+
+use std::collections::BTreeMap;
+
+use lora_analyzer::{LiteralValue, ResolvedExpr};
+use lora_ast::{BinaryOp, UnaryOp};
+
+use crate::logical::{LogicalOp, LogicalPlan};
+
+/// Whether a parameter is null, for the parameters the caller knows.
+pub type NullnessOf<'a> = &'a dyn Fn(&str) -> Option<bool>;
+
+/// Fold the parameter null tests of every filter in `plan`, recording in
+/// `assumed` every parameter tested and the nullness it was folded for
+/// (`None`: unknown, left as it is).
+pub(crate) fn fold_parameter_null_tests(
+    plan: &mut LogicalPlan,
+    nullness: NullnessOf<'_>,
+    assumed: &mut BTreeMap<String, Option<bool>>,
+) {
+    for op in &mut plan.nodes {
+        if let LogicalOp::Filter(filter) = op {
+            if mentions_null_test(&filter.predicate) {
+                let predicate = std::mem::replace(
+                    &mut filter.predicate,
+                    ResolvedExpr::Literal(LiteralValue::Null),
+                );
+                filter.predicate = fold(predicate, nullness, assumed);
+            }
+        }
+    }
+}
+
+fn mentions_null_test(expr: &ResolvedExpr) -> bool {
+    match expr {
+        ResolvedExpr::Binary { lhs, op, rhs } => match op {
+            BinaryOp::IsNull | BinaryOp::IsNotNull => {
+                matches!(**lhs, ResolvedExpr::Parameter(_))
+            }
+            BinaryOp::And | BinaryOp::Or => mentions_null_test(lhs) || mentions_null_test(rhs),
+            _ => false,
+        },
+        ResolvedExpr::Unary {
+            op: UnaryOp::Not,
+            expr,
+        } => mentions_null_test(expr),
+        _ => false,
+    }
+}
+
+fn boolean(expr: &ResolvedExpr) -> Option<bool> {
+    match expr {
+        ResolvedExpr::Literal(LiteralValue::Bool(b)) => Some(*b),
+        _ => None,
+    }
+}
+
+fn lit(b: bool) -> ResolvedExpr {
+    ResolvedExpr::Literal(LiteralValue::Bool(b))
+}
+
+/// Fold the null tests in `expr` and simplify the `AND`, `OR` and `NOT`
+/// over them. Each rule holds in three-valued logic: `false AND x` and
+/// `true OR x` are decided whatever `x` is, `true AND x` and `false OR x`
+/// are `x`.
+fn fold(
+    expr: ResolvedExpr,
+    nullness: NullnessOf<'_>,
+    assumed: &mut BTreeMap<String, Option<bool>>,
+) -> ResolvedExpr {
+    match expr {
+        ResolvedExpr::Binary { lhs, op, rhs }
+            if matches!(op, BinaryOp::IsNull | BinaryOp::IsNotNull)
+                && matches!(*lhs, ResolvedExpr::Parameter(_)) =>
+        {
+            let ResolvedExpr::Parameter(name) = &*lhs else {
+                unreachable!()
+            };
+            let known = nullness(name);
+            assumed.insert(name.clone(), known);
+            match known {
+                Some(is_null) => lit(if op == BinaryOp::IsNull {
+                    is_null
+                } else {
+                    !is_null
+                }),
+                None => ResolvedExpr::Binary { lhs, op, rhs },
+            }
+        }
+        ResolvedExpr::Binary {
+            lhs,
+            op: op @ (BinaryOp::And | BinaryOp::Or),
+            rhs,
+        } => {
+            let lhs = fold(*lhs, nullness, assumed);
+            let rhs = fold(*rhs, nullness, assumed);
+            let decides = op == BinaryOp::Or;
+            match (boolean(&lhs), boolean(&rhs)) {
+                (Some(b), _) | (_, Some(b)) if b == decides => lit(decides),
+                (Some(_), _) => rhs,
+                (_, Some(_)) => lhs,
+                _ => ResolvedExpr::Binary {
+                    lhs: Box::new(lhs),
+                    op,
+                    rhs: Box::new(rhs),
+                },
+            }
+        }
+        ResolvedExpr::Unary {
+            op: UnaryOp::Not,
+            expr,
+        } => {
+            let inner = fold(*expr, nullness, assumed);
+            match boolean(&inner) {
+                Some(b) => lit(!b),
+                None => ResolvedExpr::Unary {
+                    op: UnaryOp::Not,
+                    expr: Box::new(inner),
+                },
+            }
+        }
+        other => other,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use lora_analyzer::symbols::VarId;
+
+    fn param_is_null(name: &str) -> ResolvedExpr {
+        ResolvedExpr::Binary {
+            lhs: Box::new(ResolvedExpr::Parameter(name.into())),
+            op: BinaryOp::IsNull,
+            rhs: Box::new(ResolvedExpr::Literal(LiteralValue::Null)),
+        }
+    }
+
+    fn other() -> ResolvedExpr {
+        ResolvedExpr::Property {
+            expr: Box::new(ResolvedExpr::Variable(VarId(1))),
+            property: "kind".into(),
+        }
+    }
+
+    fn or(a: ResolvedExpr, b: ResolvedExpr) -> ResolvedExpr {
+        ResolvedExpr::Binary {
+            lhs: Box::new(a),
+            op: BinaryOp::Or,
+            rhs: Box::new(b),
+        }
+    }
+
+    #[test]
+    fn a_known_parameter_folds_and_the_disjunction_simplifies() {
+        let mut assumed = BTreeMap::new();
+        let not_null = |_: &str| Some(false);
+        let folded = fold(or(param_is_null("k"), other()), &not_null, &mut assumed);
+        assert!(matches!(folded, ResolvedExpr::Property { .. }));
+        assert_eq!(assumed.get("k"), Some(&Some(false)));
+
+        let mut assumed = BTreeMap::new();
+        let null = |_: &str| Some(true);
+        let folded = fold(or(param_is_null("k"), other()), &null, &mut assumed);
+        assert!(matches!(
+            folded,
+            ResolvedExpr::Literal(LiteralValue::Bool(true))
+        ));
+    }
+
+    #[test]
+    fn an_unknown_parameter_is_left_alone() {
+        let mut assumed = BTreeMap::new();
+        let unknown = |_: &str| None;
+        let folded = fold(or(param_is_null("k"), other()), &unknown, &mut assumed);
+        assert!(matches!(
+            folded,
+            ResolvedExpr::Binary {
+                op: BinaryOp::Or,
+                ..
+            }
+        ));
+        assert_eq!(assumed.get("k"), Some(&None));
+    }
+}

{lora_python-0.26.3 → lora_python-0.27.1}/crates/lora-compiler/src/pattern.rs

@@ -268,15 +268,42 @@ impl<'a> PatternPlanner<'a> {
         let (Some(first), Some(last)) = (chain.first(), chain.last()) else {
             return false;
         };
+        // Rows after the first expansion: a single row at an end whose
+        // relationship fans out to thousands costs thousands.
         let head_cost = self
             .start_cost(head)
+            .saturating_mul(self.fanout(head, &first.rel))
             .min(self.rel_seek_cost(head, &first.rel));
         let tail_cost = self
             .start_cost(&last.node)
+            .saturating_mul(self.fanout(&last.node, &last.rel))
             .min(self.rel_seek_cost(&last.node, &last.rel));
         tail_cost < head_cost
     }
 
+    /// Average number of `rel` relationships at a node like `end`: the
+    /// relationships of its types over the nodes of `end`'s label. 1 when
+    /// the stats cannot say, so the start costs alone decide.
+    fn fanout(&self, end: &ResolvedNode, rel: &ResolvedRel) -> u64 {
+        let stats = self.planner.stats();
+        let rels = if rel.types.is_empty() {
+            Some(stats.relationship_count as u64)
+        } else {
+            rel.types
+                .iter()
+                .map(|t| stats.relationship_type_count(t))
+                .sum::<Option<u64>>()
+        };
+        let nodes = match end.labels.as_slice() {
+            [group, ..] if group.len() == 1 => stats.label_count(&group[0]),
+            _ => Some(stats.node_count as u64),
+        };
+        match (rels, nodes) {
+            (Some(rels), Some(nodes)) if nodes > 0 => rels.div_ceil(nodes).max(1),
+            _ => 1,
+        }
+    }
+
     /// 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.