flowquery 1.0.38 → 1.0.40

package/flowquery-py/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flowquery"
-version = "1.0.28"
+version = "1.0.30"
 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/expressions/operator.py

@@ -163,7 +163,7 @@ class Not(Operator):
 
 class Is(Operator):
     def __init__(self) -> None:
-        super().__init__(-1, True)
+        super().__init__(0, True)
 
     def value(self) -> int:
         return 1 if self.lhs.value() == self.rhs.value() else 0
@@ -171,7 +171,7 @@ class Is(Operator):
 
 class IsNot(Operator):
     def __init__(self) -> None:
-        super().__init__(-1, True)
+        super().__init__(0, True)
 
     def value(self) -> int:
         return 1 if self.lhs.value() != self.rhs.value() else 0
@@ -179,7 +179,7 @@ class IsNot(Operator):
 
 class In(Operator):
     def __init__(self) -> None:
-        super().__init__(-1, True)
+        super().__init__(0, True)
 
     def value(self) -> int:
         lst = self.rhs.value()
@@ -190,7 +190,7 @@ class In(Operator):
 
 class NotIn(Operator):
     def __init__(self) -> None:
-        super().__init__(-1, True)
+        super().__init__(0, True)
 
     def value(self) -> int:
         lst = self.rhs.value()

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,11 +5,14 @@ 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
 from .match import Match
 from .operation import Operation
+from .order_by import OrderBy, SortField
 from .projection import Projection
 from .return_op import Return
 from .union import Union
@@ -34,6 +37,10 @@ __all__ = [
     "Match",
     "CreateNode",
     "CreateRelationship",
+    "DeleteNode",
+    "DeleteRelationship",
     "Union",
     "UnionAll",
+    "OrderBy",
+    "SortField",
 ]

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

@@ -19,4 +19,7 @@ class AggregatedReturn(Return):
     def results(self) -> List[Dict[str, Any]]:
         if self._where is not None:
             self._group_by.where = self._where
-        return list(self._group_by.generate_results())
+        results = list(self._group_by.generate_results())
+        if self._order_by is not None:
+            results = self._order_by.sort(results)
+        return results

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/operations/limit.py

@@ -15,6 +15,10 @@ class Limit(Operation):
     def is_limit_reached(self) -> bool:
         return self._count >= self._limit
 
+    @property
+    def limit_value(self) -> int:
+        return self._limit
+
     def increment(self) -> None:
         self._count += 1
 

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

