flowquery 1.0.39 → 1.0.41

package/flowquery-py/pyproject.toml

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

package/flowquery-py/src/graph/database.py

@@ -37,6 +37,12 @@ class Database:
         physical.statement = statement
         Database._nodes[node.label] = physical
 
+    def remove_node(self, node: 'Node') -> None:
+        """Removes a node from the database."""
+        if node.label is None:
+            raise ValueError("Node label is null")
+        Database._nodes.pop(node.label, None)
+
     def get_node(self, node: 'Node') -> Optional['PhysicalNode']:
         """Gets a node from the database."""
         return Database._nodes.get(node.label) if node.label else None
@@ -54,6 +60,12 @@ class Database:
             physical.target = relationship.target
         Database._relationships[relationship.type] = physical
 
+    def remove_relationship(self, relationship: 'Relationship') -> None:
+        """Removes a relationship from the database."""
+        if relationship.type is None:
+            raise ValueError("Relationship type is null")
+        Database._relationships.pop(relationship.type, None)
+
     def get_relationship(self, relationship: 'Relationship') -> Optional['PhysicalRelationship']:
         """Gets a relationship from the database."""
         return Database._relationships.get(relationship.type) if relationship.type else None

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

@@ -48,6 +48,7 @@ from .size import Size
 from .split import Split
 from .string_distance import StringDistance
 from .stringify import Stringify
+from .substring import Substring
 from .sum import Sum
 from .tail import Tail
 from .time_ import Time
