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

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

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

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

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.26.1"
+version = "0.26.3"
 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.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" }
+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" }
 
 # External crates.
 anyhow = "1"

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

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

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

@@ -9,11 +9,11 @@ mod planner;
 pub use plan_tree::{plan_tree_from_compiled, PlanTree, PlanTreeNode};
 
 pub use logical::{
-    Aggregation, Argument, Create, Delete, Expand, Filter, Foreach, Limit, LogicalOp, LogicalPlan,
-    Merge, NodeByIdSeek, NodeByPointScan, NodeByPropertyRangeScan, NodeByPropertyScan,
-    NodeByTextScan, NodeScan, OptionalMatch, PathBuild, PlanNodeId, PointPredicate, Projection,
-    RelByIdSeek, RelByPointScan, RelByPropertyRangeScan, RelByTextScan, Remove, Set, Sort,
-    SortLimit, TextPredicate, Unwind,
+    Aggregation, Argument, Create, Delete, Expand, ExtraRangeBound, Filter, Foreach, Limit,
+    LogicalOp, LogicalPlan, 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::{

{lora_python-0.26.1 → lora_python-0.26.3}/crates/lora-compiler/src/logical.rs

@@ -150,6 +150,8 @@ pub struct NodeByPropertyRangeScan {
     pub lo_inclusive: bool,
     pub hi: Option<ResolvedExpr>,
     pub hi_inclusive: bool,
+    /// More bounds on `key`, intersected with `lo`/`hi` per row.
+    pub extra_bounds: Vec<ExtraRangeBound>,
     /// Set when the optimizer replaced an `ORDER BY var.key` above this
     /// scan: rows must come out in that order (from the index when it can
     /// supply it, otherwise sorted by the operator itself).
@@ -223,6 +225,20 @@ pub struct RelByPropertyRangeScan {
     pub lo_inclusive: bool,
     pub hi: Option<ResolvedExpr>,
     pub hi_inclusive: bool,
+    /// More bounds on `key`, intersected with `lo`/`hi` per row.
+    pub extra_bounds: Vec<ExtraRangeBound>,
+}
+
+/// A range-scan bound the planner cannot order against the scan's `lo` or
+/// `hi` (a parameter, say, where `lo` is a STARTS WITH prefix). The
+/// executor evaluates it per row and seeks from the tighter of the two, so
+/// `x STARTS WITH $p AND x > $after` reads from `max($p, $after)`.
+#[derive(Debug, Clone)]
+pub struct ExtraRangeBound {
+    /// `true` for a lower bound (`>`, `>=`), `false` for an upper one.
+    pub lower: bool,
+    pub value: ResolvedExpr,
+    pub inclusive: bool,
 }
 
 /// Trigram-backed relationship scan. Mirror of [`NodeByTextScan`].

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

@@ -365,6 +365,7 @@ fn lower_logical_op(op: LogicalOp) -> PhysicalOp {
                 lo_inclusive: scan.lo_inclusive,
                 hi: scan.hi,
                 hi_inclusive: scan.hi_inclusive,
+                extra_bounds: scan.extra_bounds,
                 order: scan.order,
             })
         }
@@ -399,6 +400,7 @@ fn lower_logical_op(op: LogicalOp) -> PhysicalOp {
                 lo_inclusive: scan.lo_inclusive,
                 hi: scan.hi,
                 hi_inclusive: scan.hi_inclusive,
+                extra_bounds: scan.extra_bounds,
             })
         }
 
@@ -597,7 +599,36 @@ fn collect_index_candidates(
         }
     }
 
-    if let Some(bounds) = collect_range_bounds(predicate, scan.var) {
+    let text = text_predicate_for_var(predicate, scan.var);
+    // `x STARTS WITH s` is the range `s <= x < string.prefix_end(s)`,
+    // which a RANGE index answers when there is no TEXT index. It
+    // intersects with the comparisons on the same property, so a keyset
+    // page within a prefix seeks from its cursor.
+    let prefix = text.as_ref().filter(|candidate| {
+        matches!(candidate.predicate, TextPredicate::StartsWith) && !is_tautological_text(candidate)
+    });
+    let mut range = collect_range_bounds(predicate, scan.var);
+    match (&mut range, prefix) {
+        (Some(bounds), Some(prefix)) if bounds.key == prefix.key => {
+            add_prefix_bounds(bounds, &prefix.query);
+        }
+        (None, Some(prefix)) => {
+            let mut bounds = RangeBounds::new(prefix.key.clone());
+            add_prefix_bounds(&mut bounds, &prefix.query);
+            range = Some(bounds);
+        }
+        _ => {}
+    }
+    // A prefix on another property than the comparisons: its own scan.
+    let prefix_range = prefix
+        .filter(|prefix| range.as_ref().is_some_and(|b| b.key != prefix.key))
+        .map(|prefix| {
+            let mut bounds = RangeBounds::new(prefix.key.clone());
+            add_prefix_bounds(&mut bounds, &prefix.query);
+            bounds
+        });
+
+    for bounds in range.into_iter().chain(prefix_range) {
         if !is_tautological_range(&bounds)
             && first_simple_label(&scan.labels)
                 .is_some_and(|label| stats.has_node_range_index(label, &bounds.key))
@@ -612,39 +643,14 @@ fn collect_index_candidates(
                     lo_inclusive: bounds.lo_inclusive,
                     hi: bounds.hi,
                     hi_inclusive: bounds.hi_inclusive,
+                    extra_bounds: bounds.extra,
                     order: None,
                 },
             ));
         }
     }
 