@@ -0,0 +1,72 @@
+"""Represents an ORDER BY operation that sorts results."""
+
+from typing import Any, Dict, List
+
+from .operation import Operation
+
+
+class SortField:
+    """A single sort specification: field name and direction."""
+
+    def __init__(self, field: str, direction: str = "asc"):
+        self.field = field
+        self.direction = direction
+
+
+class OrderBy(Operation):
+    """Represents an ORDER BY operation that sorts results.
+
+    Can be attached to a RETURN operation (sorting its results),
+    or used as a standalone accumulating operation after a non-aggregate WITH.
+
+    Example:
+        RETURN x ORDER BY x DESC
+    """
+
+    def __init__(self, fields: List[SortField]):
+        super().__init__()
+        self._fields = fields
+        self._results: List[Dict[str, Any]] = []
+
+    @property
+    def fields(self) -> List[SortField]:
+        return self._fields
+
+    def sort(self, records: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Sorts an array of records according to the sort fields."""
+        import functools
+
+        def compare(a: Dict[str, Any], b: Dict[str, Any]) -> int:
+            for sf in self._fields:
+                a_val = a.get(sf.field)
+                b_val = b.get(sf.field)
+                cmp = 0
+                if a_val is None and b_val is None:
+                    cmp = 0
+                elif a_val is None:
+                    cmp = -1
+                elif b_val is None:
+                    cmp = 1
+                elif a_val < b_val:
+                    cmp = -1
+                elif a_val > b_val:
+                    cmp = 1
+                if cmp != 0:
+                    return -cmp if sf.direction == "desc" else cmp
+            return 0
+
+        return sorted(records, key=functools.cmp_to_key(compare))
+
+    async def run(self) -> None:
+        """When used as a standalone operation, passes through to next."""
+        if self.next:
+            await self.next.run()
+
+    async def initialize(self) -> None:
+        self._results = []
+        if self.next:
+            await self.next.initialize()
+
+    @property
+    def results(self) -> List[Dict[str, Any]]:
+        return self._results

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

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from ..ast_node import ASTNode
 from .limit import Limit
+from .order_by import OrderBy
 from .projection import Projection
 
 if TYPE_CHECKING:
@@ -26,6 +27,7 @@ class Return(Projection):
         self._where: Optional['Where'] = None
         self._results: List[Dict[str, Any]] = []
         self._limit: Optional[Limit] = None
+        self._order_by: Optional[OrderBy] = None
 
     @property
     def where(self) -> Any:
@@ -45,10 +47,20 @@ class Return(Projection):
     def limit(self, limit: Limit) -> None:
         self._limit = limit
 
+    @property
+    def order_by(self) -> Optional[OrderBy]:
+        return self._order_by
+
+    @order_by.setter
+    def order_by(self, order_by: OrderBy) -> None:
+        self._order_by = order_by
+
     async def run(self) -> None:
         if not self.where:
             return
-        if self._limit is not None and self._limit.is_limit_reached:
+        # When ORDER BY is present, skip limit during accumulation;
+        # limit will be applied after sorting in results property
+        if self._order_by is None and self._limit is not None and self._limit.is_limit_reached:
             return
         record: Dict[str, Any] = {}
         for expression, alias in self.expressions():
@@ -57,7 +69,7 @@ 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:
+        if self._order_by is None and self._limit is not None:
             self._limit.increment()
 
     async def initialize(self) -> None:
@@ -65,4 +77,9 @@ class Return(Projection):
 
     @property
     def results(self) -> List[Dict[str, Any]]:
-        return self._results
+        result = self._results
+        if self._order_by is not None:
+            result = self._order_by.sort(result)
+        if self._order_by is not None and self._limit is not None:
+            result = result[:self._limit.limit_value]
+        return result

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

@@ -57,10 +57,13 @@ 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
 from .operations.operation import Operation
+from .operations.order_by import OrderBy, SortField
 from .operations.return_op import Return
 from .operations.union import Union
 from .operations.union_all import UnionAll
@@ -146,6 +149,14 @@ class Parser(BaseParser):
                     operation.add_sibling(where)
                     operation = where
 
+            order_by = self._parse_order_by()
+            if order_by is not None:
+                if isinstance(operation, Return):
+                    operation.order_by = order_by
+                else:
+                    operation.add_sibling(order_by)
+                    operation = order_by
+
             limit = self._parse_limit()
             if limit is not None:
                 if isinstance(operation, Return):
@@ -176,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
 
@@ -189,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]:
@@ -422,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():
@@ -694,6 +754,41 @@ class Parser(BaseParser):
         self.set_next_token()
         return limit
 
+    def _parse_order_by(self) -> Optional[OrderBy]:
+        self._skip_whitespace_and_comments()
+        if not self.token.is_order():
+            return None
+        self._expect_previous_token_to_be_whitespace_or_comment()
+        self.set_next_token()
+        self._expect_and_skip_whitespace_and_comments()
+        if not self.token.is_by():
+            raise ValueError("Expected BY after ORDER")
+        self.set_next_token()
+        self._expect_and_skip_whitespace_and_comments()
+        fields: list[SortField] = []
+        while True:
+            if not self.token.is_identifier_or_keyword():
+                raise ValueError("Expected field name in ORDER BY")
+            field = self.token.value
+            self.set_next_token()
+            self._skip_whitespace_and_comments()
+            direction = "asc"
+            if self.token.is_asc():
+                direction = "asc"
+                self.set_next_token()
+                self._skip_whitespace_and_comments()
+            elif self.token.is_desc():
+                direction = "desc"
+                self.set_next_token()
+                self._skip_whitespace_and_comments()
+            fields.append(SortField(field, direction))
+            if self.token.is_comma():
+                self.set_next_token()
+                self._skip_whitespace_and_comments()
+            else:
+                break
+        return OrderBy(fields)
+
     def _parse_expressions(
         self, alias_option: AliasOption = AliasOption.NOT_ALLOWED
     ) -> Iterator[Expression]:

package/flowquery-py/src/tokenization/token.py

@@ -630,6 +630,34 @@ class Token:
     def is_all(self) -> bool:
         return self._type == TokenType.KEYWORD and self._value == Keyword.ALL.value
 
+    @staticmethod
+    def ORDER() -> Token:
+        return Token(TokenType.KEYWORD, Keyword.ORDER.value)
+
+    def is_order(self) -> bool:
+        return self._type == TokenType.KEYWORD and self._value == Keyword.ORDER.value
+
+    @staticmethod
+    def BY() -> Token:
+        return Token(TokenType.KEYWORD, Keyword.BY.value)
+
+    def is_by(self) -> bool:
+        return self._type == TokenType.KEYWORD and self._value == Keyword.BY.value
+
+    @staticmethod
+    def ASC() -> Token:
+        return Token(TokenType.KEYWORD, Keyword.ASC.value)
+
+    def is_asc(self) -> bool:
+        return self._type == TokenType.KEYWORD and self._value == Keyword.ASC.value
+
+    @staticmethod
+    def DESC() -> Token:
+        return Token(TokenType.KEYWORD, Keyword.DESC.value)
+
+    def is_desc(self) -> bool:
+        return self._type == TokenType.KEYWORD and self._value == Keyword.DESC.value
+
     # End of file token
 
     @staticmethod