@@ -107,6 +108,7 @@ __all__ = [
     "Split",
     "StringDistance",
     "Stringify",
+    "Substring",
     "Tail",
     "Time",
     "Timestamp",

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

@@ -0,0 +1,74 @@
+"""Substring function."""
+
+from typing import Any, List
+
+from ..ast_node import ASTNode
+from .function import Function
+from .function_metadata import FunctionDef
+
+
+@FunctionDef({
+    "description": "Returns a substring of a string, starting at a 0-based index with an optional length",
+    "category": "scalar",
+    "parameters": [
+        {"name": "original", "description": "The original string", "type": "string"},
+        {"name": "start", "description": "The 0-based start index", "type": "integer"},
+        {
+            "name": "length",
+            "description": "The length of the substring (optional)",
+            "type": "integer",
+        }
+    ],
+    "output": {"description": "The substring", "type": "string", "example": "llo"},
+    "examples": [
+        "RETURN substring('hello', 1, 3)",
+        "RETURN substring('hello', 2)"
+    ]
+})
+class Substring(Function):
+    """Substring function.
+
+    Returns a substring of a string, starting at a 0-based index with an optional length.
+    """
+
+    def __init__(self) -> None:
+        super().__init__("substring")
+
+    @property
+    def parameters(self) -> List[ASTNode]:
+        return self.get_children()
+
+    @parameters.setter
+    def parameters(self, nodes: List[ASTNode]) -> None:
+        if len(nodes) < 2 or len(nodes) > 3:
+            raise ValueError(
+                f"Function substring expected 2 or 3 parameters, but got {len(nodes)}"
+            )
+        for node in nodes:
+            self.add_child(node)
+
+    def value(self) -> Any:
+        children = self.get_children()
+        original = children[0].value()
+        start = children[1].value()
+
+        if not isinstance(original, str):
+            raise ValueError(
+                "Invalid argument for substring function: expected a string as the first argument"
+            )
+        if not isinstance(start, (int, float)) or (isinstance(start, float) and not start.is_integer()):
+            raise ValueError(
+                "Invalid argument for substring function: expected an integer as the second argument"
+            )
+        start = int(start)
+
+        if len(children) == 3:
+            length = children[2].value()
+            if not isinstance(length, (int, float)) or (isinstance(length, float) and not length.is_integer()):
+                raise ValueError(
+                    "Invalid argument for substring function: expected an integer as the third argument"
+                )
+            length = int(length)
+            return original[start:start + length]
+
+        return original[start:]

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

@@ -5,6 +5,8 @@ from .aggregated_with import AggregatedWith
 from .call import Call
 from .create_node import CreateNode
 from .create_relationship import CreateRelationship
+from .delete_node import DeleteNode
+from .delete_relationship import DeleteRelationship
 from .group_by import GroupBy
 from .limit import Limit
 from .load import Load
@@ -35,6 +37,8 @@ __all__ = [
     "Match",
     "CreateNode",
     "CreateRelationship",
+    "DeleteNode",
+    "DeleteRelationship",
     "Union",
     "UnionAll",
     "OrderBy",

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

@@ -0,0 +1,29 @@
+"""Represents a DELETE operation for deleting virtual nodes."""
+
+from typing import Any, Dict, List
+
+from ...graph.database import Database
+from ...graph.node import Node
+from .operation import Operation
+
+
+class DeleteNode(Operation):
+    """Represents a DELETE operation for deleting virtual nodes."""
+
+    def __init__(self, node: Node) -> None:
+        super().__init__()
+        self._node = node
+
+    @property
+    def node(self) -> Node:
+        return self._node
+
+    async def run(self) -> None:
+        if self._node is None:
+            raise ValueError("Node is null")
+        db = Database.get_instance()
+        db.remove_node(self._node)
+
+    @property
+    def results(self) -> List[Dict[str, Any]]:
+        return []

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

@@ -0,0 +1,29 @@
+"""Represents a DELETE operation for deleting virtual relationships."""
+
+from typing import Any, Dict, List
+
+from ...graph.database import Database
+from ...graph.relationship import Relationship
+from .operation import Operation
+
+
+class DeleteRelationship(Operation):
+    """Represents a DELETE operation for deleting virtual relationships."""
+
+    def __init__(self, relationship: Relationship) -> None:
+        super().__init__()
+        self._relationship = relationship
+
+    @property
+    def relationship(self) -> Relationship:
+        return self._relationship
+
+    async def run(self) -> None:
+        if self._relationship is None:
+            raise ValueError("Relationship is null")
+        db = Database.get_instance()
+        db.remove_relationship(self._relationship)
+
+    @property
+    def results(self) -> List[Dict[str, Any]]:
+        return []

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

@@ -57,6 +57,8 @@ from .operations.aggregated_with import AggregatedWith
 from .operations.call import Call
 from .operations.create_node import CreateNode
 from .operations.create_relationship import CreateRelationship
+from .operations.delete_node import DeleteNode
+from .operations.delete_relationship import DeleteRelationship
 from .operations.limit import Limit
 from .operations.load import Load
 from .operations.match import Match
@@ -185,8 +187,8 @@ class Parser(BaseParser):
             new_root.add_child(union)
             return new_root
 
-        if not isinstance(operation, (Return, Call, CreateNode, CreateRelationship)):
-            raise ValueError("Last statement must be a RETURN, WHERE, CALL, or CREATE statement")
+        if not isinstance(operation, (Return, Call, CreateNode, CreateRelationship, DeleteNode, DeleteRelationship)):
+            raise ValueError("Last statement must be a RETURN, WHERE, CALL, CREATE, or DELETE statement")
 
         return root
 
@@ -198,7 +200,8 @@ class Parser(BaseParser):
             self._parse_load() or
             self._parse_call() or
             self._parse_match() or
-            self._parse_create()
+            self._parse_create() or
+            self._parse_delete()
         )
 
     def _parse_with(self) -> Optional[With]:
@@ -211,7 +214,7 @@ class Parser(BaseParser):
             distinct = True
             self.set_next_token()
             self._expect_and_skip_whitespace_and_comments()
-        expressions = list(self._parse_expressions(AliasOption.REQUIRED))
+        expressions = self._parse_expressions(AliasOption.REQUIRED)
         if len(expressions) == 0:
             raise ValueError("Expected expression")
         if distinct or any(expr.has_reducers() for expr in expressions):
@@ -251,7 +254,7 @@ class Parser(BaseParser):
             distinct = True
             self.set_next_token()
             self._expect_and_skip_whitespace_and_comments()
-        expressions = list(self._parse_expressions(AliasOption.OPTIONAL))
+        expressions = self._parse_expressions(AliasOption.OPTIONAL)
         if len(expressions) == 0:
             raise ValueError("Expected expression")
         if distinct or any(expr.has_reducers() for expr in expressions):
@@ -350,7 +353,7 @@ class Parser(BaseParser):
             self._expect_previous_token_to_be_whitespace_or_comment()
             self.set_next_token()
             self._expect_and_skip_whitespace_and_comments()
-            expressions = list(self._parse_expressions(AliasOption.OPTIONAL))
+            expressions = self._parse_expressions(AliasOption.OPTIONAL)
             if len(expressions) == 0:
                 raise ValueError("Expected at least one expression")
             call.yielded = expressions  # type: ignore[assignment]
@@ -431,6 +434,54 @@ class Parser(BaseParser):
         else:
             return CreateNode(node, query)
 
+    def _parse_delete(self) -> Optional[Operation]:
+        """Parse DELETE VIRTUAL statement for nodes and relationships."""
+        if not self.token.is_delete():
+            return None
+        self.set_next_token()
+        self._expect_and_skip_whitespace_and_comments()
+        if not self.token.is_virtual():
+            raise ValueError("Expected VIRTUAL")
+        self.set_next_token()
+        self._expect_and_skip_whitespace_and_comments()
+
+        node = self._parse_node()
+        if node is None:
+            raise ValueError("Expected node definition")
+
+        relationship: Optional[Relationship] = None
+        if self.token.is_subtract() and self.peek() and self.peek().is_opening_bracket():
+            self.set_next_token()  # skip -
+            self.set_next_token()  # skip [
+            if not self.token.is_colon():
+                raise ValueError("Expected ':' for relationship type")
+            self.set_next_token()
+            if not self.token.is_identifier_or_keyword():
+                raise ValueError("Expected relationship type identifier")
+            rel_type = self.token.value or ""
+            self.set_next_token()
+            if not self.token.is_closing_bracket():
+                raise ValueError("Expected closing bracket for relationship definition")
+            self.set_next_token()
+            if not self.token.is_subtract():
+                raise ValueError("Expected '-' for relationship definition")
+            self.set_next_token()
+            # Skip optional direction indicator '>'
+            if self.token.is_greater_than():
+                self.set_next_token()
+            target = self._parse_node()
+            if target is None:
+                raise ValueError("Expected target node definition")
+            relationship = Relationship()
+            relationship.type = rel_type
+            relationship.source = node
+            relationship.target = target
+
+        if relationship is not None:
+            return DeleteRelationship(relationship)
+        else:
+            return DeleteNode(node)
+
     def _parse_union(self) -> Optional[Union]:
         """Parse a UNION or UNION ALL keyword."""
         if not self.token.is_union():
@@ -740,16 +791,30 @@ class Parser(BaseParser):
 
     def _parse_expressions(
         self, alias_option: AliasOption = AliasOption.NOT_ALLOWED
-    ) -> Iterator[Expression]:
+    ) -> List[Expression]:
+        """Parse a comma-separated list of expressions with deferred variable
+        registration.  Aliases set by earlier expressions in the same clause
+        won't shadow variables needed by later expressions
+        (e.g. ``RETURN a.x AS a, a.y AS b``)."""
+        parsed = list(self.__parse_expressions(alias_option))
+        for expression, variable_name in parsed:
+            if variable_name is not None:
+                self._state.variables[variable_name] = expression
+        return [expression for expression, _ in parsed]
+
+    def __parse_expressions(
+        self, alias_option: AliasOption
+    ) -> Iterator[Tuple[Expression, Optional[str]]]:
         while True:
             expression = self._parse_expression()
             if expression is not None:
