lora-python 0.11.4__tar.gz → 0.11.5__tar.gz

{lora_python-0.11.4 → lora_python-0.11.5}/Cargo.lock

@@ -773,9 +773,10 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "lora-ast",
+ "lora-builtins-meta",
  "lora-parser",
  "lora-store",
  "thiserror",
@@ -783,22 +784,26 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-binding-buffer"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "lora-database",
  "lora-store",
 ]
 
+[[package]]
+name = "lora-builtins-meta"
+version = "0.11.5"
+
 [[package]]
 name = "lora-compiler"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -807,7 +812,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "anyhow",
  "chacha20poly1305",
@@ -831,7 +836,7 @@ dependencies = [
 
 [[package]]
 name = "lora-executor"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "blake3",
  "crc32fast",
@@ -854,7 +859,7 @@ dependencies = [
 
 [[package]]
 name = "lora-ffi"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -866,7 +871,7 @@ dependencies = [
 
 [[package]]
 name = "lora-node"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -881,7 +886,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "lora-ast",
  "pest",
@@ -892,7 +897,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -904,11 +909,12 @@ dependencies = [
 
 [[package]]
 name = "lora-query-wasm"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
  "lora-ast",
+ "lora-builtins-meta",
  "lora-parser",
  "serde",
  "serde-wasm-bindgen",
@@ -917,7 +923,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "anyhow",
  "axum",
@@ -931,7 +937,7 @@ dependencies = [
 
 [[package]]
 name = "lora-snapshot"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "argon2",
  "blake3",
@@ -945,7 +951,7 @@ dependencies = [
 
 [[package]]
 name = "lora-store"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "crc32fast",
  "js-sys",
@@ -956,7 +962,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wal"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "crc32fast",
  "lora-store",
@@ -966,7 +972,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -982,7 +988,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.11.4"
+version = "0.11.5"
 dependencies = [
  "anyhow",
  "lora-database",

{lora_python-0.11.4 → lora_python-0.11.5}/Cargo.toml

@@ -1,10 +1,10 @@
 [workspace]
-members = ["crates/lora-ast", "crates/lora-parser", "crates/lora-analyzer", "crates/lora-compiler", "crates/lora-store", "crates/lora-snapshot", "crates/lora-wal", "crates/lora-executor", "crates/lora-database", "crates/bindings/lora-python"]
+members = ["crates/lora-ast", "crates/lora-parser", "crates/lora-builtins-meta", "crates/lora-analyzer", "crates/lora-compiler", "crates/lora-store", "crates/lora-snapshot", "crates/lora-wal", "crates/lora-executor", "crates/lora-database", "crates/bindings/lora-python"]
 resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.11.4"
+version = "0.11.5"
 license = "BUSL-1.1"
 authors = ["LoraDB, Inc."]
 repository = "https://github.com/lora-db/lora"
@@ -15,16 +15,17 @@ 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.11.4" }
-lora-parser = { path = "crates/lora-parser", version = "=0.11.4" }
-lora-analyzer = { path = "crates/lora-analyzer", version = "=0.11.4" }
-lora-compiler = { path = "crates/lora-compiler", version = "=0.11.4" }
-lora-store = { path = "crates/lora-store", version = "=0.11.4" }
-lora-snapshot = { path = "crates/lora-snapshot", version = "=0.11.4", default-features = false }
-lora-wal = { path = "crates/lora-wal", version = "=0.11.4" }
-lora-executor = { path = "crates/lora-executor", version = "=0.11.4", default-features = false }
-lora-database = { path = "crates/lora-database", version = "=0.11.4" }
-lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.11.4" }
+lora-ast = { path = "crates/lora-ast", version = "=0.11.5" }
+lora-parser = { path = "crates/lora-parser", version = "=0.11.5" }
+lora-builtins-meta = { path = "crates/lora-builtins-meta", version = "=0.11.5" }
+lora-analyzer = { path = "crates/lora-analyzer", version = "=0.11.5" }
+lora-compiler = { path = "crates/lora-compiler", version = "=0.11.5" }
+lora-store = { path = "crates/lora-store", version = "=0.11.5" }
+lora-snapshot = { path = "crates/lora-snapshot", version = "=0.11.5", default-features = false }
+lora-wal = { path = "crates/lora-wal", version = "=0.11.5" }
+lora-executor = { path = "crates/lora-executor", version = "=0.11.5", default-features = false }
+lora-database = { path = "crates/lora-database", version = "=0.11.5" }
+lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.11.5" }
 
 # External crates.
 anyhow = "1"

{lora_python-0.11.4 → lora_python-0.11.5}/PKG-INFO

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

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-analyzer/Cargo.toml

@@ -13,6 +13,7 @@ categories = ["compilers", "parser-implementations"]
 
 [dependencies]
 lora-ast.workspace = true
+lora-builtins-meta.workspace = true
 lora-store.workspace = true
 lora-parser.workspace = true
 thiserror.workspace = true

lora_python-0.11.5/crates/lora-analyzer/src/analyzer/builtin_signatures.rs

@@ -0,0 +1,7 @@
+//! Re-export of the builtin metadata table.
+//!
+//! The actual specs and aliases live in the `lora-builtins-meta` crate
+//! so the editor's WASM bridge can pull from the same source of truth
+//! without dragging in `lora-store` (an analyzer transitive dep). This
+//! shim keeps the existing in-tree call sites working unchanged.
+pub use lora_builtins_meta::*;

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-analyzer/src/analyzer/clauses.rs

@@ -2,8 +2,8 @@ use super::expressions::expr_contains_aggregate;
 use super::state::{Analyzer, PatternContext};
 use crate::{errors::*, resolved::*, symbols::*};
 use lora_ast::{
-    Create, Delete, Expr, InQueryCall, Match, Merge, ProjectionBody, ProjectionItem, Remove,
-    RemoveItem, Return, Set, SetItem, Unwind, With,
+    Create, Delete, Expr, Foreach, InQueryCall, Match, Merge, ProjectionBody, ProjectionItem,
+    Remove, RemoveItem, Return, Set, SetItem, Unwind, UpdatingClause, With,
 };
 use lora_store::GraphCatalog;
 use std::collections::{BTreeMap, BTreeSet};
@@ -151,6 +151,51 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
         Ok(ResolvedSet { items })
     }
 
+    pub(super) fn analyze_foreach(
+        &mut self,
+        f: &Foreach,
+    ) -> Result<ResolvedForeach, SemanticError> {
+        // The list expression is evaluated in the outer scope.
+        let list = self.analyze_expr(&f.list)?;
+
+        // Push the loop variable into a fresh scope so the body sees it
+        // and shadowing rules track properly. Snapshot the outer scope
+        // so we can restore it once the body is analyzed — the loop
+        // variable must not leak into clauses that follow FOREACH.
+        let outer = self.visible_bindings();
+        let var_id = self.declare_fresh_variable(&f.variable.name)?;
+
+        let mut body = Vec::with_capacity(f.body.len());
+        for clause in &f.body {
+            body.push(self.analyze_foreach_body_clause(clause)?);
+        }
+
+        self.replace_scope(outer);
+
+        Ok(ResolvedForeach {
+            variable: var_id,
+            list,
+            body,
+        })
+    }
+
+    /// Analyze one body clause inside `FOREACH`. The body is restricted
+    /// to updating clauses (Create / Merge / Delete / Set / Remove /
+    /// nested Foreach) — reading clauses and RETURN are not legal there.
+    fn analyze_foreach_body_clause(
+        &mut self,
+        uc: &UpdatingClause,
+    ) -> Result<ResolvedClause, SemanticError> {
+        match uc {
+            UpdatingClause::Create(c) => Ok(ResolvedClause::Create(self.analyze_create(c)?)),
+            UpdatingClause::Merge(m) => Ok(ResolvedClause::Merge(self.analyze_merge(m)?)),
+            UpdatingClause::Delete(d) => Ok(ResolvedClause::Delete(self.analyze_delete(d)?)),
+            UpdatingClause::Set(s) => Ok(ResolvedClause::Set(self.analyze_set(s)?)),
+            UpdatingClause::Remove(r) => Ok(ResolvedClause::Remove(self.analyze_remove(r)?)),
+            UpdatingClause::Foreach(f) => Ok(ResolvedClause::Foreach(self.analyze_foreach(f)?)),
+        }
+    }
+
     pub(super) fn analyze_remove(&mut self, r: &Remove) -> Result<ResolvedRemove, SemanticError> {
         let mut items = Vec::with_capacity(r.items.len());
 

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-analyzer/src/analyzer/state.rs

@@ -224,6 +224,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
             UpdatingClause::Delete(d) => Ok(ResolvedClause::Delete(self.analyze_delete(d)?)),
             UpdatingClause::Set(s) => Ok(ResolvedClause::Set(self.analyze_set(s)?)),
             UpdatingClause::Remove(r) => Ok(ResolvedClause::Remove(self.analyze_remove(r)?)),
+            UpdatingClause::Foreach(f) => Ok(ResolvedClause::Foreach(self.analyze_foreach(f)?)),
         }
     }
 

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-analyzer/src/lib.rs

@@ -11,8 +11,8 @@ pub use analyzer::{
 pub use errors::SemanticError;
 pub use resolved::{
     LiteralValue, ResolvedCallSubquery, ResolvedChain, ResolvedClause, ResolvedCreate,
-    ResolvedDelete, ResolvedExpr, ResolvedMapSelector, ResolvedMatch, ResolvedMerge,
-    ResolvedMergeAction, ResolvedNode, ResolvedPattern, ResolvedPatternElement,
+    ResolvedDelete, ResolvedExpr, ResolvedForeach, ResolvedMapSelector, ResolvedMatch,
+    ResolvedMerge, ResolvedMergeAction, ResolvedNode, ResolvedPattern, ResolvedPatternElement,
     ResolvedPatternPart, ResolvedProjection, ResolvedQuery, ResolvedRel, ResolvedRemove,
     ResolvedRemoveItem, ResolvedReturn, ResolvedSet, ResolvedSetItem, ResolvedSortItem,
     ResolvedUnionPart, ResolvedUnwind, ResolvedWith,

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-analyzer/src/resolved.rs

@@ -28,6 +28,7 @@ pub enum ResolvedClause {
     Delete(ResolvedDelete),
     Set(ResolvedSet),
     Remove(ResolvedRemove),
+    Foreach(ResolvedForeach),
     Return(ResolvedReturn),
     With(ResolvedWith),
     CallSubquery(ResolvedCallSubquery),
@@ -112,6 +113,18 @@ pub struct ResolvedRemove {
     pub items: Vec<ResolvedRemoveItem>,
 }
 
+/// `FOREACH (var IN list | body...)`. The body is restricted to
+/// updating clauses (Create / Merge / Delete / Set / Remove / nested
+/// Foreach). The analyzer enforces that restriction; the planner /
+/// executor treat each body item as a side-effect-only operation
+/// applied row-by-row inside the iteration.
+#[derive(Debug, Clone)]
+pub struct ResolvedForeach {
+    pub variable: VarId,
+    pub list: ResolvedExpr,
+    pub body: Vec<ResolvedClause>,
+}
+
 #[derive(Debug, Clone)]
 pub enum ResolvedRemoveItem {
     Labels {

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-ast/src/ast.rs

@@ -402,6 +402,7 @@ pub enum UpdatingClause {
     Delete(Delete),
     Set(Set),
     Remove(Remove),
+    Foreach(Foreach),
 }
 
 #[derive(Debug, Clone)]
@@ -482,6 +483,18 @@ pub struct Remove {
     pub span: Span,
 }
 
+/// `FOREACH (var IN list | body...)` — runs each body updating clause
+/// once per element in `list`, with `var` bound to the element. The
+/// body itself contains only updating clauses (CREATE / MERGE / DELETE
+/// / SET / REMOVE / nested FOREACH).
+#[derive(Debug, Clone)]
+pub struct Foreach {
+    pub variable: Variable,
+    pub list: Expr,
+    pub body: Vec<UpdatingClause>,
+    pub span: Span,
+}
+
 #[derive(Debug, Clone)]
 pub enum RemoveItem {
     Labels {

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-ast/src/lib.rs

@@ -9,14 +9,14 @@ pub mod ast;
 
 pub use ast::{
     BinaryOp, CallSubquery, ConstraintKind, ConstraintNameSpec, Create, CreateConstraint,
-    CreateIndex, Delete, Direction, Document, DropConstraint, DropIndex, Expr, InQueryCall,
-    IndexEntityKind, IndexKind, IndexKindFilter, IndexNameSpec, IndexOptions, ListPredicateKind,
-    LiteralTypeExpr, MapProjectionSelector, Match, Merge, MergeAction, MultiPartQuery, NodePattern,
-    Pattern, PatternElement, PatternElementChain, PatternPart, ProcedureInvocation,
-    ProcedureInvocationKind, ProcedureName, ProjectionBody, ProjectionItem, PropertyTypeExpr,
-    PropertyTypeTerm, Query, QueryPart, RangeLiteral, ReadingClause, RegularQuery,
-    RelationshipDetail, RelationshipPattern, Remove, RemoveItem, Return, ScalarType, SchemaCommand,
-    Set, SetItem, ShowConstraints, ShowIndexes, ShowPipeline, ShowReturn, ShowYield,
+    CreateIndex, Delete, Direction, Document, DropConstraint, DropIndex, Expr, Foreach,
+    InQueryCall, IndexEntityKind, IndexKind, IndexKindFilter, IndexNameSpec, IndexOptions,
+    ListPredicateKind, LiteralTypeExpr, MapProjectionSelector, Match, Merge, MergeAction,
+    MultiPartQuery, NodePattern, Pattern, PatternElement, PatternElementChain, PatternPart,
+    ProcedureInvocation, ProcedureInvocationKind, ProcedureName, ProjectionBody, ProjectionItem,
+    PropertyTypeExpr, PropertyTypeTerm, Query, QueryPart, RangeLiteral, ReadingClause,
+    RegularQuery, RelationshipDetail, RelationshipPattern, Remove, RemoveItem, Return, ScalarType,
+    SchemaCommand, Set, SetItem, ShowConstraints, ShowIndexes, ShowPipeline, ShowReturn, ShowYield,
     SinglePartQuery, SingleQuery, SortDirection, SortItem, Span, StandaloneCall, Statement,
     UnaryOp, UnionPart, Unwind, UpdatingClause, Variable, VectorCoordType, With, YieldItem,
 };

lora_python-0.11.5/crates/lora-builtins-meta/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "lora-builtins-meta"
+edition.workspace = true
+version.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+rust-version.workspace = true
+description = "Static metadata table for LoraDB's namespaced builtin functions — arity, aliases, aggregates. Shared by the analyzer, executor, and editor WASM."
+keywords = ["loradb", "cypher", "builtins", "metadata"]
+categories = ["compilers", "parser-implementations"]
+
+[dependencies]

lora_python-0.11.4/crates/lora-analyzer/src/analyzer/builtin_signatures.rs → lora_python-0.11.5/crates/lora-builtins-meta/src/lib.rs

@@ -1,13 +1,15 @@
 //! Metadata table for lora's namespaced builtin functions.
 //!
-//! Owned by the analyzer because the analyzer validates function
-//! references at compile time. The executor consults the same
-//! `op` strings; drift-safety tests in lora-executor assert that every
+//! Owned by this leaf crate so the analyzer (which validates function
+//! references at compile time), the executor (which dispatches on the
+//! `op` strings), and the editor's WASM bridge (which feeds the
+//! autocomplete / signature-hint surface) can all share a single
+//! declaration. Drift-safety tests in lora-executor assert that every
 //! entry here has a dispatch arm.
 //!
-//! This is intentionally more than an arity table: enum-like argument slots
-//! live here too, so analyzer rewrites and executor dispatch share one
-//! declaration for each builtin.
+//! This is intentionally more than an arity table: enum-like argument
+//! slots live here too, so analyzer rewrites and executor dispatch
+//! share one declaration for each builtin.
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct BuiltinSpec {
@@ -423,6 +425,7 @@ pub const BUILTIN_SPECS: &[BuiltinSpec] = &[
     // -- geo.* --------------------------------------------------------------
     spec("geo.distance", 2, Some(2)),
     spec("geo.within_bbox", 3, Some(3)),
+    spec("geo.point", 1, Some(1)),
     // -- vector.* -----------------------------------------------------------
     spec("vector.dimension", 1, Some(1)),
     spec_enum("vector.distance", 3, Some(3), &[2]),
@@ -477,6 +480,16 @@ pub const BUILTIN_ALIASES: &[BuiltinAlias] = &[
     alias("type.can_cast", "cast.can"),
     alias("now", "temporal.now"),
     alias("datetime", "temporal.now"),
+    // Cypher temporal constructors. `temporal.now` doubles as a parser
+    // when called with a string argument (see `temporal::now` in the
+    // executor — `date("2025-01-01")` lands in the string-parse branch
+    // that picks DateTime/Date/Duration based on the literal's shape).
+    alias("date", "temporal.now"),
+    alias("time", "temporal.now"),
+    alias("localdatetime", "temporal.now"),
+    alias("localtime", "temporal.now"),
+    alias("duration", "temporal.now"),
+    alias("point", "geo.point"),
     alias("timestamp", "temporal.timestamp"),
     alias("timezone", "temporal.timezone"),
     alias("new", "uuid.new"),

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-compiler/src/lib.rs

@@ -9,15 +9,15 @@ mod planner;
 pub use plan_tree::{plan_tree_from_compiled, PlanTree, PlanTreeNode};
 
 pub use logical::{
-    Aggregation, Argument, Create, Delete, Expand, Filter, Limit, LogicalOp, LogicalPlan, Merge,
-    NodeByPointScan, NodeByPropertyRangeScan, NodeByPropertyScan, NodeByTextScan, NodeScan,
+    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, TextPredicate, Unwind,
 };
 pub use optimizer::Optimizer;
 pub use physical::{
-    ArgumentExec, CreateExec, DeleteExec, ExpandExec, FilterExec, HashAggregationExec, LimitExec,
-    MergeExec, NodeByLabelScanExec, NodeByPointScanExec, NodeByPropertyRangeScanExec,
+    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,

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-compiler/src/logical.rs

@@ -1,7 +1,7 @@
 use lora_analyzer::symbols::VarId;
 use lora_analyzer::{
-    ResolvedExpr, ResolvedMergeAction, ResolvedPattern, ResolvedPatternPart, ResolvedProjection,
-    ResolvedRemoveItem, ResolvedSetItem, ResolvedSortItem,
+    ResolvedClause, ResolvedExpr, ResolvedMergeAction, ResolvedPattern, ResolvedPatternPart,
+    ResolvedProjection, ResolvedRemoveItem, ResolvedSetItem, ResolvedSortItem,
 };
 use lora_ast::{Direction, RangeLiteral};
 
@@ -36,11 +36,25 @@ pub enum LogicalOp {
     Set(Set),
     Remove(Remove),
     Create(Create),
+    Foreach(Foreach),
     OptionalMatch(OptionalMatch),
     PathBuild(PathBuild),
     CallSubquery(CallSubquery),
 }
 
+/// `FOREACH (var IN list | body...)` — for each input row, evaluate
+/// the list, then run each body clause once per element with `var`
+/// bound to the element. The body is a flat list of resolved updating
+/// clauses applied for side effects only; the outer row is emitted
+/// unchanged after the loop.
+#[derive(Debug, Clone)]
+pub struct Foreach {
+    pub input: PlanNodeId,
+    pub variable: VarId,
+    pub list: ResolvedExpr,
+    pub body: Vec<ResolvedClause>,
+}
+
 /// `CALL { ... }` subquery: for each upstream row, runs the inner
 /// sub-plan with the upstream row as its initial argument, then
 /// emits the cartesian product of `(upstream row, inner row)` for

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-compiler/src/optimizer.rs

@@ -354,6 +354,13 @@ fn lower_logical_op(op: LogicalOp) -> PhysicalOp {
             items: remove.items,
         }),
 
+        LogicalOp::Foreach(foreach) => PhysicalOp::Foreach(crate::ForeachExec {
+            input: foreach.input,
+            variable: foreach.variable,
+            list: foreach.list,
+            body: foreach.body,
+        }),
+
         LogicalOp::OptionalMatch(om) => PhysicalOp::OptionalMatch(OptionalMatchExec {
             input: om.input,
             inner: om.inner,

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-compiler/src/physical.rs

@@ -1,7 +1,7 @@
 use lora_analyzer::symbols::VarId;
 use lora_analyzer::{
-    ResolvedExpr, ResolvedMergeAction, ResolvedPattern, ResolvedPatternPart, ResolvedProjection,
-    ResolvedRemoveItem, ResolvedSetItem, ResolvedSortItem,
+    ResolvedClause, ResolvedExpr, ResolvedMergeAction, ResolvedPattern, ResolvedPatternPart,
+    ResolvedProjection, ResolvedRemoveItem, ResolvedSetItem, ResolvedSortItem,
 };
 use lora_ast::{Direction, RangeLiteral};
 
@@ -37,11 +37,21 @@ pub enum PhysicalOp {
     Delete(DeleteExec),
     Set(SetExec),
     Remove(RemoveExec),
+    Foreach(ForeachExec),
     OptionalMatch(OptionalMatchExec),
     PathBuild(PathBuildExec),
     CallSubquery(CallSubqueryExec),
 }
 
+/// See [`crate::logical::Foreach`].
+#[derive(Debug, Clone)]
+pub struct ForeachExec {
+    pub input: PhysicalNodeId,
+    pub variable: VarId,
+    pub list: ResolvedExpr,
+    pub body: Vec<ResolvedClause>,
+}
+
 /// `CALL { ... }` subquery executor node. See [`crate::logical::CallSubquery`].
 #[derive(Debug, Clone)]
 pub struct CallSubqueryExec {

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-compiler/src/plan_tree.rs

@@ -387,6 +387,12 @@ fn describe(op: &PhysicalOp) -> PlanDescription {
             d.insert("items".to_string(), n.items.len().to_string());
             PlanDescription::with_children("Remove", d, vec![n.input])
         }
+        PhysicalOp::Foreach(n) => {
+            d.insert("variable".to_string(), var_str(n.variable));
+            d.insert("list".to_string(), expr_str(&n.list));
+            d.insert("body".to_string(), n.body.len().to_string());
+            PlanDescription::with_children("Foreach", d, vec![n.input])
+        }
         PhysicalOp::OptionalMatch(n) => describe_optional_match(n),
         PhysicalOp::CallSubquery(n) => {
             d.insert(

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-compiler/src/planner.rs

@@ -6,8 +6,9 @@ use crate::{
 use lora_analyzer::symbols::VarId;
 use lora_analyzer::{
     ResolvedCallSubquery, ResolvedClause, ResolvedCreate, ResolvedDelete, ResolvedExpr,
-    ResolvedMatch, ResolvedMerge, ResolvedPattern, ResolvedPatternElement, ResolvedProjection,
-    ResolvedQuery, ResolvedRemove, ResolvedReturn, ResolvedSet, ResolvedUnwind, ResolvedWith,
+    ResolvedForeach, ResolvedMatch, ResolvedMerge, ResolvedPattern, ResolvedPatternElement,
+    ResolvedProjection, ResolvedQuery, ResolvedRemove, ResolvedReturn, ResolvedSet, ResolvedUnwind,
+    ResolvedWith,
 };
 
 pub struct Planner {
@@ -77,6 +78,11 @@ impl Planner {
                     self.plan_remove(upstream, rm)
                 }
 
+                ResolvedClause::Foreach(f) => {
+                    let upstream = input.unwrap_or_else(|| self.plan_unit_input());
+                    self.plan_foreach(upstream, f)
+                }
+
                 ResolvedClause::With(w) => {
                     let upstream = input.unwrap_or_else(|| self.plan_unit_input());
                     self.plan_with(upstream, w)
@@ -198,6 +204,15 @@ impl Planner {
         }))
     }
 
+    fn plan_foreach(&mut self, input: PlanNodeId, f: &ResolvedForeach) -> PlanNodeId {
+        self.push(LogicalOp::Foreach(crate::Foreach {
+            input,
+            variable: f.variable,
+            list: f.list.clone(),
+            body: f.body.clone(),
+        }))
+    }
+
     fn plan_with(&mut self, input: PlanNodeId, with: &ResolvedWith) -> PlanNodeId {
         let mut node = input;
 

{lora_python-0.11.4 → lora_python-0.11.5}/crates/lora-database/src/database/pull_mode.rs

@@ -53,6 +53,7 @@ fn subtree_contains_blocking_limit_input(plan: &PhysicalPlan, node_id: PhysicalN
         | PhysicalOp::Merge(_)
         | PhysicalOp::Delete(_)
         | PhysicalOp::Set(_)
-        | PhysicalOp::Remove(_) => true,
+        | PhysicalOp::Remove(_)
+        | PhysicalOp::Foreach(_) => true,
     }
 }