lora-python 0.15.0__tar.gz → 0.16.0__tar.gz

{lora_python-0.15.0 → lora_python-0.16.0}/Cargo.lock

@@ -773,7 +773,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "lora-ast",
  "lora-builtins-meta",
@@ -784,14 +784,14 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-binding-buffer"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "lora-database",
  "lora-store",
@@ -799,11 +799,11 @@ dependencies = [
 
 [[package]]
 name = "lora-builtins-meta"
-version = "0.15.0"
+version = "0.16.0"
 
 [[package]]
 name = "lora-compiler"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -812,7 +812,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "anyhow",
  "chacha20poly1305",
@@ -837,7 +837,7 @@ dependencies = [
 
 [[package]]
 name = "lora-executor"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "blake3",
  "crc32fast",
@@ -860,7 +860,7 @@ dependencies = [
 
 [[package]]
 name = "lora-ffi"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -872,7 +872,7 @@ dependencies = [
 
 [[package]]
 name = "lora-io"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "lora-executor",
  "lora-store",
@@ -883,7 +883,7 @@ dependencies = [
 
 [[package]]
 name = "lora-node"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -898,7 +898,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "lora-ast",
  "pest",
@@ -909,7 +909,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -921,7 +921,7 @@ dependencies = [
 
 [[package]]
 name = "lora-query-wasm"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
@@ -935,7 +935,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "anyhow",
  "axum",
@@ -950,7 +950,7 @@ dependencies = [
 
 [[package]]
 name = "lora-snapshot"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "argon2",
  "blake3",
@@ -965,18 +965,21 @@ dependencies = [
 
 [[package]]
 name = "lora-store"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "crc32fast",
  "js-sys",
  "lora-ast",
  "serde",
+ "serde_json",
+ "smallvec 2.0.0-alpha.12",
  "thiserror",
+ "unicode-normalization",
 ]
 
 [[package]]
 name = "lora-wal"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "crc32fast",
  "lora-store",
@@ -986,7 +989,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -1002,7 +1005,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "anyhow",
  "lora-database",

{lora_python-0.15.0 → lora_python-0.16.0}/Cargo.toml

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

{lora_python-0.15.0 → lora_python-0.16.0}/PKG-INFO

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

{lora_python-0.15.0 → lora_python-0.16.0}/crates/lora-analyzer/src/analyzer/clauses.rs

@@ -3,7 +3,7 @@ use super::state::{Analyzer, PatternContext};
 use crate::{errors::*, resolved::*, symbols::*};
 use lora_ast::{
     Create, Delete, Expr, Foreach, InQueryCall, Match, Merge, ProjectionBody, ProjectionItem,
-    Remove, RemoveItem, Return, Set, SetItem, Unwind, UpdatingClause, With,
+    Remove, RemoveItem, Return, Set, SetItem, Unwind, UpdatingClause, Variable, With,
 };
 use lora_store::GraphCatalog;
 use std::collections::{BTreeMap, BTreeSet};
@@ -63,13 +63,99 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
         Ok(ResolvedUnwind { expr, alias })
     }
 
+    /// `CALL proc(args) YIELD f [AS a], ... [WHERE cond]` as a clause.
+    ///
+    /// Supported procedures are the index queries. The call is rewritten
+    /// into clauses the rest of the pipeline already runs:
+    ///
+    /// ```text
+    /// UNWIND index.<op>(args) AS <hit>
+    /// WITH *, <hit>.f AS a, ... [WHERE cond]
+    /// ```
+    ///
+    /// so each hit becomes a row whose yielded variables are ordinary
+    /// bindings: a yielded `node` is a bound node that later `MATCH`
+    /// patterns expand from, and `score` is a number.
     pub(super) fn analyze_in_query_call(
         &mut self,
-        _call: &InQueryCall,
-    ) -> Result<ResolvedClause, SemanticError> {
-        Err(SemanticError::UnsupportedFeature(
-            "CALL ... YIELD is not yet supported by the analyzer".into(),
-        ))
+        call: &InQueryCall,
+    ) -> Result<Vec<ResolvedClause>, SemanticError> {
+        let span = call.span;
+        let qualified = call.procedure.name.parts.join(".");
+        let (function, entity_field) = match qualified.to_ascii_lowercase().as_str() {
+            "db.index.fulltext.querynodes" => ("fulltext_nodes", "node"),
+            "db.index.fulltext.queryrelationships" => ("fulltext_relationships", "relationship"),
+            "db.index.vector.querynodes" => ("vector_nodes", "node"),
+            "db.index.vector.queryrelationships" => ("vector_relationships", "relationship"),
+            _ => {
+                return Err(SemanticError::UnsupportedFeature(format!(
+                    "unknown procedure `{qualified}` (supported in CALL ... YIELD: \
+                     db.index.fulltext.queryNodes, db.index.fulltext.queryRelationships, \
+                     db.index.vector.queryNodes, db.index.vector.queryRelationships)"
+                )))
+            }
+        };
+        if call.yield_items.is_empty() {
+            return Err(SemanticError::UnsupportedFeature(format!(
+                "CALL {qualified}(...) inside a query needs YIELD (fields: {entity_field}, score)"
+            )));
+        }
+
+        // Unique per call site so two CALLs in one query don't collide.
+        let hit_name = format!("__call_hit_{}", span.start);
+        let hit = Variable {
+            name: hit_name,
+            span,
+        };
+        let unwind = Unwind {
+            expr: Expr::FunctionCall {
+                name: vec!["index".to_string(), function.to_string()],
+                distinct: false,
+                args: call.procedure.args.clone(),
+                span,
+            },
+            alias: hit.clone(),
+            span,
+        };
+
+        let mut items = vec![ProjectionItem::Star { span }];
+        for item in &call.yield_items {
+            let field = item
+                .field
+                .clone()
+                .unwrap_or_else(|| item.alias.name.clone());
+            if field != entity_field && field != "score" {
+                return Err(SemanticError::UnsupportedFeature(format!(
+                    "{qualified} yields `{entity_field}` and `score`, not `{field}`"
+                )));
+            }
+            items.push(ProjectionItem::Expr {
+                expr: Expr::Property {
+                    expr: Box::new(Expr::Variable(hit.clone())),
+                    key: field,
+                    span: item.span,
+                },
+                alias: Some(item.alias.clone()),
+                span: item.span,
+            });
+        }
+        let with = With {
+            body: ProjectionBody {
+                distinct: false,
+                items,
+                order: Vec::new(),
+                skip: None,
+                limit: None,
+                span,
+            },
+            where_: call.where_.clone(),
+            span,
+        };
+
+        Ok(vec![
+            ResolvedClause::Unwind(self.analyze_unwind(&unwind)?),
+            ResolvedClause::With(self.analyze_with(&with)?),
+        ])
     }
 
     pub(super) fn analyze_create(&mut self, c: &Create) -> Result<ResolvedCreate, SemanticError> {
@@ -308,7 +394,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
                     items.push(ResolvedProjection {
                         expr: resolved,
                         output,
-                        name,
+                        name: name.into(),
                         explicit_alias: explicit,
                         span: *span,
                     });

{lora_python-0.15.0 → lora_python-0.16.0}/crates/lora-analyzer/src/analyzer/state.rs

@@ -7,7 +7,11 @@ use lora_store::GraphCatalog;
 use std::collections::{BTreeMap, BTreeSet};
 
 pub struct Analyzer<'a, S: GraphCatalog + ?Sized> {
-    pub(super) storage: &'a S,
+    /// Analysis deliberately does not read the stored data: whether a
+    /// query is valid must not depend on which labels, types or keys
+    /// happen to exist right now. The catalog type stays in the signature
+    /// so callers keep constructing the analyzer against their store.
+    pub(super) _catalog: std::marker::PhantomData<&'a S>,
     pub(super) scopes: ScopeStack,
     pub(super) symbols: SymbolTable,
     /// Variables whose runtime value shape isn't tracked by the analyzer
@@ -27,9 +31,9 @@ pub(super) enum PatternContext {
 }
 
 impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
-    pub fn new(storage: &'a S) -> Self {
+    pub fn new(_storage: &'a S) -> Self {
         Self {
-            storage,
+            _catalog: std::marker::PhantomData,
             scopes: ScopeStack::new(),
             symbols: SymbolTable::default(),
             dynamic_property_vars: BTreeSet::new(),
@@ -131,7 +135,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
         let mut clauses = Vec::new();
 
         for rc in &part.reading_clauses {
-            clauses.push(self.analyze_reading_clause(rc)?);
+            clauses.extend(self.analyze_reading_clause(rc)?);
         }
 
         for uc in &part.updating_clauses {
@@ -149,7 +153,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
         let mut clauses = Vec::new();
 
         for rc in &q.reading_clauses {
-            clauses.push(self.analyze_reading_clause(rc)?);
+            clauses.extend(self.analyze_reading_clause(rc)?);
         }
 
         for uc in &q.updating_clauses {
@@ -158,6 +162,19 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
 
         if let Some(ret) = &q.return_clause {
             clauses.push(ResolvedClause::Return(self.analyze_return(ret)?));
+        } else if q.updating_clauses.is_empty() {
+            // The parser only lets a query end in a reading clause when it
+            // is a `CALL { ... }`; it must be a unit subquery.
+            match clauses.last() {
+                Some(ResolvedClause::CallSubquery(call)) if call.return_vars.is_empty() => {}
+                _ => {
+                    return Err(SemanticError::UnsupportedFeature(
+                        "a query can only end in CALL { ... } when the subquery ends in an \
+                         updating clause; add a RETURN"
+                            .into(),
+                    ))
+                }
+            }
         }
 
         Ok(clauses)
@@ -166,15 +183,15 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
     fn analyze_reading_clause(
         &mut self,
         rc: &ReadingClause,
-    ) -> Result<ResolvedClause, SemanticError> {
-        match rc {
-            ReadingClause::Match(m) => Ok(ResolvedClause::Match(self.analyze_match(m)?)),
-            ReadingClause::Unwind(u) => Ok(ResolvedClause::Unwind(self.analyze_unwind(u)?)),
-            ReadingClause::InQueryCall(c) => self.analyze_in_query_call(c),
+    ) -> Result<Vec<ResolvedClause>, SemanticError> {
+        Ok(match rc {
+            ReadingClause::Match(m) => vec![ResolvedClause::Match(self.analyze_match(m)?)],
+            ReadingClause::Unwind(u) => vec![ResolvedClause::Unwind(self.analyze_unwind(u)?)],
+            ReadingClause::InQueryCall(c) => self.analyze_in_query_call(c)?,
             ReadingClause::CallSubquery(c) => {
-                Ok(ResolvedClause::CallSubquery(self.analyze_call_subquery(c)?))
+                vec![ResolvedClause::CallSubquery(self.analyze_call_subquery(c)?)]
             }
-        }
+        })
     }
 
     /// Analyze a CALL { ... } subquery. The inner body is analyzed
@@ -200,11 +217,23 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
             Some(ResolvedClause::Return(ret)) => ret
                 .items
                 .iter()
-                .map(|p| (p.name.clone(), p.output))
+                .map(|p| (p.name.to_string(), p.output))
                 .collect(),
+            // A unit subquery: its body ends in an update and returns
+            // nothing. It runs once per outer row for its side effects and
+            // leaves the outer rows (and scope) unchanged.
+            Some(
+                ResolvedClause::Create(_)
+                | ResolvedClause::Merge(_)
+                | ResolvedClause::Delete(_)
+                | ResolvedClause::Set(_)
+                | ResolvedClause::Remove(_)
+                | ResolvedClause::Foreach(_),
+            ) => Vec::new(),
+            Some(ResolvedClause::CallSubquery(inner)) if inner.return_vars.is_empty() => Vec::new(),
             _ => {
                 return Err(SemanticError::UnsupportedFeature(
-                    "CALL { ... } subquery must end with RETURN".into(),
+                    "CALL { ... } subquery must end with RETURN or an updating clause".into(),
                 ));
             }
         };
@@ -274,38 +303,28 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
         }
     }
 
+    /// Label names are never rejected. Standard Cypher treats a label no
+    /// node carries as an empty match, not an error, and checking against
+    /// the stored data made the *kind* of answer depend on what happens to
+    /// exist right now: the same query errored after the last `:Comment`
+    /// was deleted, but not on an empty database. A pattern with an unknown
+    /// label simply matches nothing.
     pub(super) fn validate_label_name(
         &self,
-        label: &str,
-        context: PatternContext,
+        _label: &str,
+        _context: PatternContext,
     ) -> Result<(), SemanticError> {
-        if matches!(
-            context,
-            PatternContext::Write | PatternContext::OptionalRead
-        ) || self.storage.has_label_name(label)
-            || self.storage.node_count() == 0
-        {
-            Ok(())
-        } else {
-            Err(SemanticError::UnknownLabel(label.to_string()))
-        }
+        Ok(())
     }
 
+    /// Relationship types follow the same rule as labels: an unknown type
+    /// matches nothing.
     pub(super) fn validate_relationship_type_name(
         &self,
-        rel_type: &str,
-        context: PatternContext,
+        _rel_type: &str,
+        _context: PatternContext,
     ) -> Result<(), SemanticError> {
-        if matches!(
-            context,
-            PatternContext::Write | PatternContext::OptionalRead
-        ) || self.storage.has_relationship_type_name(rel_type)
-            || self.storage.relationship_count() == 0
-        {
-            Ok(())
-        } else {
-            Err(SemanticError::UnknownRelationshipType(rel_type.to_string()))
-        }
+        Ok(())
     }
 
     /// Analyze an expression that is the target of a SET operation.
@@ -329,20 +348,12 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
         }
     }
 
-    pub(super) fn property_access_allowed(&self, base: &ResolvedExpr, key: &str) -> bool {
-        match base {
-            // Map literals and query parameters carry their own keys —
-            // there's nothing in the graph catalog to check against.
-            ResolvedExpr::Map(_) | ResolvedExpr::Parameter(_) => true,
-            // Variables whose value shape isn't tracked (UNWIND-bound
-            // row elements, etc.) — the catalog can't speak to keys on
-            // values that come from `$params` at execution time.
-            ResolvedExpr::Variable(id) if self.dynamic_property_vars.contains(id) => true,
-            _ => {
-                self.storage.has_property_key(key)
-                    || (self.storage.node_count() == 0 && self.storage.relationship_count() == 0)
-            }
-        }
+    /// Property access is always allowed: reading a key no entity carries
+    /// yields `null` (standard Cypher), including a key written earlier in
+    /// the same statement. Checking the stored catalog made the query's
+    /// validity depend on the data.
+    pub(super) fn property_access_allowed(&self, _base: &ResolvedExpr, _key: &str) -> bool {
+        true
     }
 
     pub(super) fn visible_bindings(&self) -> BTreeMap<String, VarId> {
@@ -364,7 +375,7 @@ fn return_column_info(clauses: &[ResolvedClause]) -> Option<Vec<(String, bool)>>
             return Some(
                 ret.items
                     .iter()
-                    .map(|p| (p.name.clone(), p.explicit_alias))
+                    .map(|p| (p.name.to_string(), p.explicit_alias))
                     .collect(),
             );
         }

{lora_python-0.15.0 → lora_python-0.16.0}/crates/lora-analyzer/src/analyzer/tests.rs

@@ -23,12 +23,11 @@ fn create_allows_new_relationship_type_when_graph_is_not_empty() {
     let mut analyzer = Analyzer::new(&graph);
     assert!(analyzer.analyze(&doc).is_ok());
 
+    // A type no relationship carries yet is not an error: it matches
+    // nothing (standard Cypher), independent of the stored data.
     let match_doc = parse_query("MATCH (a)-[:KNOWS]->(b) RETURN a, b").unwrap();
     let mut analyzer = Analyzer::new(&graph);
-    assert!(matches!(
-        analyzer.analyze(&match_doc),
-        Err(SemanticError::UnknownRelationshipType(rel_type)) if rel_type == "KNOWS"
-    ));
+    assert!(analyzer.analyze(&match_doc).is_ok());
 }
 
 #[test]

{lora_python-0.15.0 → lora_python-0.16.0}/crates/lora-analyzer/src/resolved.rs

@@ -161,7 +161,10 @@ pub struct ResolvedWith {
 pub struct ResolvedProjection {
     pub expr: ResolvedExpr,
     pub output: VarId,
-    pub name: String,
+    /// Output column name. `Arc<str>` because executors stamp it onto
+    /// every produced row; cloning it per row is a refcount bump rather
+    /// than a heap allocation per cell.
+    pub name: std::sync::Arc<str>,
     /// True when the name came from an explicit `AS` alias.
     pub explicit_alias: bool,
     pub span: Span,

{lora_python-0.15.0 → lora_python-0.16.0}/crates/lora-builtins-meta/src/lib.rs

@@ -424,6 +424,11 @@ pub const BUILTIN_SPECS: &[BuiltinSpec] = &[
     spec("json.path", 2, Some(2)),
     // -- geo.* --------------------------------------------------------------
     spec("geo.distance", 2, Some(2)),
+    // -- index.* (backs in-query `CALL db.index.* YIELD ...`) --------------
+    spec("index.fulltext_nodes", 2, Some(3)),
+    spec("index.fulltext_relationships", 2, Some(3)),
+    spec("index.vector_nodes", 3, Some(4)),
+    spec("index.vector_relationships", 3, Some(4)),
     spec("geo.within_bbox", 3, Some(3)),
     spec("geo.point", 1, Some(1)),
     // -- vector.* -----------------------------------------------------------
@@ -522,6 +527,45 @@ pub const BUILTIN_ALIASES: &[BuiltinAlias] = &[
     alias("tofloatornull", "cast.try"),
     alias("tobooleanornull", "cast.try"),
     alias("tostringornull", "cast.try"),
+    // Standard Cypher scalar names, so queries written from memory (by
+    // people or LLMs) work unchanged. Lookup is case-insensitive, so
+    // `startNode` resolves through `startnode`.
+    alias("split", "string.split"),
+    alias("trim", "string.trim"),
+    alias("ltrim", "string.trim_left"),
+    alias("rtrim", "string.trim_right"),
+    alias("replace", "string.replace"),
+    alias("normalize", "string.normalize"),
+    alias("char_length", "string.length"),
+    alias("character_length", "string.length"),
+    alias("point.distance", "geo.distance"),
+    alias("distance", "geo.distance"),
+    alias("abs", "math.abs"),
+    alias("ceil", "math.ceil"),
+    alias("floor", "math.floor"),
+    alias("round", "math.round"),
+    alias("sqrt", "math.sqrt"),
+    alias("sign", "math.sign"),
+    alias("log", "math.ln"),
+    alias("log10", "math.log10"),
+    alias("exp", "math.exp"),
+    alias("sin", "math.sin"),
+    alias("cos", "math.cos"),
+    alias("tan", "math.tan"),
+    alias("cot", "math.cot"),
+    alias("asin", "math.asin"),
+    alias("acos", "math.acos"),
+    alias("atan", "math.atan"),
+    alias("atan2", "math.atan2"),
+    alias("degrees", "math.degrees"),
+    alias("radians", "math.radians"),
+    alias("pi", "math.pi"),
+    alias("e", "math.e"),
+    alias("tail", "list.rest"),
+    alias("nodes", "path.nodes"),
+    alias("relationships", "path.edges"),
+    alias("startnode", "edge.start"),
+    alias("endnode", "edge.end"),
 ];
 
 pub fn builtin_spec(name: &str) -> Option<&'static BuiltinSpec> {

{lora_python-0.15.0 → lora_python-0.16.0}/crates/lora-compiler/src/lib.rs

@@ -71,7 +71,7 @@ impl Compiler {
 }
 
 fn compile_physical(query: &ResolvedQuery, stats: &GraphStats) -> PhysicalPlan {
-    let mut planner = Planner::new();
+    let mut planner = Planner::with_stats(stats);
     let logical = planner.plan(query);
 
     let mut optimizer = Optimizer::new();

{lora_python-0.15.0 → lora_python-0.16.0}/crates/lora-compiler/src/logical.rs

@@ -112,6 +112,9 @@ pub struct NodeByPropertyScan {
     pub labels: Vec<Vec<String>>,
     pub key: String,
     pub value: ResolvedExpr,
+    /// `false`: seek `key = value`. `true`: `value` evaluates to a list and
+    /// the scan seeks `key IN value`, one lookup per distinct element.
+    pub in_list: bool,
 }
 
 /// Range-bounded property scan rewritten from `Filter(NodeScan, var.prop CMP value)`
@@ -128,6 +131,10 @@ pub struct NodeByPropertyRangeScan {
     pub lo_inclusive: bool,
     pub hi: Option<ResolvedExpr>,
     pub hi_inclusive: bool,
+    /// 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).
+    pub order: Option<lora_ast::SortDirection>,
 }
 
 /// Trigram-backed property scan rewritten from `Filter(NodeScan, var.prop OP "literal")`