-    if let Some(candidate) = text_predicate_for_var(predicate, scan.var) {
-        // `x STARTS WITH s` is the range `s <= x < string.prefix_end(s)`,
-        // which a RANGE index answers when there is no TEXT index.
-        if matches!(candidate.predicate, TextPredicate::StartsWith)
-            && !is_tautological_text(&candidate)
-            && first_simple_label(&scan.labels)
-                .is_some_and(|label| stats.has_node_range_index(label, &candidate.key))
-        {
-            out.push(LogicalOp::NodeByPropertyRangeScan(
-                NodeByPropertyRangeScan {
-                    input: scan.input,
-                    var: scan.var,
-                    labels: scan.labels.clone(),
-                    key: candidate.key.clone(),
-                    lo: Some(candidate.query.clone()),
-                    lo_inclusive: true,
-                    hi: Some(ResolvedExpr::Function {
-                        function: lora_analyzer::FunctionId::builtin("string.prefix_end")
-                            .expect("string.prefix_end is a builtin"),
-                        distinct: false,
-                        args: vec![candidate.query.clone()],
-                    }),
-                    hi_inclusive: false,
-                    order: None,
-                },
-            ));
-        }
+    if let Some(candidate) = text {
         if !is_tautological_text(&candidate)
             && first_simple_label(&scan.labels)
                 .is_some_and(|label| stats.has_node_text_index(label, &candidate.key))
@@ -729,6 +735,7 @@ fn collect_rel_index_candidates(
                 lo_inclusive: bounds.lo_inclusive,
                 hi: bounds.hi,
                 hi_inclusive: bounds.hi_inclusive,
+                extra_bounds: bounds.extra,
             }));
         }
     }
@@ -977,7 +984,7 @@ fn is_tautological_range(bounds: &RangeBounds) -> bool {
         ),
         (Some(_), true) => false,
     };
