flowquery 1.0.25 → 1.0.27

package/flowquery-py/pyproject.toml

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

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

@@ -199,6 +199,7 @@ class Parser(BaseParser):
         return Return(expressions)
 
     def _parse_where(self) -> Optional[Where]:
+        self._skip_whitespace_and_comments()
         if not self.token.is_where():
             return None
         self._expect_previous_token_to_be_whitespace_or_comment()
@@ -473,6 +474,12 @@ class Parser(BaseParser):
             self._variables[identifier] = node
         elif identifier is not None:
             reference = self._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):
                 raise ValueError(f"Undefined node reference: {identifier}")
             node = NodeReference(node, reference)
@@ -523,6 +530,13 @@ class Parser(BaseParser):
             self._variables[variable] = relationship
         elif variable is not None:
             reference = self._variables.get(variable)
+            # Resolve through Expression -> Reference -> Relationship (e.g., after WITH)
+            if isinstance(reference, Expression) and isinstance(
+                reference.first_child(), Reference
+            ):
+                inner = reference.first_child().referred
+                if isinstance(inner, Relationship):
+                    reference = inner
             if reference is None or not isinstance(reference, Relationship):
                 raise ValueError(f"Undefined relationship reference: {variable}")
             relationship = RelationshipReference(relationship, reference)

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

@@ -1258,6 +1258,31 @@ class TestRunner:
         assert results[1] == {"name1": "Person 2", "name2": "Person 3"}
         assert results[2] == {"name1": "Person 3", "name2": "Person 4"}
 
+        # Test negative match
+        nomatch = Runner(
+            """
+            MATCH (a:WherePerson), (b:WherePerson)
+            WHERE (a)-[:KNOWS]->(b) <> true
+            RETURN a.name AS name1, b.name AS name2
+            """
+        )
+        await nomatch.run()
+        noresults = nomatch.results
+        assert len(noresults) == 13
+        assert noresults[0] == {"name1": "Person 1", "name2": "Person 1"}
+        assert noresults[1] == {"name1": "Person 1", "name2": "Person 3"}
+        assert noresults[2] == {"name1": "Person 1", "name2": "Person 4"}
+        assert noresults[3] == {"name1": "Person 2", "name2": "Person 1"}
+        assert noresults[4] == {"name1": "Person 2", "name2": "Person 2"}
+        assert noresults[5] == {"name1": "Person 2", "name2": "Person 4"}
+        assert noresults[6] == {"name1": "Person 3", "name2": "Person 1"}
+        assert noresults[7] == {"name1": "Person 3", "name2": "Person 2"}
+        assert noresults[8] == {"name1": "Person 3", "name2": "Person 3"}
+        assert noresults[9] == {"name1": "Person 4", "name2": "Person 1"}
+        assert noresults[10] == {"name1": "Person 4", "name2": "Person 2"}
+        assert noresults[11] == {"name1": "Person 4", "name2": "Person 3"}
+        assert noresults[12] == {"name1": "Person 4", "name2": "Person 4"}
+
     @pytest.mark.asyncio
     async def test_person_who_does_not_know_anyone(self):
         """Test person who does not know anyone."""
@@ -1516,6 +1541,7 @@ 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_constraints(self):
         await Runner(
             """
@@ -1643,4 +1669,44 @@ class TestRunner:
         await runner.run()
         results = runner.results
         assert len(results) == 1
-        assert results[0] == {"name1": "Node 1", "name2": "Node 2"}
+        assert results[0] == {"name1": "Node 1", "name2": "Node 2"}
+
+    @pytest.mark.asyncio
+    async def test_match_with_node_reference_passed_through_with(self):
+        """Test that node variables passed through WITH can be re-referenced in subsequent MATCH."""
+        await Runner("""
+            CREATE VIRTUAL (:WithRefUser) AS {
+                UNWIND [
+                    {id: 1, name: 'Alice', mail: 'alice@test.com', jobTitle: 'CEO'},
+                    {id: 2, name: 'Bob', mail: 'bob@test.com', jobTitle: 'VP'},
+                    {id: 3, name: 'Carol', mail: 'carol@test.com', jobTitle: 'VP'},
+                    {id: 4, name: 'Dave', mail: 'dave@test.com', jobTitle: 'Engineer'}
+                ] AS record
+                RETURN record.id AS id, record.name AS name, record.mail AS mail, record.jobTitle AS jobTitle
+            }
+        """).run()
+        await Runner("""
+            CREATE VIRTUAL (:WithRefUser)-[:MANAGES]-(:WithRefUser) AS {
+                UNWIND [
+                    {left_id: 1, right_id: 2},
+                    {left_id: 1, right_id: 3},
+                    {left_id: 2, right_id: 4}
+                ] AS record
+                RETURN record.left_id AS left_id, record.right_id AS right_id
+            }
+        """).run()
+        runner = Runner("""
+            MATCH (ceo:WithRefUser)-[:MANAGES]->(dr1:WithRefUser)
+            WHERE ceo.jobTitle = 'CEO'
+            WITH ceo, dr1
+            MATCH (ceo)-[:MANAGES]->(dr2:WithRefUser)
+            WHERE dr1.mail <> dr2.mail
+            RETURN ceo.name AS ceo, dr1.name AS dr1, dr2.name AS dr2
+        """)
+        await runner.run()
+        results = runner.results
+        # CEO (Alice) manages Bob and Carol. All distinct pairs:
+        # (Alice, Bob, Carol) and (Alice, Carol, Bob)
+        assert len(results) == 2
+        assert results[0] == {"ceo": "Alice", "dr1": "Bob", "dr2": "Carol"}
+        assert results[1] == {"ceo": "Alice", "dr1": "Carol", "dr2": "Bob"}

package/flowquery-py/tests/parsing/test_parser.py

@@ -6,6 +6,7 @@ from flowquery.parsing.parser import Parser
 from flowquery.parsing.functions.async_function import AsyncFunction
 from flowquery.parsing.functions.function_metadata import FunctionDef
 from flowquery.parsing.operations.match import Match
+from flowquery.parsing.operations.create_relationship import CreateRelationship
 from flowquery.graph.node import Node
 from flowquery.graph.relationship import Relationship
 
@@ -784,6 +785,23 @@ class TestParser:
         assert node.properties.get("value") is not None
         assert node.properties["value"].value() == "hello"
 
+    def test_where_in_create_virtual_sub_query(self):
+        """Test WHERE in CREATE VIRTUAL sub-query."""
+        parser = Parser()
+        ast = parser.parse(
+            "CREATE VIRTUAL (:Email)-[:HAS_ATTACHMENT]-(:File) AS {"
+            " LOAD JSON FROM '/data/emails.json' AS email"
+            " WHERE email.hasAttachments = true"
+            " UNWIND email.attachments AS fileId"
+            " RETURN email.id AS left_id, fileId AS right_id"
+            " }"
+        )
+        create = ast.first_child()
+        assert isinstance(create, CreateRelationship)
+        assert create.relationship is not None
+        assert create.relationship.type == "HAS_ATTACHMENT"
+        assert create.statement is not None
+
     def test_relationship_with_properties(self):
         """Test relationship with properties."""
         parser = Parser()