+                variable_name: Optional[str] = None
                 alias = self._parse_alias()
                 if isinstance(expression.first_child(), Reference) and alias is None:
                     reference = expression.first_child()
                     assert isinstance(reference, Reference)  # For type narrowing
                     expression.set_alias(reference.identifier)
-                    self._state.variables[reference.identifier] = expression
+                    variable_name = reference.identifier
                 elif (alias_option == AliasOption.REQUIRED and
                       alias is None and
                       not isinstance(expression.first_child(), Reference)):
@@ -758,8 +823,8 @@ class Parser(BaseParser):
                     raise ValueError("Alias not allowed")
                 elif alias_option in (AliasOption.OPTIONAL, AliasOption.REQUIRED) and alias is not None:
                     expression.set_alias(alias.get_alias())
-                    self._state.variables[alias.get_alias()] = expression
-                yield expression
+                    variable_name = alias.get_alias()
+                yield expression, variable_name
             else:
                 break
             self._skip_whitespace_and_comments()

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

@@ -3,6 +3,9 @@
 import pytest
 from typing import AsyncIterator
 from flowquery.compute.runner import Runner
+from flowquery.graph.node import Node
+from flowquery.graph.relationship import Relationship
+from flowquery.graph.database import Database
 from flowquery.parsing.functions.async_function import AsyncFunction
 from flowquery.parsing.functions.function_metadata import FunctionDef
 