-    lo_open && hi_open
+    lo_open && hi_open && bounds.extra.is_empty()
 }
 
 fn is_tautological_text(candidate: &TextCandidate) -> bool {
@@ -1075,66 +1082,75 @@ struct RangeBounds {
     lo_inclusive: bool,
     hi: Option<ResolvedExpr>,
     hi_inclusive: bool,
+    /// Bounds that could not be ordered against `lo`/`hi` at plan time.
+    extra: Vec<ExtraRangeBound>,
+}
+
+impl RangeBounds {
+    fn new(key: String) -> Self {
+        Self {
+            key,
+            lo: None,
+            lo_inclusive: false,
+            hi: None,
+            hi_inclusive: false,
+            extra: Vec::new(),
+        }
+    }
+
+    /// Intersect one more bound: keep the tighter of it and the current
+    /// one when both are literals, else keep it for the executor to order.
+    fn add(&mut self, side: RangeSide, value: ResolvedExpr, inclusive: bool) {
+        let (current, current_inclusive, tighter): (_, _, fn(_, _, _, _) -> _) = match side {
+            RangeSide::Lower => (&mut self.lo, &mut self.lo_inclusive, lower_bound_is_tighter),
+            RangeSide::Upper => (&mut self.hi, &mut self.hi_inclusive, upper_bound_is_tighter),
+        };
+        let Some(existing) = current.as_ref() else {
+            *current = Some(value);
+            *current_inclusive = inclusive;
+            return;
+        };
+        if compare_literal_bounds(&value, existing).is_none() {
+            self.extra.push(ExtraRangeBound {
+                lower: matches!(side, RangeSide::Lower),
+                value,
+                inclusive,
+            });
+        } else if tighter(&value, inclusive, existing, *current_inclusive) {
+            *current = Some(value);
+            *current_inclusive = inclusive;
+        }
+    }
 }
 
-/// Walk an AND-tree and collect any `var.prop CMP literal` bounds.
-/// Returns `None` if no comparison touches `var.prop` for a single
-/// property key — we don't try to combine multi-property bounds in v1.
+/// Walk an AND-tree and collect any `var.prop CMP value` bounds on the
+/// first property compared. Returns `None` if no comparison touches
+/// `var`; bounds on other properties are left to the filter.
 fn collect_range_bounds(predicate: &ResolvedExpr, var: VarId) -> Option<RangeBounds> {
-    let mut key: Option<String> = None;
-    let mut lo: Option<ResolvedExpr> = None;
-    let mut lo_inclusive = false;
-    let mut hi: Option<ResolvedExpr> = None;
-    let mut hi_inclusive = false;
-    let mut any = false;
-
-    walk_and_for_range(
-        predicate,
-        var,
-        &mut |found_key, side, value, inclusive| match side {
-            RangeSide::Lower => {
-                if key.as_deref().map(|k| k != found_key).unwrap_or(false) {
-                    return;
-                }
-                key = Some(found_key.to_string());
-                if lo
-                    .as_ref()
-                    .map(|current| lower_bound_is_tighter(&value, inclusive, current, lo_inclusive))
-                    .unwrap_or(true)
-                {
-                    lo = Some(value);
-                    lo_inclusive = inclusive;
-                }
-                any = true;
-            }
-            RangeSide::Upper => {
-                if key.as_deref().map(|k| k != found_key).unwrap_or(false) {
-                    return;
-                }
-                key = Some(found_key.to_string());
-                if hi
-                    .as_ref()
-                    .map(|current| upper_bound_is_tighter(&value, inclusive, current, hi_inclusive))
-                    .unwrap_or(true)
-                {
-                    hi = Some(value);
-                    hi_inclusive = inclusive;
-                }
-                any = true;
-            }
+    let mut bounds: Option<RangeBounds> = None;
+    walk_and_for_range(predicate, var, &mut |found_key, side, value, inclusive| {
+        let bounds = bounds.get_or_insert_with(|| RangeBounds::new(found_key.to_string()));
+        if bounds.key == found_key {
+            bounds.add(side, value, inclusive);
+        }
+    });
+    bounds
+}
+
+/// The range `prefix <= x < string.prefix_end(prefix)` of `x STARTS WITH
+/// prefix`, added to `bounds`.
+fn add_prefix_bounds(bounds: &mut RangeBounds, prefix: &ResolvedExpr) {
+    bounds.add(RangeSide::Lower, prefix.clone(), true);
+    bounds.add(
+        RangeSide::Upper,
+        ResolvedExpr::Function {
+            function: lora_analyzer::FunctionId::builtin("string.prefix_end")
+                .expect("string.prefix_end is a builtin"),
+            distinct: false,
+            args: vec![prefix.clone()],
         },
+        false,
     );
-
-    if !any {
-        return None;
-    }
-    Some(RangeBounds {
-        key: key?,
-        lo,
-        lo_inclusive,
-        hi,
-        hi_inclusive,
-    })
 }
 
 #[derive(Clone, Copy)]
@@ -1703,6 +1719,7 @@ mod tests {
                 lo_inclusive: false,
                 hi: None,
                 hi_inclusive: false,
+                extra_bounds: Vec::new(),
                 order: None,
             }),
             LogicalOp::NodeByPropertyScan(NodeByPropertyScan {
@@ -1759,6 +1776,7 @@ mod tests {
             lo_inclusive: false,
             hi: None,
             hi_inclusive: false,
+            extra: Vec::new(),
         };
         assert!(is_tautological_range(&bounds));
     }
@@ -1771,6 +1789,7 @@ mod tests {
             lo_inclusive: false,
             hi: Some(lit_int(i64::MAX)),
             hi_inclusive: false,
+            extra: Vec::new(),
         };
         assert!(is_tautological_range(&bounds));
     }
@@ -1783,6 +1802,7 @@ mod tests {
             lo_inclusive: false,
             hi: Some(lit_int(i64::MAX)),
             hi_inclusive: false,
+            extra: Vec::new(),
         };
         assert!(is_tautological_range(&bounds));
     }
@@ -1795,6 +1815,7 @@ mod tests {
             lo_inclusive: false,
             hi: Some(lit_int(100)),
             hi_inclusive: false,
+            extra: Vec::new(),
         };
         assert!(!is_tautological_range(&bounds));
     }

{lora_python-0.26.1 → lora_python-0.26.3}/crates/lora-compiler/src/physical.rs

