flowquery 1.0.36 → 1.0.38

package/flowquery-py/pyproject.toml

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

package/flowquery-py/src/parsing/functions/coalesce.py

@@ -22,7 +22,6 @@ class Coalesce(Function):
     """Coalesce function.
 
     Returns the first non-null value from a list of expressions.
-    Equivalent to Neo4j's coalesce() function.
     """
 
     def __init__(self) -> None:
@@ -37,7 +36,7 @@ class Coalesce(Function):
             try:
                 val = child.value()
             except (KeyError, AttributeError):
-                # Treat missing properties/keys as null, matching Neo4j behavior
+                # Treat missing properties/keys as null
                 val = None
             if val is not None:
                 return val

package/flowquery-py/src/parsing/functions/date_.py

@@ -42,8 +42,6 @@ class DateFunction(Function):
     Returns a date value (no time component).
     When called with no arguments, returns the current date.
     When called with a string argument, parses it as an ISO 8601 date.
-
-    Equivalent to Neo4j's date() function.
     """
 
     def __init__(self) -> None:

package/flowquery-py/src/parsing/functions/datetime_.py

@@ -43,8 +43,6 @@ class Datetime(Function):
     When called with no arguments, returns the current UTC datetime.
     When called with a string argument, parses it as an ISO 8601 datetime.
     When called with a map argument, constructs a datetime from components.
-
-    Equivalent to Neo4j's datetime() function.
     """
 
     def __init__(self) -> None:

package/flowquery-py/src/parsing/functions/localdatetime.py

@@ -41,8 +41,6 @@ class LocalDatetime(Function):
     Returns a local datetime value (date + time, no timezone offset).
     When called with no arguments, returns the current local datetime.
     When called with a string argument, parses it as an ISO 8601 datetime.
-
-    Equivalent to Neo4j's localdatetime() function.
     """
 
     def __init__(self) -> None:

package/flowquery-py/src/parsing/functions/localtime.py

@@ -38,8 +38,6 @@ class LocalTime(Function):
     Returns a local time value (no timezone offset).
     When called with no arguments, returns the current local time.
     When called with a string argument, parses it.
-
-    Equivalent to Neo4j's localtime() function.
     """
 
     def __init__(self) -> None:

package/flowquery-py/src/parsing/functions/temporal_utils.py

@@ -9,7 +9,7 @@ from typing import Any, Dict
 
 
 def iso_day_of_week(d: date) -> int:
-    """Computes the ISO day of the week (1 = Monday, 7 = Sunday) matching Neo4j convention."""
+    """Computes the ISO day of the week (1 = Monday, 7 = Sunday)."""
     return d.isoweekday()
 
 

package/flowquery-py/src/parsing/functions/time_.py

@@ -38,8 +38,6 @@ class Time(Function):
     Returns a time value (with timezone offset awareness).
     When called with no arguments, returns the current UTC time.
     When called with a string argument, parses it.
-
-    Equivalent to Neo4j's time() function.
     """
 
     def __init__(self) -> None:

package/flowquery-py/src/parsing/functions/timestamp.py

@@ -9,8 +9,7 @@ from .function_metadata import FunctionDef
 
 @FunctionDef({
     "description": (
-        "Returns the number of milliseconds since the Unix epoch (1970-01-01T00:00:00Z). "
-        "Equivalent to Neo4j's timestamp() function."
+        "Returns the number of milliseconds since the Unix epoch (1970-01-01T00:00:00Z)."
     ),
     "category": "scalar",
     "parameters": [],
@@ -28,7 +27,6 @@ class Timestamp(Function):
     """Timestamp function.
 
     Returns the number of milliseconds since the Unix epoch (1970-01-01T00:00:00Z).
