lora-python 0.22.2__tar.gz → 0.23.0__tar.gz

{lora_python-0.22.2 → lora_python-0.23.0}/Cargo.lock

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

{lora_python-0.22.2 → lora_python-0.23.0}/Cargo.toml

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

{lora_python-0.22.2 → lora_python-0.23.0}/PKG-INFO

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

{lora_python-0.22.2 → lora_python-0.23.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, Variable, With,
+    Remove, RemoveItem, Return, Set, SetItem, Span, Unwind, UpdatingClause, Variable, With,
 };
 use lora_store::GraphCatalog;
 use std::collections::{BTreeMap, BTreeSet};
@@ -17,6 +17,7 @@ pub(super) struct ExportedAlias {
 #[derive(Debug, Clone)]
 pub(super) struct AnalyzedProjectionBody {
     pub(super) items: Vec<ResolvedProjection>,
+    pub(super) lifted_aggregates: Vec<ResolvedProjection>,
     pub(super) include_existing: bool,
     pub(super) exported_aliases: Vec<ExportedAlias>,
     pub(super) order: Vec<ResolvedSortItem>,
@@ -318,6 +319,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
         Ok(ResolvedReturn {
             distinct: r.body.distinct,
             items: analyzed.items,
+            lifted_aggregates: analyzed.lifted_aggregates,
             include_existing: analyzed.include_existing,
             order: analyzed.order,
             skip: analyzed.skip,
@@ -352,6 +354,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
         Ok(ResolvedWith {
             distinct: w.body.distinct,
             items: analyzed.items,
+            lifted_aggregates: analyzed.lifted_aggregates,
             include_existing: analyzed.include_existing,
             order: analyzed.order,
             skip: analyzed.skip,
@@ -364,6 +367,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
         &mut self,
         body: &ProjectionBody,
     ) -> Result<AnalyzedProjectionBody, SemanticError> {
+        let first_var = self.symbols.next_var();
         let mut items = Vec::new();
         let mut include_existing = false;
         let mut exported_aliases = Vec::new();
@@ -406,6 +410,20 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
             }
         }
 
+        // The items as written, before lifting rewrites them: an ORDER BY key
+        // that restates one sorts by its column.
+        let written: Vec<(String, VarId, bool)> = items
+            .iter()
+            .map(|item| {
+                (
+                    format!("{:?}", item.expr),
+                    item.output,
+                    expr_contains_aggregate(&item.expr),
+                )
+            })
+            .collect();
+        let mut lifted_aggregates = self.lift_nested_aggregates(&mut items, first_var)?;
+
         // Build a lookup from alias names to their output VarIds so ORDER BY
         // can reference projection aliases (e.g. ORDER BY name when RETURN p.name AS name).
         let alias_map: BTreeMap<String, VarId> = exported_aliases
@@ -424,6 +442,13 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
                 })
             })
             .collect::<Result<Vec<_>, SemanticError>>()?;
+        let order = self.lift_order_aggregates(
+            order,
+            &written,
+            &mut lifted_aggregates,
+            body.distinct,
+            first_var,
+        )?;
 
         let skip = body
             .skip
@@ -438,6 +463,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
 
         Ok(AnalyzedProjectionBody {
             items,
+            lifted_aggregates,
             include_existing,
             exported_aliases,
             order,
@@ -447,6 +473,249 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
     }
 }
 
+impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
+    /// Split every item that nests an aggregate inside a larger expression
+    /// (`size(collect(x))`, `{c: count(*)}`): each aggregate call becomes a
+    /// hidden column and the item reads it, so the planner can aggregate
+    /// first and evaluate the item on the grouped row. Inside such an item,
+    /// a sub-expression that restates a grouping key reads that key's column.
+    ///
+    /// Anything else the item reads from before this projection would be a
+    /// different value per row of the group, so it is rejected, as in
+    /// openCypher. `first_var` is the first id this projection allocated:
+    /// lower ids are those earlier bindings, higher ones its own aliases and
+    /// comprehension locals.
+    fn lift_nested_aggregates(
+        &mut self,
+        items: &mut [ResolvedProjection],
+        first_var: VarId,
+    ) -> Result<Vec<ResolvedProjection>, SemanticError> {
+        if !items
+            .iter()
+            .any(|item| expr_contains_aggregate(&item.expr) && !is_bare_aggregate(&item.expr))
+        {
+            return Ok(Vec::new());
+        }
+
+        // Grouping keys, compared by their derived `Debug` form (structural
+        // and deterministic), with the column each one lands in.
+        let keys: Vec<(String, VarId)> = items
+            .iter()
+            .filter(|item| !expr_contains_aggregate(&item.expr))
+            .map(|item| (format!("{:?}", item.expr), item.output))
+            .collect();
+
+        let mut lifted = Vec::new();
+        for item in items.iter_mut() {
+            if !expr_contains_aggregate(&item.expr) || is_bare_aggregate(&item.expr) {
+                continue;
+            }
+            let mut expr = item.expr.clone();
+            lift_aggregates_in(
+                &mut expr,
+                &keys,
+                &mut || self.symbols.new_var(),
+                &mut lifted,
+                item.span,
+            );
+
+            if reads_ungrouped(&expr, &keys, first_var) {
+                return Err(SemanticError::ImplicitGroupingKey(item.name.to_string()));
+            }
+            item.expr = expr;
+        }
+        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).
+    fn lift_order_aggregates(
+        &mut self,
+        order: Vec<ResolvedSortItem>,
+        written: &[(String, VarId, bool)],
+        lifted: &mut Vec<ResolvedProjection>,
+        distinct: bool,
+        first_var: VarId,
+    ) -> Result<Vec<ResolvedSortItem>, SemanticError> {
+        let aggregating = written.iter().any(|(_, _, aggregates)| *aggregates);
+        if !aggregating {
+            if order.iter().any(|key| expr_contains_aggregate(&key.expr)) {
+                return Err(SemanticError::AggregationInOrderBy(
+                    "the projection doesn't aggregate".into(),
+                ));
+            }
+            return Ok(order);
+        }
+
+        let keys: Vec<(String, VarId)> = written
+            .iter()
+            .filter(|(_, _, aggregates)| !aggregates)
+            .map(|(shape, output, _)| (shape.clone(), *output))
+            .collect();
+        order
+            .into_iter()
+            .map(|mut key| {
+                let shape = format!("{:?}", key.expr);
+                if let Some((_, output, _)) = written.iter().find(|(s, _, _)| *s == shape) {
+                    key.expr = ResolvedExpr::Variable(*output);
+                    return Ok(key);
+                }
+                if !expr_contains_aggregate(&key.expr) {
+                    return Ok(key);
+                }
+                if distinct {
+                    return Err(SemanticError::AggregationInOrderBy(
+                        "after DISTINCT it can only sort by an aggregate that is projected".into(),
+                    ));
+                }
+                lift_aggregates_in(
+                    &mut key.expr,
+                    &keys,
+                    &mut || self.symbols.new_var(),
+                    lifted,
+                    Span::default(),
+                );
+                if reads_ungrouped(&key.expr, &keys, first_var) {
+                    return Err(SemanticError::ImplicitGroupingKey("ORDER BY".into()));
+                }
+                Ok(key)
+            })
+            .collect()
+    }
+}
+
+/// 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.
+fn reads_ungrouped(expr: &ResolvedExpr, keys: &[(String, VarId)], first_var: VarId) -> bool {
+    let mut reads = BTreeSet::new();
+    expr.collect_vars(&mut reads);
+    reads
+        .iter()
+        .any(|v| *v < first_var && !keys.iter().any(|(_, key)| key == v))
+}
+
+/// Whether `expr` is itself one aggregate call, the shape the aggregation
+/// operator evaluates directly.
+fn is_bare_aggregate(expr: &ResolvedExpr) -> bool {
+    matches!(expr, ResolvedExpr::Function { function, .. } if function.is_aggregate())
+}
+
+/// Replace each aggregate call in `expr` with a fresh variable, recording
+/// the call as a hidden projection in `lifted`; replace each aggregate-free
+/// sub-expression that restates a grouping key with that key's column.
+fn lift_aggregates_in(
+    expr: &mut ResolvedExpr,
+    keys: &[(String, VarId)],
+    new_var: &mut dyn FnMut() -> VarId,
+    lifted: &mut Vec<ResolvedProjection>,
+    span: Span,
+) {
+    if is_bare_aggregate(expr) {
+        let output = new_var();
+        let call = std::mem::replace(expr, ResolvedExpr::Variable(output));
+        lifted.push(ResolvedProjection {
+            expr: call,
+            output,
+            name: format!("  aggregate {}", output.0).into(),
+            explicit_alias: false,
+            span,
+        });
+        return;
+    }
+    // Not a key, but its parts may be (`size(n.tags)` with `n.tags` grouped).
+    if !keys.is_empty() && !expr_contains_aggregate(expr) {
+        let shape = format!("{:?}", expr);
+        if let Some((_, output)) = keys.iter().find(|(key, _)| *key == shape) {
+            *expr = ResolvedExpr::Variable(*output);
+            return;
+        }
+    }
+    let mut go = |e: &mut ResolvedExpr| lift_aggregates_in(e, keys, new_var, lifted, span);
+    match expr {
+        ResolvedExpr::Variable(_) | ResolvedExpr::Literal(_) | ResolvedExpr::Parameter(_) => {}
+        ResolvedExpr::Property { expr, .. } | ResolvedExpr::Unary { expr, .. } => go(expr),
+        ResolvedExpr::Binary { lhs, rhs, .. } => {
+            go(lhs);
+            go(rhs);
+        }
+        ResolvedExpr::Function { args, .. } => args.iter_mut().for_each(go),
+        ResolvedExpr::List(items) => items.iter_mut().for_each(go),
+        ResolvedExpr::Map(items) => items.iter_mut().for_each(|(_, v)| go(v)),
+        ResolvedExpr::Case {
+            input,
+            alternatives,
+            else_expr,
+        } => {
+            if let Some(e) = input {
+                go(e);
+            }
+            for (w, t) in alternatives {
+                go(w);
+                go(t);
+            }
+            if let Some(e) = else_expr {
+                go(e);
+            }
+        }
+        ResolvedExpr::ListPredicate {
+            list, predicate, ..
+        } => {
+            go(list);
+            go(predicate);
+        }
+        ResolvedExpr::ListComprehension {
+            list,
+            filter,
+            map_expr,
+            ..
+        } => {
+            go(list);
+            if let Some(e) = filter {
+                go(e);
+            }
+            if let Some(e) = map_expr {
+                go(e);
+            }
+        }
+        ResolvedExpr::Reduce {
+            init, list, expr, ..
+        } => {
+            go(init);
+            go(list);
+            go(expr);
+        }
+        ResolvedExpr::MapProjection { base, selectors } => {
+            go(base);
+            for selector in selectors {
+                if let ResolvedMapSelector::Literal(_, e) = selector {
+                    go(e);
+                }
+            }
+        }
+        ResolvedExpr::Index { expr, index } => {
+            go(expr);
+            go(index);
+        }
+        ResolvedExpr::Slice { expr, from, to } => {
+            go(expr);
+            if let Some(e) = from {
+                go(e);
+            }
+            if let Some(e) = to {
+                go(e);
+            }
+        }
+        // Their pattern reads row bindings directly; aggregates can't nest there.
+        ResolvedExpr::ExistsSubquery { .. } | ResolvedExpr::PatternComprehension { .. } => {}
+    }
+}
+
 fn projection_name(expr: &Expr) -> String {
     match expr {
         Expr::Variable(v) => v.name.clone(),

{lora_python-0.22.2 → lora_python-0.23.0}/crates/lora-analyzer/src/analyzer/expressions.rs

@@ -117,7 +117,10 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
             Expr::String(v, _) => Ok(ResolvedExpr::Literal(LiteralValue::String(v.clone()))),
             Expr::Bool(v, _) => Ok(ResolvedExpr::Literal(LiteralValue::Bool(*v))),
             Expr::Null(_) => Ok(ResolvedExpr::Literal(LiteralValue::Null)),
-            Expr::Parameter(name, _) => Ok(ResolvedExpr::Parameter(name.clone())),
+            Expr::Parameter(name, _) => {
+                self.parameters.insert(name.clone());
+                Ok(ResolvedExpr::Parameter(name.clone()))
+            }
 
             Expr::List(items, _) => {
                 let items = items

{lora_python-0.22.2 → lora_python-0.23.0}/crates/lora-analyzer/src/analyzer/state.rs

@@ -20,6 +20,8 @@ pub struct Analyzer<'a, S: GraphCatalog + ?Sized> {
     /// graph-catalog check — the caller can't know which keys the data
     /// carries until rows are bound at execution time.
     pub(super) dynamic_property_vars: BTreeSet<VarId>,
+    /// Every `$name` resolved so far (see [`ResolvedQuery::parameters`]).
+    pub(super) parameters: BTreeSet<String>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -37,6 +39,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
             scopes: ScopeStack::new(),
             symbols: SymbolTable::default(),
             dynamic_property_vars: BTreeSet::new(),
+            parameters: BTreeSet::new(),
         }
     }
 
@@ -106,7 +109,11 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
             }
         }
 