@@ -810,6 +813,42 @@ class TestRunner:
         assert len(results) == 1
         assert results[0] == {"result": ""}
 
+    @pytest.mark.asyncio
+    async def test_substring_function_with_start_and_length(self):
+        """Test substring function with start and length."""
+        runner = Runner('RETURN substring("hello", 1, 3) as result')
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": "ell"}
+
+    @pytest.mark.asyncio
+    async def test_substring_function_with_start_only(self):
+        """Test substring function with start only."""
+        runner = Runner('RETURN substring("hello", 2) as result')
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": "llo"}
+
+    @pytest.mark.asyncio
+    async def test_substring_function_with_zero_start(self):
+        """Test substring function with zero start."""
+        runner = Runner('RETURN substring("hello", 0, 5) as result')
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": "hello"}
+
+    @pytest.mark.asyncio
+    async def test_substring_function_with_zero_length(self):
+        """Test substring function with zero length."""
+        runner = Runner('RETURN substring("hello", 1, 0) as result')
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": ""}
+
     @pytest.mark.asyncio
     async def test_associative_array_with_key_which_is_keyword(self):
         """Test associative array with key which is keyword."""
@@ -4169,4 +4208,190 @@ class TestRunner:
         assert results[1] == {"x": 6}
         assert results[2] == {"x": 5}
         assert results[3] == {"x": 4}