@@ -130,6 +130,8 @@ pub struct NodeByPropertyRangeScanExec {
     pub lo_inclusive: bool,
     pub hi: Option<ResolvedExpr>,
     pub hi_inclusive: bool,
+    /// See [`crate::logical::ExtraRangeBound`].
+    pub extra_bounds: Vec<crate::logical::ExtraRangeBound>,
     /// Set when the optimizer replaced an `ORDER BY var.key` above this
     /// scan: rows must come out in that order (from the index when it can
     /// supply it, otherwise sorted by the operator itself).
@@ -168,6 +170,8 @@ pub struct RelByPropertyRangeScanExec {
     pub lo_inclusive: bool,
     pub hi: Option<ResolvedExpr>,
     pub hi_inclusive: bool,
+    /// See [`crate::logical::ExtraRangeBound`].
+    pub extra_bounds: Vec<crate::logical::ExtraRangeBound>,
 }
 
 #[derive(Debug, Clone)]

{lora_python-0.26.1 → lora_python-0.26.3}/crates/lora-compiler/src/plan_tree.rs

@@ -195,26 +195,12 @@ fn describe(op: &PhysicalOp) -> PlanDescription {
                 d.insert("labels".to_string(), label_groups_str(&n.labels));
             }
             d.insert("key".to_string(), n.key.clone());
-            if let Some(lo) = &n.lo {
-                d.insert(
-                    "lo".to_string(),
-                    format!(
-                        "{} {}",
-                        if n.lo_inclusive { ">=" } else { ">" },
-                        expr_str(lo)
-                    ),
-                );
-            }
-            if let Some(hi) = &n.hi {
-                d.insert(
-                    "hi".to_string(),
-                    format!(
-                        "{} {}",
-                        if n.hi_inclusive { "<=" } else { "<" },
-                        expr_str(hi)
-                    ),
-                );
-            }
+            insert_range_bounds(
+                &mut d,
+                (&n.lo, n.lo_inclusive),
+                (&n.hi, n.hi_inclusive),
+                &n.extra_bounds,
+            );
             PlanDescription::with_children("NodeByPropertyRangeScan", d, opt_input(n.input))
         }
         PhysicalOp::NodeByPointScan(n) => {
@@ -282,26 +268,12 @@ fn describe(op: &PhysicalOp) -> PlanDescription {
                 direction_str(n.direction).to_string(),
             );
             d.insert("key".to_string(), n.key.clone());
-            if let Some(lo) = &n.lo {
-                d.insert(
-                    "lo".to_string(),
-                    format!(
-                        "{} {}",
-                        if n.lo_inclusive { ">=" } else { ">" },
-                        expr_str(lo)
-                    ),
-                );
-            }
-            if let Some(hi) = &n.hi {
-                d.insert(
-                    "hi".to_string(),
-                    format!(
-                        "{} {}",
-                        if n.hi_inclusive { "<=" } else { "<" },
-                        expr_str(hi)
-                    ),
-                );
-            }
+            insert_range_bounds(
+                &mut d,
+                (&n.lo, n.lo_inclusive),
+                (&n.hi, n.hi_inclusive),
+                &n.extra_bounds,
+            );
             PlanDescription::with_children("RelByPropertyRangeScan", d, opt_input(n.input))
         }
         PhysicalOp::RelByTextScan(n) => {
@@ -641,3 +613,37 @@ fn expr_str(e: &ResolvedExpr) -> String {
 fn pattern_summary(part_count: usize) -> String {
     format!("{} pattern part(s)", part_count)
 }
+
+/// The `lo` and `hi` details of a range scan: each side's bounds joined
+/// with `AND`, the scan seeking from the tightest at run time.
+fn insert_range_bounds(
+    d: &mut BTreeMap<String, String>,
+    lo: (&Option<ResolvedExpr>, bool),
+    hi: (&Option<ResolvedExpr>, bool),
+    extra: &[crate::logical::ExtraRangeBound],
+) {
+    for (name, lower, (first, first_inclusive)) in [("lo", true, lo), ("hi", false, hi)] {
+        let parts: Vec<String> = first
+            .iter()
+            .map(|value| (value, first_inclusive))
+            .chain(
+                extra
+                    .iter()
+                    .filter(|b| b.lower == lower)
+                    .map(|b| (&b.value, b.inclusive)),
+            )
+            .map(|(value, inclusive)| {
+                let op = match (lower, inclusive) {
+                    (true, true) => ">=",
+                    (true, false) => ">",
+                    (false, true) => "<=",
+                    (false, false) => "<",
+                };
+                format!("{op} {}", expr_str(value))
+            })
+            .collect();
+        if !parts.is_empty() {
+            d.insert(name.to_string(), parts.join(" AND "));
+        }
+    }
+}