-        Ok(ResolvedQuery { clauses, unions })
+        Ok(ResolvedQuery {
+            clauses,
+            unions,
+            parameters: std::mem::take(&mut self.parameters),
+        })
     }
 
     fn analyze_single_query(

{lora_python-0.22.2 → lora_python-0.23.0}/crates/lora-analyzer/src/errors.rs

@@ -47,6 +47,12 @@ pub enum SemanticError {
     #[error("aggregation functions are not allowed in WHERE clause")]
     AggregationInWhere,
 
+    #[error("`{0}` aggregates, so outside its aggregate functions it can only use grouping keys; project that value as its own column")]
+    ImplicitGroupingKey(String),
+
+    #[error("ORDER BY can't aggregate here: {0}")]
+    AggregationInOrderBy(String),
+
     #[error("all UNION branches must return the same number of columns: expected {0}, got {1}")]
     UnionColumnCountMismatch(usize, usize),
 

{lora_python-0.22.2 → lora_python-0.23.0}/crates/lora-analyzer/src/resolved.rs

@@ -8,6 +8,9 @@ use lora_ast::{
 #[derive(Debug, Clone)]
 pub struct ResolvedQuery {
     pub clauses: Vec<ResolvedClause>,
+    /// Every `$name` the query reads, across its UNION branches and
+    /// subqueries: running it without one of them is an error.
+    pub parameters: BTreeSet<String>,
     /// Additional UNION branches. Each branch is a separate resolved query
     /// that produces rows to be combined with the head query's results.
     pub unions: Vec<ResolvedUnionPart>,
@@ -142,6 +145,11 @@ pub enum ResolvedRemoveItem {
 pub struct ResolvedReturn {
     pub distinct: bool,
     pub items: Vec<ResolvedProjection>,
+    /// Aggregate calls nested inside a larger item (`size(collect(x))`,
+    /// `count(*) + 1`), each lifted into its own hidden column. Those items
+    /// read the lifted columns, and grouping keys, by output id, so they
+    /// are evaluated after aggregation.
+    pub lifted_aggregates: Vec<ResolvedProjection>,
     pub include_existing: bool,
     pub order: Vec<ResolvedSortItem>,
     pub skip: Option<ResolvedExpr>,
@@ -152,6 +160,11 @@ pub struct ResolvedReturn {
 pub struct ResolvedWith {
     pub distinct: bool,
     pub items: Vec<ResolvedProjection>,
+    /// Aggregate calls nested inside a larger item (`size(collect(x))`,
+    /// `count(*) + 1`), each lifted into its own hidden column. Those items
+    /// read the lifted columns, and grouping keys, by output id, so they
+    /// are evaluated after aggregation.
+    pub lifted_aggregates: Vec<ResolvedProjection>,
     pub include_existing: bool,
     pub order: Vec<ResolvedSortItem>,
     pub skip: Option<ResolvedExpr>,

{lora_python-0.22.2 → lora_python-0.23.0}/crates/lora-analyzer/src/symbols.rs

@@ -19,6 +19,12 @@ impl SymbolTable {
         Self { next_var: 0 }
     }
 
+    /// The id the next `new_var` returns. Every variable bound from here on
+    /// (aliases, comprehension locals) gets this id or a higher one.
+    pub fn next_var(&self) -> VarId {
+        VarId(self.next_var)
+    }
+
     pub fn new_var(&mut self) -> VarId {
         let id = VarId(self.next_var);
         self.next_var += 1;