-        assert results[4] == {"x": 3}
+        assert results[4] == {"x": 3}
+
+    @pytest.mark.asyncio
+    async def test_delete_virtual_node_operation(self):
+        """Test delete virtual node operation."""
+        db = Database.get_instance()
+        # Create a virtual node first
+        create = Runner(
+            """
+            CREATE VIRTUAL (:PyDeleteTestPerson) AS {
+                unwind [
+                    {id: 1, name: 'Person 1'},
+                    {id: 2, name: 'Person 2'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        )
+        await create.run()
+        assert db.get_node(Node(None, "PyDeleteTestPerson")) is not None
+
+        # Delete the virtual node
+        del_runner = Runner("DELETE VIRTUAL (:PyDeleteTestPerson)")
+        await del_runner.run()
+        assert len(del_runner.results) == 0
+        assert db.get_node(Node(None, "PyDeleteTestPerson")) is None
+
+    @pytest.mark.asyncio
+    async def test_delete_virtual_node_then_match_throws(self):
+        """Test that matching a deleted virtual node throws."""
+        # Create a virtual node
+        create = Runner(
+            """
+            CREATE VIRTUAL (:PyDeleteMatchPerson) AS {
+                unwind [{id: 1, name: 'Alice'}] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        )
+        await create.run()
+
+        # Verify it can be matched
+        match1 = Runner("MATCH (n:PyDeleteMatchPerson) RETURN n")
+        await match1.run()
+        assert len(match1.results) == 1
+
+        # Delete the virtual node
+        del_runner = Runner("DELETE VIRTUAL (:PyDeleteMatchPerson)")
+        await del_runner.run()
+
+        # Matching should now throw since the node is gone
+        match2 = Runner("MATCH (n:PyDeleteMatchPerson) RETURN n")
+        with pytest.raises(ValueError):
+            await match2.run()
+
+    @pytest.mark.asyncio
+    async def test_delete_virtual_relationship_operation(self):
+        """Test delete virtual relationship operation."""
+        db = Database.get_instance()
+        # Create virtual nodes and relationship
+        await Runner(
+            """
+            CREATE VIRTUAL (:PyDelRelUser) AS {
+                unwind [
+                    {id: 1, name: 'Alice'},
+                    {id: 2, name: 'Bob'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+
+        await Runner(
+            """
+            CREATE VIRTUAL (:PyDelRelUser)-[:PY_DEL_KNOWS]-(:PyDelRelUser) AS {
+                unwind [
+                    {left_id: 1, right_id: 2}
+                ] as record
+                RETURN record.left_id as left_id, record.right_id as right_id
+            }
+            """
+        ).run()
+
+        # Verify relationship exists
+        rel = Relationship()
+        rel.type = "PY_DEL_KNOWS"
+        assert db.get_relationship(rel) is not None
+
+        # Delete the virtual relationship
+        del_runner = Runner("DELETE VIRTUAL (:PyDelRelUser)-[:PY_DEL_KNOWS]-(:PyDelRelUser)")
+        await del_runner.run()
+        assert len(del_runner.results) == 0
+        assert db.get_relationship(rel) is None
+
+    @pytest.mark.asyncio
+    async def test_delete_virtual_node_leaves_other_nodes_intact(self):
+        """Test that deleting one virtual node leaves others intact."""
+        db = Database.get_instance()
+        # Create two virtual node types
+        await Runner(
+            """
+            CREATE VIRTUAL (:PyKeepNode) AS {
+                unwind [{id: 1, name: 'Keep'}] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+
+        await Runner(
+            """
+            CREATE VIRTUAL (:PyRemoveNode) AS {
+                unwind [{id: 2, name: 'Remove'}] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+
+        assert db.get_node(Node(None, "PyKeepNode")) is not None
+        assert db.get_node(Node(None, "PyRemoveNode")) is not None
+
+        # Delete only one
+        await Runner("DELETE VIRTUAL (:PyRemoveNode)").run()
+
+        # The other should still exist
+        assert db.get_node(Node(None, "PyKeepNode")) is not None
+        assert db.get_node(Node(None, "PyRemoveNode")) is None
+
+        # The remaining node can still be matched
+        match = Runner("MATCH (n:PyKeepNode) RETURN n")
+        await match.run()
+        assert len(match.results) == 1
+        assert match.results[0]["n"]["name"] == "Keep"
+
+    @pytest.mark.asyncio
+    async def test_return_alias_shadowing_graph_variable(self):
+        """Test that RETURN alias doesn't shadow graph variable in same clause.
+
+        When RETURN mentor.displayName AS mentor is followed by mentor.jobTitle,
+        the alias 'mentor' should not overwrite the graph node variable before
+        subsequent expressions are parsed.
+        """
+        await Runner(
+            """
+            CREATE VIRTUAL (:PyMentorUser) AS {
+                UNWIND [
+                    {id: 1, displayName: 'Alice Smith', jobTitle: 'Senior Engineer', department: 'Engineering'},
+                    {id: 2, displayName: 'Bob Jones', jobTitle: 'Staff Engineer', department: 'Engineering'},
+                    {id: 3, displayName: 'Chloe Dubois', jobTitle: 'Junior Engineer', department: 'Engineering'}
+                ] AS record
+                RETURN record.id AS id, record.displayName AS displayName, record.jobTitle AS jobTitle, record.department AS department
+            }
+            """
+        ).run()
+
+        await Runner(
+            """
+            CREATE VIRTUAL (:PyMentorUser)-[:PY_MENTORS]-(:PyMentorUser) AS {
+                UNWIND [
+                    {left_id: 1, right_id: 3},
+                    {left_id: 2, right_id: 3}
+                ] AS record
+                RETURN record.left_id AS left_id, record.right_id AS right_id
+            }
+            """
+        ).run()
+
+        runner = Runner(
+            """
+            MATCH (mentor:PyMentorUser)-[:PY_MENTORS]->(mentee:PyMentorUser)
+            WHERE mentee.displayName = "Chloe Dubois"
+            RETURN mentor.displayName AS mentor, mentor.jobTitle AS mentorJobTitle, mentor.department AS mentorDepartment
+            """
+        )
+        await runner.run()
+        results = runner.results
+
+        assert len(results) == 2
+        assert results[0] == {
+            "mentor": "Alice Smith",
+            "mentorJobTitle": "Senior Engineer",
+            "mentorDepartment": "Engineering",
+        }
+        assert results[1] == {
+            "mentor": "Bob Jones",
+            "mentorJobTitle": "Staff Engineer",
+            "mentorDepartment": "Engineering",
+        }