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

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

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

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

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

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

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

{lora_python-0.24.0 → lora_python-0.25.0}/crates/lora-analyzer/src/analyzer/clauses.rs

@@ -442,12 +442,20 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
                 })
             })
             .collect::<Result<Vec<_>, SemanticError>>()?;
+        let shadowed: Vec<(VarId, VarId)> = exported_aliases
+            .iter()
+            .filter_map(|alias| Some((self.scopes.resolve(&alias.name)?, alias.id)))
+            .collect();
         let order = self.lift_order_aggregates(
             order,
-            &written,
             &mut lifted_aggregates,
-            body.distinct,
-            first_var,
+            OrderProjection {
+                written: &written,
+                shadowed: &shadowed,
+                distinct: body.distinct,
+                include_existing,
+                first_var,
+            },
         )?;
 
         let skip = body
@@ -527,21 +535,30 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
         Ok(lifted)
     }
 
-    /// Point ORDER BY keys of an aggregating projection at what they mean
-    /// on the grouped rows. A key that restates an item (as written, before
-    /// lifting) sorts by that item's column; an aggregate in any other key
-    /// is lifted into a hidden column like a nested one in an item, the
-    /// planner keeping it until the sort. A projection that doesn't
-    /// aggregate can't aggregate in ORDER BY, and after DISTINCT a key can
-    /// only aggregate what is projected (openCypher rejects both).
+    /// Point ORDER BY keys of an aggregating or DISTINCT projection at what
+    /// they mean on the rows it produces, where only its columns exist. A
+    /// key that restates an item (as written, before lifting) sorts by that
+    /// item's column, and so does any part of a key that restates a grouping
+    /// key (`n.key` with `n` grouped). An aggregate in any other key is
+    /// lifted into a hidden column like a nested one in an item, the planner
+    /// keeping it until the sort. Whatever a key still reads from before the
+    /// projection has no single value per produced row, so it is rejected,
+    /// as in openCypher. A projection that doesn't aggregate can't aggregate
+    /// in ORDER BY, and after DISTINCT a key can only aggregate what is
+    /// projected (openCypher rejects both).
     fn lift_order_aggregates(
         &mut self,
         order: Vec<ResolvedSortItem>,
-        written: &[(String, VarId, bool)],
         lifted: &mut Vec<ResolvedProjection>,
-        distinct: bool,
-        first_var: VarId,
+        projection: OrderProjection<'_>,
     ) -> Result<Vec<ResolvedSortItem>, SemanticError> {
+        let OrderProjection {
+            written,
+            shadowed,
+            distinct,
+            include_existing,
+            first_var,
+        } = projection;
         let aggregating = written.iter().any(|(_, _, aggregates)| *aggregates);
         if !aggregating {
             if order.iter().any(|key| expr_contains_aggregate(&key.expr)) {
@@ -549,7 +566,11 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
                     "the projection doesn't aggregate".into(),
                 ));
             }
-            return Ok(order);
+            // A plain projection sorts with the bindings from before it
+            // still in the row.
+            if !distinct {
+                return Ok(order);
+            }
         }
 
         let keys: Vec<(String, VarId)> = written
@@ -565,10 +586,16 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
                     key.expr = ResolvedExpr::Variable(*output);
                     return Ok(key);
                 }
-                if !expr_contains_aggregate(&key.expr) {
-                    return Ok(key);
+                // A bare name that is both an alias and an earlier binding
+                // (`RETURN n.name AS n, count(*) AS c ORDER BY n`) can only
+                // mean the alias here: the earlier binding is gone.
+                if let ResolvedExpr::Variable(var) = &key.expr {
+                    if let Some((_, column)) = shadowed.iter().find(|(earlier, _)| earlier == var) {
+                        key.expr = ResolvedExpr::Variable(*column);
+                        return Ok(key);
+                    }
                 }
-                if distinct {
+                if distinct && expr_contains_aggregate(&key.expr) {
                     return Err(SemanticError::AggregationInOrderBy(
                         "after DISTINCT it can only sort by an aggregate that is projected".into(),
                     ));
@@ -580,8 +607,13 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
                     lifted,
                     Span::default(),
                 );
-                if reads_ungrouped(&key.expr, &keys, first_var) {
-                    return Err(SemanticError::ImplicitGroupingKey("ORDER BY".into()));
+                // `WITH *` / `RETURN *` keep the earlier bindings as columns.
+                if !include_existing && reads_ungrouped(&key.expr, &keys, first_var) {
+                    return Err(if aggregating {
+                        SemanticError::ImplicitGroupingKey("ORDER BY".into())
+                    } else {
+                        SemanticError::OrderByAfterDistinct
+                    });
                 }
                 Ok(key)
             })
@@ -589,6 +621,22 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
     }
 }
 