-    Equivalent to Neo4j's timestamp() function.
     """
 
     def __init__(self) -> None:

package/flowquery-py/src/parsing/operations/limit.py

@@ -11,6 +11,13 @@ class Limit(Operation):
         self._count = 0
         self._limit = limit
 
+    @property
+    def is_limit_reached(self) -> bool:
+        return self._count >= self._limit
+
+    def increment(self) -> None:
+        self._count += 1
+
     async def run(self) -> None:
         if self._count >= self._limit:
             return

package/flowquery-py/src/parsing/operations/return_op.py

@@ -4,6 +4,7 @@ import copy
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from ..ast_node import ASTNode
+from .limit import Limit
 from .projection import Projection
 
 if TYPE_CHECKING:
@@ -24,6 +25,7 @@ class Return(Projection):
         super().__init__(expressions)
         self._where: Optional['Where'] = None
         self._results: List[Dict[str, Any]] = []
+        self._limit: Optional[Limit] = None
 
     @property
     def where(self) -> Any:
@@ -35,9 +37,19 @@ class Return(Projection):
     def where(self, where: 'Where') -> None:
         self._where = where
 
+    @property
+    def limit(self) -> Optional[Limit]:
+        return self._limit
+
+    @limit.setter
+    def limit(self, limit: Limit) -> None:
+        self._limit = limit
+
     async def run(self) -> None:
         if not self.where:
             return
+        if self._limit is not None and self._limit.is_limit_reached:
+            return
         record: Dict[str, Any] = {}
         for expression, alias in self.expressions():
             raw = expression.value()
@@ -45,6 +57,8 @@ class Return(Projection):
             value = copy.deepcopy(raw) if isinstance(raw, (dict, list)) else raw
             record[alias] = value
         self._results.append(record)
+        if self._limit is not None:
+            self._limit.increment()
 
     async def initialize(self) -> None:
         self._results = []

package/flowquery-py/src/parsing/parser.py

@@ -116,6 +116,9 @@ class Parser(BaseParser):
             if self.token.is_union():
                 break
 
+            if self.token.is_eof():
+                break
+
             operation = self._parse_operation()
             if operation is None and not is_sub_query:
                 raise ValueError("Expected one of WITH, UNWIND, RETURN, LOAD, OR CALL")
@@ -145,8 +148,11 @@ class Parser(BaseParser):
 
             limit = self._parse_limit()
             if limit is not None:
-                operation.add_sibling(limit)
-                operation = limit
+                if isinstance(operation, Return):
+                    operation.limit = limit
+                else:
+                    operation.add_sibling(limit)
+                    operation = limit
 
             previous = operation
 
@@ -539,13 +545,11 @@ class Parser(BaseParser):
         node.properties = dict(self._parse_properties())
         if identifier is not None and identifier in self._state.variables:
             reference = self._state.variables.get(identifier)
-            # Resolve through Expression -> Reference -> Node (e.g., after WITH)
-            ref_child = reference.first_child() if isinstance(reference, Expression) else None
-            if isinstance(ref_child, Reference):
-                inner = ref_child.referred
-                if isinstance(inner, Node):
-                    reference = inner
-            if reference is None or (not isinstance(reference, Node) and not isinstance(reference, Unwind)):
+            if reference is None or (
+                not isinstance(reference, Node)
+                and not isinstance(reference, Unwind)
+                and not isinstance(reference, Expression)
+            ):
                 raise ValueError(f"Undefined node reference: {identifier}")
             node = NodeReference(node, reference)
         elif identifier is not None:

package/flowquery-py/tests/compute/test_runner.py

@@ -925,6 +925,20 @@ class TestRunner:
         results = runner.results
         assert len(results) == 50
 
+    @pytest.mark.asyncio
+    async def test_limit_as_last_operation(self):
+        """Test limit as the last operation after return."""
+        runner = Runner(
+            """
+            unwind range(1, 10) as i
+            return i
+            limit 5
+            """
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 5
+
     @pytest.mark.asyncio
     async def test_range_lookup(self):
         """Test range lookup."""
@@ -1457,6 +1471,71 @@ class TestRunner:
         assert results[0] == {"name1": "Person 1", "name2": "Person 2", "name3": "Person 3"}
         assert results[1] == {"name1": "Person 2", "name2": "Person 3", "name3": "Person 4"}
 
+    @pytest.mark.asyncio
+    async def test_match_with_aggregated_with_and_subsequent_match(self):
+        """Test match with aggregated WITH followed by another match using the same node reference."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:AggUser) AS {
+                unwind [
+                    {id: 1, name: 'Alice'},
+                    {id: 2, name: 'Bob'},
+                    {id: 3, name: 'Carol'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:AggUser)-[:KNOWS]-(:AggUser) AS {
+                unwind [
+                    {left_id: 1, right_id: 2},
+                    {left_id: 1, right_id: 3}
+                ] as record
+                RETURN record.left_id as left_id, record.right_id as right_id
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:AggProject) AS {
+                unwind [
+                    {id: 1, name: 'Project A'},
+                    {id: 2, name: 'Project B'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:AggUser)-[:WORKS_ON]-(:AggProject) AS {
+                unwind [
+                    {left_id: 1, right_id: 1},
+                    {left_id: 1, right_id: 2}
+                ] as record
+                RETURN record.left_id as left_id, record.right_id as right_id
+            }
+            """
+        ).run()
+        match = Runner(
+            """
+            MATCH (u:AggUser)-[:KNOWS]->(s:AggUser)
+            WITH u, count(s) as acquaintances
+            MATCH (u)-[:WORKS_ON]->(p:AggProject)
+            RETURN u.name as name, acquaintances, collect(p.name) as projects
+            """
+        )
+        await match.run()
+        results = match.results
+        assert len(results) == 1
+        assert results[0] == {
+            "name": "Alice",
+            "acquaintances": 2,
+            "projects": ["Project A", "Project B"],
+        }
+
     @pytest.mark.asyncio
     async def test_match_and_return_full_node(self):
         """Test match and return full node."""
@@ -2232,7 +2311,7 @@ class TestRunner:
             }
             """
         ).run()
-        # When accessing b.name and b is null (no match), should return null like Neo4j
+        # When accessing b.name and b is null (no match), should return null
         match = Runner(
             """
             MATCH (a:OptPropPerson)
@@ -3427,7 +3506,7 @@ class TestRunner:
         assert results[0] == {"result": "Alice"}
 
     # ============================================================
-    # Temporal / Time Functions (Neo4j-style)
+    # Temporal / Time Functions
     # ============================================================
 
     @pytest.mark.asyncio