flowquery 1.0.62__tar.gz → 1.0.63__tar.gz

{flowquery-1.0.62 → flowquery-1.0.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowquery
-Version: 1.0.62
+Version: 1.0.63
 Summary: A declarative query language for data processing pipelines
 Author-email: Team Microsoft FlowQuery <flowquery@microsoft.com>
 License: MIT

{flowquery-1.0.62 → flowquery-1.0.63}/flowquery.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowquery
-Version: 1.0.62
+Version: 1.0.63
 Summary: A declarative query language for data processing pipelines
 Author-email: Team Microsoft FlowQuery <flowquery@microsoft.com>
 License: MIT

{flowquery-1.0.62 → flowquery-1.0.63}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowquery"
-version = "1.0.62"
+version = "1.0.63"
 description = "A declarative query language for data processing pipelines"
 readme = "README.md"
 requires-python = ">=3.10"

{flowquery-1.0.62 → flowquery-1.0.63}/src/parsing/expressions/operator.py

@@ -161,6 +161,20 @@ class Not(Operator):
         return 1 if not self.lhs.value() else 0
 
 
+class Negate(Operator):
+    """Unary minus.  Binds to a single operand, so ``-a + b`` is ``(-a) + b``."""
+
+    def __init__(self) -> None:
+        super().__init__(0, True)
+
+    def is_operator(self) -> bool:
+        return False
+
+    def value(self) -> Any:
+        value = self.lhs.value()
+        return None if value is None else -value
+
+
 class Is(Operator):
     def __init__(self) -> None:
         super().__init__(0, True)

{flowquery-1.0.62 → flowquery-1.0.63}/src/parsing/operations/aggregated_return.py

@@ -52,6 +52,9 @@ class AggregatedReturn(Return):
         # (e.g. ``RETURN count(*)`` over no MATCH).  This keeps
         # ``runner.provenance`` length aligned with ``runner.results``.
         want_provenance = self._provenance_sink is not None
+        # Re-emission re-walks the group tree, so drop stale keys first.
+        if self._order_by is not None:
+            self._order_by.reset_sort_keys()
         if want_provenance:
             record_iter = self._group_by.generate_results()
             prov_iter = self._group_by.generate_provenance()
@@ -64,10 +67,16 @@ class AggregatedReturn(Return):
                     p = next(prov_iter)
                 except StopIteration:
                     break
+                # Evaluated while this group's overrides are live, so ORDER BY
+                # supports arbitrary expressions and not just bare aliases.
+                if self._order_by is not None:
+                    self._order_by.capture_sort_keys()
                 results.append(r)
                 provenance.append(p)
         else:
             for r in self._group_by.generate_results():
+                if self._order_by is not None:
+                    self._order_by.capture_sort_keys()
                 results.append(r)
         if self._order_by is not None:
             indices = self._order_by.sort_indices(results)

{flowquery-1.0.62 → flowquery-1.0.63}/src/parsing/operations/aggregated_with.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 from ...compute.provenance import ProvenanceSource, RowProvenance, RowSegment
 from ..ast_node import ASTNode
@@ -48,13 +48,40 @@ class AggregatedWith(Return):
     async def finish(self) -> None:
         want_provenance = self._group_by.provenance_enabled
         prov_iter = self._group_by.generate_provenance() if want_provenance else None
-        for _ in self._group_by.generate_results():
-            if prov_iter is not None:
-                try:
-                    self._current_group_provenance = next(prov_iter)
-                except StopIteration:
-                    self._current_group_provenance = None
-            if self.next:
-                await self.next.run()
+        if self._order_by is not None:
+            # Re-emission re-walks the group tree, so drop stale keys first.
+            self._order_by.reset_sort_keys()
+            # Groups must be buffered so ORDER BY can permute them before
+            # any downstream operation (notably LIMIT) consumes the stream.
+            records: List[Dict[str, Any]] = []
+            restores: List[Callable[[], None]] = []
+            provenance: List[Optional[RowProvenance]] = []
+            for record, restore in self._group_by.generate_groups():
+                # Evaluated while this group's overrides are live, so ORDER BY
+                # supports arbitrary expressions and not just bare aliases.
+                self._order_by.capture_sort_keys()
+                records.append(record)
+                restores.append(restore)
+                if prov_iter is not None:
+                    try:
+                        provenance.append(next(prov_iter))
+                    except StopIteration:
+                        provenance.append(None)
+            for index in self._order_by.sort_indices(records):
+                restores[index]()
+                self._current_group_provenance = (
+                    None if prov_iter is None else provenance[index]
+                )
+                if self.next:
+                    await self.next.run()
+        else:
+            for _ in self._group_by.generate_results():
+                if prov_iter is not None:
+                    try:
+                        self._current_group_provenance = next(prov_iter)
+                    except StopIteration:
+                        self._current_group_provenance = None
+                if self.next:
+                    await self.next.run()
         self._current_group_provenance = None
         await super().finish()

{flowquery-1.0.62 → flowquery-1.0.63}/src/parsing/operations/group_by.py

@@ -1,7 +1,7 @@
 """GroupBy implementation for aggregate operations."""
 
 import json
-from typing import Any, Callable, Dict, Generator, List, Optional
+from typing import Any, Callable, Dict, Generator, List, Optional, Tuple
 
 from ...compute.provenance import (
     NodeBinding,
@@ -190,13 +190,22 @@ class GroupBy(Projection):
                     self._reducers.extend(child.reducers())
         return self._reducers
 
-    def generate_results(
+    def _generate_leaves(
         self,
         mapper_index: int = 0,
-        node: Optional[GroupByNode] = None
-    ) -> Generator[Dict[str, Any], None, None]:
+        node: Optional[GroupByNode] = None,
+        path: Optional[List[Any]] = None,
+    ) -> Generator[Tuple[GroupByNode, List[Any]], None, None]:
+        """Depth-first walk over the group tree that applies each
+        group's mapper and reducer overrides before yielding its leaf,
+        together with the mapper values collected along the path.
+        Shared by the result, group and provenance generators so they
+        always traverse in identical order.
+        """
         if node is None:
             node = self._root
+        if path is None:
+            path = []
 
         if mapper_index == 0 and len(node.children) == 0 and len(self.mappers) > 0:
             return
@@ -204,46 +213,60 @@ class GroupBy(Projection):
         if len(node.children) > 0:
             for child in node.children.values():
                 self.mappers[mapper_index].overridden = child.value
-                yield from self.generate_results(mapper_index + 1, child)
+                yield from self._generate_leaves(
+                    mapper_index + 1, child, path + [child.value]
+                )
         else:
             if node.elements is None:
                 node.elements = [reducer.element() for reducer in self.reducers]
             if node.elements:
                 for i, element in enumerate(node.elements):
                     self.reducers[i].overridden = element.value
+            yield node, path
+
+    def _make_restore(
+        self, path: List[Any], element_values: List[Any]
+    ) -> Callable[[], None]:
+        # A factory, not an inline closure: consumers hold restorers past
+        # the yield, so the captured values must not be late-bound.
+        def restore() -> None:
+            for i, value in enumerate(path):
+                self.mappers[i].overridden = value
+            for i, value in enumerate(element_values):
+                self.reducers[i].overridden = value
+
+        return restore
+
+    def generate_groups(
+        self,
+    ) -> Generator[Tuple[Dict[str, Any], Callable[[], None]], None, None]:
+        """Yields each emitted group together with a callback that
+        re-applies that group's mapper and reducer overrides.  Lets
+        callers replay groups in an order other than tree-traversal
+        order (e.g. after ORDER BY) while keeping downstream expression
+        evaluation correct.
+        """
+        for node, path in self._generate_leaves():
             record: Dict[str, Any] = {}
             for expression, alias in self.expressions():
                 record[alias] = expression.value()
-            if self.where_condition:
-                yield record
+            if not self.where_condition:
+                continue
+            element_values = [element.value for element in (node.elements or [])]
+            yield record, self._make_restore(path, element_values)
 
-    def generate_provenance(
-        self,
-        mapper_index: int = 0,
-        node: Optional[GroupByNode] = None,
-    ) -> Generator[RowProvenance, None, None]:
+    def generate_results(self) -> Generator[Dict[str, Any], None, None]:
+        for record, _ in self.generate_groups():
+            yield record
+
+    def generate_provenance(self) -> Generator[RowProvenance, None, None]:
         """Walks the group tree in the same traversal order as
         :meth:`generate_results`, yielding the materialised
         :class:`RowProvenance` for each emitted group.
         """
-        if node is None:
-            node = self._root
-
-        if mapper_index == 0 and len(node.children) == 0 and len(self.mappers) > 0:
-            return
-
-        if len(node.children) > 0:
-            for child in node.children.values():
-                self.mappers[mapper_index].overridden = child.value
-                yield from self.generate_provenance(mapper_index + 1, child)
-        else:
-            if node.elements is None:
-                node.elements = [reducer.element() for reducer in self.reducers]
-            if node.elements:
-                for i, element in enumerate(node.elements):
-                    self.reducers[i].overridden = element.value
+        for node, _ in self._generate_leaves():
             if not self.where_condition:
-                return
+                continue
             yield RowProvenance(
                 nodes=list(node.provenance_nodes.values()),
                 relationships=list(node.provenance_relationships.values()),

{flowquery-1.0.62 → flowquery-1.0.63}/src/parsing/operations/order_by.py

@@ -48,6 +48,11 @@ class OrderBy(Operation):
         accumulated row (from ``Return.run()``)."""
         self._sort_keys.append([f.expression.value() for f in self._fields])
 
+    def reset_sort_keys(self) -> None:
+        """Discard keys from a previous emission pass so a re-run starts
+        clean."""
+        self._sort_keys = []
+
     def sort(self, records: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
         """Sort records using pre-computed sort keys captured during
         accumulation.  When no keys have been captured (e.g. aggregated

{flowquery-1.0.62 → flowquery-1.0.63}/src/parsing/parser.py

@@ -38,6 +38,7 @@ from .expressions.operator import (
     In,
     Is,
     IsNot,
+    Negate,
     Not,
     NotContains,
     NotEndsWith,
@@ -1685,6 +1686,19 @@ class Parser(BaseParser):
                 raise ValueError("Expected CASE statement")
             expression.add_node(case)
             return True
+        elif self.token.is_subtract():
+            # Only unary here: a binary minus is consumed as an operator by
+            # _parse_expression, and the tokenizer folds ``-<digit>`` into a
+            # literal.
+            negate = Negate()
+            self.set_next_token()
+            temp_expr = Expression()
+            if not self._parse_operand(temp_expr):
+                raise ValueError("Expected expression after unary minus")
+            temp_expr.finish()
+            negate.add_child(temp_expr)
+            expression.add_node(negate)
+            return True
         elif self.token.is_not():
             not_node = Not()
             self.set_next_token()

{flowquery-1.0.62 → flowquery-1.0.63}/src/tokenization/tokenizer.py

@@ -207,8 +207,19 @@ class Tokenizer:
         return None
 
     def _skip_minus(self, last: Optional[Token], current: Token) -> bool:
-        if last is None:
+        if last is None or not current.is_negation():
             return False
-        if (last.is_keyword() or last.is_comma() or last.is_colon()) and current.is_negation():
-            return True
-        return False
+        # A digit must follow immediately, otherwise relationship patterns
+        # such as ``<-[r]-`` and ``-->`` would lex their ``-`` as a number lead.
+        remaining = self._walker.get_remaining_string()
+        if len(remaining) < 2 or remaining[1] not in '0123456789':
+            return False
+        # Prefix position: no operand can precede the ``-``, so it is a sign.
+        return (
+            last.is_keyword()
+            or last.is_comma()
+            or last.is_colon()
+            or last.is_left_parenthesis()
+            or last.is_opening_bracket()
+            or last.is_operator()
+        )