+/// The projection an ORDER BY belongs to, as its keys see it.
+struct OrderProjection<'a> {
+    /// Each item as written, before lifting: its `Debug` form, its column,
+    /// and whether it aggregates.
+    written: &'a [(String, VarId, bool)],
+    /// Aliases that reuse the name of a binding from before the projection
+    /// (`RETURN n.name AS n`), as (earlier binding, column).
+    shadowed: &'a [(VarId, VarId)],
+    distinct: bool,
+    /// `WITH *` / `RETURN *`: the earlier bindings stay columns.
+    include_existing: bool,
+    /// The first id the projection allocated: lower ids are earlier
+    /// bindings.
+    first_var: VarId,
+}
+
 /// Whether `expr`, after lifting, reads a binding from before the
 /// projection (an id below `first_var`) that isn't a grouping key's
 /// column: a value that differs per row of the group.

{lora_python-0.24.0 → lora_python-0.25.0}/crates/lora-analyzer/src/analyzer/expressions.rs

@@ -404,6 +404,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
                     pattern: resolved_pattern,
                     where_: resolved_where.map(Box::new),
                     reads: Vec::new(),
+                    seeks: Vec::new(),
                 };
                 fill_subquery_reads(&mut expr);
                 Ok(expr)
@@ -432,6 +433,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
                     where_: resolved_where.map(Box::new),
                     map_expr: Box::new(resolved_map),
                     reads: Vec::new(),
+                    seeks: Vec::new(),
                 };
                 fill_subquery_reads(&mut expr);
                 Ok(expr)
@@ -441,14 +443,27 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
 }
 
 /// Record on a pattern subquery the variables it uses, so the executor can
-/// hand it only those bindings without walking the expression per row.
+/// hand it only those bindings without walking the expression per row, and
+/// the WHERE conjuncts it can seek a node by.
 fn fill_subquery_reads(expr: &mut ResolvedExpr) {
     let mut vars = std::collections::BTreeSet::new();
     expr.collect_vars(&mut vars);
-    if let ResolvedExpr::ExistsSubquery { reads, .. }
-    | ResolvedExpr::PatternComprehension { reads, .. } = expr
+    if let ResolvedExpr::ExistsSubquery {
+        pattern,
+        where_,
+        reads,
+        seeks,
+    }
+    | ResolvedExpr::PatternComprehension {
+        pattern,
+        where_,
+        reads,
+        seeks,
+        ..
+    } = expr
     {
         *reads = vars.into_iter().collect();
+        *seeks = crate::PatternSeek::collect(pattern, where_.as_deref());
     }
 }
 

{lora_python-0.24.0 → lora_python-0.25.0}/crates/lora-analyzer/src/errors.rs

@@ -8,15 +8,6 @@ pub enum SemanticError {
     #[error("duplicate variable `{0}` in the same scope")]
     DuplicateVariable(String),
 
-    #[error("unknown label `:{0}`")]
-    UnknownLabel(String),
-
-    #[error("unknown relationship type `:{0}`")]
-    UnknownRelationshipType(String),
-
-    #[error("unknown property `{0}`")]
-    UnknownProperty(String),
-
     #[error("unknown property `{0}` at {1}..{2}")]
     UnknownPropertyAt(String, usize, usize),
 
@@ -50,6 +41,9 @@ pub enum SemanticError {
     #[error("`{0}` aggregates, so outside its aggregate functions it can only use grouping keys; project that value as its own column")]
     ImplicitGroupingKey(String),
 
+    #[error("after DISTINCT, ORDER BY can only use the projected columns; project that value as its own column")]
+    OrderByAfterDistinct,
+
     #[error("ORDER BY can't aggregate here: {0}")]
     AggregationInOrderBy(String),
 

lora_python-0.25.0/crates/lora-analyzer/src/lib.rs

@@ -0,0 +1,20 @@
+pub mod analyzer;
+pub mod errors;
+pub mod resolved;
+pub mod scope;
+pub mod symbols;
+
+pub use analyzer::{
+    accepts_enum_literal, accepts_type_literal, builtin_spec, namespaced_arity, resolve_function,
+    AggregateFunction, Analyzer, FunctionId, BUILTIN_SPECS,
+};
+pub use errors::SemanticError;
+pub use resolved::{
+    LiteralValue, PatternSeek, PatternSeekKind, ResolvedCallSubquery, ResolvedChain,
+    ResolvedClause, ResolvedCreate, ResolvedDelete, ResolvedExpr, ResolvedForeach,
+    ResolvedMapSelector, ResolvedMatch, ResolvedMerge, ResolvedMergeAction, ResolvedNode,
+    ResolvedNodeRef, ResolvedPattern, ResolvedPatternElement, ResolvedPatternPart,
+    ResolvedProjection, ResolvedQuery, ResolvedRel, ResolvedRemove, ResolvedRemoveItem,
+    ResolvedReturn, ResolvedSet, ResolvedSetItem, ResolvedSortItem, ResolvedUnionPart,
+    ResolvedUnwind, ResolvedWith,
+};