flowquery 1.0.16 → 1.0.17

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

@@ -0,0 +1,34 @@
+"""Represents a CREATE operation for creating virtual relationships."""
+
+from typing import Any, Dict, List
+
+from .operation import Operation
+from ..ast_node import ASTNode
+
+
+class CreateRelationship(Operation):
+    """Represents a CREATE operation for creating virtual relationships."""
+
+    def __init__(self, relationship, statement: ASTNode):
+        super().__init__()
+        self._relationship = relationship
+        self._statement = statement
+
+    @property
+    def relationship(self):
+        return self._relationship
+
+    @property
+    def statement(self) -> ASTNode:
+        return self._statement
+
+    async def run(self) -> None:
+        if self._relationship is None:
+            raise ValueError("Relationship is null")
+        from ...graph.database import Database
+        db = Database.get_instance()
+        db.add_relationship(self._relationship, self._statement)
+
+    @property
+    def results(self) -> List[Dict[str, Any]]:
+        return []

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

@@ -0,0 +1,130 @@
+"""GroupBy implementation for aggregate operations."""
+
+from typing import Any, Dict, Generator, List, Optional
+
+from ..expressions.expression import Expression
+from ..functions.aggregate_function import AggregateFunction
+from ..functions.reducer_element import ReducerElement
+from .projection import Projection
+
+
+class GroupByNode:
+    """Represents a node in the group-by tree."""
+
+    def __init__(self, value: Any = None):
+        self._value = value
+        self._children: Dict[Any, 'GroupByNode'] = {}
+        self._elements: Optional[List[ReducerElement]] = None
+
+    @property
+    def value(self) -> Any:
+        return self._value
+
+    @property
+    def children(self) -> Dict[Any, 'GroupByNode']:
+        return self._children
+
+    @property
+    def elements(self) -> Optional[List[ReducerElement]]:
+        return self._elements
+
+    @elements.setter
+    def elements(self, elements: List[ReducerElement]) -> None:
+        self._elements = elements
+
+
+class GroupBy(Projection):
+    """Implements grouping and aggregation for FlowQuery operations."""
+
+    def __init__(self, expressions: List[Expression]):
+        super().__init__(expressions)
+        self._root = GroupByNode()
+        self._current = self._root
+        self._mappers: Optional[List[Expression]] = None
+        self._reducers: Optional[List[AggregateFunction]] = None
+        self._where = None
+
+    async def run(self) -> None:
+        self._reset_tree()
+        self._map()
+        self._reduce()
+
+    @property
+    def _root_node(self) -> GroupByNode:
+        return self._root
+
+    def _reset_tree(self) -> None:
+        self._current = self._root
+
+    def _map(self) -> None:
+        node = self._current
+        for mapper in self.mappers:
+            value = mapper.value()
+            child = node.children.get(value)
+            if child is None:
+                child = GroupByNode(value)
+                node.children[value] = child
+            node = child
+        self._current = node
+
+    def _reduce(self) -> None:
+        if self._current.elements is None:
+            self._current.elements = [reducer.element() for reducer in self.reducers]
+        elements = self._current.elements
+        for i, reducer in enumerate(self.reducers):
+            reducer.reduce(elements[i])
+
+    @property
+    def mappers(self) -> List[Expression]:
+        if self._mappers is None:
+            self._mappers = list(self._generate_mappers())
+        return self._mappers
+
+    def _generate_mappers(self) -> Generator[Expression, None, None]:
+        for expression, _ in self.expressions():
+            if expression.mappable():
+                yield expression
+
+    @property
+    def reducers(self) -> List[AggregateFunction]:
+        if self._reducers is None:
+            self._reducers = []
+            for child in self.children:
+                self._reducers.extend(child.reducers())
+        return self._reducers
+
+    def generate_results(
+        self, 
+        mapper_index: int = 0, 
+        node: Optional[GroupByNode] = None
+    ) -> Generator[Dict[str, Any], None, None]:
+        if node is None:
+            node = self._root
+        
+        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)
+        else:
+            if node.elements:
+                for i, element in enumerate(node.elements):
+                    self.reducers[i].overridden = element.value
+            record: Dict[str, Any] = {}
+            for expression, alias in self.expressions():
+                record[alias] = expression.value()
+            if self.where_condition:
+                yield record
+
+    @property
+    def where(self):
+        return self._where
+
+    @where.setter
+    def where(self, where) -> None:
+        self._where = where
+
+    @property
+    def where_condition(self) -> bool:
+        if self._where is None:
+            return True
+        return self._where.value()

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

@@ -0,0 +1,22 @@
+"""Represents a LIMIT operation that limits the number of results."""
+
+from .operation import Operation
+
+
+class Limit(Operation):
+    """Represents a LIMIT operation that limits the number of results."""
+
+    def __init__(self, limit: int):
+        super().__init__()
+        self._count = 0
+        self._limit = limit
+
+    async def run(self) -> None:
+        if self._count >= self._limit:
+            return
+        self._count += 1
+        if self.next:
+            await self.next.run()
+
+    def reset(self) -> None:
+        self._count = 0

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

@@ -0,0 +1,140 @@
+"""Represents a LOAD operation that fetches data from external sources."""
+
+import json
+from typing import Any, Dict, Optional
+
+from .operation import Operation
+from ..functions.async_function import AsyncFunction
+
+
+class Load(Operation):
+    """Represents a LOAD operation that fetches data from external sources."""
+
+    def __init__(self):
+        super().__init__()
+        self._value: Any = None
+
+    @property
+    def type(self):
+        """Gets the data type (JSON, CSV, or Text)."""
+        return self.children[0]
+
+    @property
+    def from_component(self):
+        """Gets the From component which contains either a URL expression or an AsyncFunction."""
+        return self.children[1]
+
+    @property
+    def is_async_function(self) -> bool:
+        """Checks if the data source is an async function."""
+        return isinstance(self.from_component.first_child(), AsyncFunction)
+
+    @property
+    def async_function(self) -> Optional[AsyncFunction]:
+        """Gets the async function if the source is a function, otherwise None."""
+        child = self.from_component.first_child()
+        return child if isinstance(child, AsyncFunction) else None
+
+    @property
+    def from_(self) -> str:
+        return self.children[1].value()
+
+    @property
+    def headers(self) -> Dict[str, str]:
+        from ..components.headers import Headers
+        if self.child_count() > 2 and isinstance(self.children[2], Headers):
+            return self.children[2].value() or {}
+        return {}
+
+    @property
+    def payload(self):
+        from ..components.post import Post
+        post = None
+        if self.child_count() > 2 and isinstance(self.children[2], Post):
+            post = self.children[2]
+        elif self.child_count() > 3 and isinstance(self.children[3], Post):
+            post = self.children[3]
+        return post.first_child() if post else None
+
+    def _method(self) -> str:
+        return "GET" if self.payload is None else "POST"
+
+    def _options(self) -> Dict[str, Any]:
+        headers = dict(self.headers)
+        payload = self.payload
+        data = payload.value() if payload else None
+        if data is not None and isinstance(data, dict) and "Content-Type" not in headers:
+            headers["Content-Type"] = "application/json"
+        options: Dict[str, Any] = {
+            "method": self._method(),
+            "headers": headers,
+        }
+        if payload is not None:
+            options["body"] = json.dumps(payload.value())
+        return options
+
+    async def _load_from_function(self) -> None:
+        """Loads data from an async function source."""
+        async_func = self.async_function
+        if async_func is None:
+            return
+        args = async_func.get_arguments()
+        async for item in async_func.generate(*args):
+            self._value = item
+            if self.next:
+                await self.next.run()
+
+    async def _load_from_url(self) -> None:
+        """Loads data from a URL source."""
+        import aiohttp
+        from ..components.json import JSON as JSONComponent
+        from ..components.text import Text
+        
+        async with aiohttp.ClientSession() as session:
+            options = self._options()
+            method = options.pop("method")
+            headers = options.pop("headers", {})
+            body = options.pop("body", None)
+            
+            async with session.request(
+                method, 
+                self.from_, 
+                headers=headers, 
+                data=body
+            ) as response:
+                if isinstance(self.type, JSONComponent):
+                    data = await response.json()
+                elif isinstance(self.type, Text):
+                    data = await response.text()
+                else:
+                    data = await response.text()
+                
+                if isinstance(data, list):
+                    for item in data:
+                        self._value = item
+                        if self.next:
+                            await self.next.run()
+                elif isinstance(data, dict):
+                    self._value = data
+                    if self.next:
+                        await self.next.run()
+                elif isinstance(data, str):
+                    self._value = data
+                    if self.next:
+                        await self.next.run()
+
+    async def load(self) -> None:
+        if self.is_async_function:
+            await self._load_from_function()
+        else:
+            await self._load_from_url()
+
+    async def run(self) -> None:
+        try:
+            await self.load()
+        except Exception as e:
+            source = self.async_function.name if self.is_async_function else self.from_
+            raise RuntimeError(f"Failed to load data from {source}. Error: {e}")
+
+    def value(self) -> Any:
+        return self._value

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

@@ -0,0 +1,29 @@
+"""Represents a MATCH operation for graph pattern matching."""
+
+from typing import List
+
+from .operation import Operation
+
+
+class Match(Operation):
+    """Represents a MATCH operation for graph pattern matching."""
+
+    def __init__(self, patterns=None):
+        super().__init__()
+        from ...graph.patterns import Patterns
+        self._patterns = Patterns(patterns or [])
+
+    @property
+    def patterns(self):
+        return self._patterns.patterns if self._patterns else []
+
+    async def run(self) -> None:
+        """Executes the match operation by chaining the patterns together."""
+        await self._patterns.initialize()
+        
+        async def to_do_next():
+            if self.next:
+                await self.next.run()
+        
+        self._patterns.to_do_next = to_do_next
+        await self._patterns.traverse()

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

@@ -0,0 +1,69 @@
+"""Base class for all FlowQuery operations."""
+
+from abc import ABC
+from typing import Any, Dict, List, Optional
+
+from ..ast_node import ASTNode
+
+
+class Operation(ASTNode, ABC):
+    """Base class for all FlowQuery operations.
+    
+    Operations represent the main statements in FlowQuery (WITH, UNWIND, RETURN, LOAD, WHERE).
+    They form a linked list structure and can be executed sequentially.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._previous: Optional[Operation] = None
+        self._next: Optional[Operation] = None
+
+    @property
+    def previous(self) -> Optional['Operation']:
+        return self._previous
+
+    @previous.setter
+    def previous(self, value: Optional['Operation']) -> None:
+        self._previous = value
+
+    @property
+    def next(self) -> Optional['Operation']:
+        return self._next
+
+    @next.setter
+    def next(self, value: Optional['Operation']) -> None:
+        self._next = value
+
+    def add_sibling(self, operation: 'Operation') -> None:
+        if self._parent:
+            self._parent.add_child(operation)
+        operation.previous = self
+        self.next = operation
+
+    @property
+    def is_last(self) -> bool:
+        return self._next is None
+
+    async def run(self) -> None:
+        """Executes this operation. Must be implemented by subclasses.
+        
+        Raises:
+            NotImplementedError: If not implemented by subclass
+        """
+        raise NotImplementedError("Not implemented")
+
+    async def finish(self) -> None:
+        """Finishes execution by calling finish on the next operation in the chain."""
+        if self.next:
+            await self.next.finish()
+
+    async def initialize(self) -> None:
+        if self.next:
+            await self.next.initialize()
+
+    def reset(self) -> None:
+        pass
+
+    @property
+    def results(self) -> List[Dict[str, Any]]:
+        raise NotImplementedError("Not implemented")

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

@@ -0,0 +1,21 @@
+"""Base class for projection operations."""
+
+from typing import Generator, List, Tuple, Optional
+
+from ..expressions.expression import Expression
+from .operation import Operation
+
+
+class Projection(Operation):
+    """Base class for operations that project expressions."""
+
+    def __init__(self, expressions: List[Expression]):
+        super().__init__()
+        self.children = expressions
+
+    def expressions(self) -> Generator[Tuple[Expression, str], None, None]:
+        """Yields tuples of (expression, alias) for all child expressions."""
+        for i, child in enumerate(self.children):
+            expression: Expression = child
+            alias = expression.alias or f"expr{i}"
+            yield (expression, alias)

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

@@ -0,0 +1,50 @@
+"""Represents a RETURN operation that produces the final query results."""
+
+import copy
+from typing import Any, Dict, List, Optional
+
+from .projection import Projection
+
+
+class Return(Projection):
+    """Represents a RETURN operation that produces the final query results.
+    
+    The RETURN operation evaluates expressions and collects them into result records.
+    It can optionally have a WHERE clause to filter results.
+    
+    Example:
+        # RETURN x, y WHERE x > 0
+    """
+
+    def __init__(self, expressions):
+        super().__init__(expressions)
+        self._where: Optional['Where'] = None
+        self._results: List[Dict[str, Any]] = []
+
+    @property
+    def where(self) -> bool:
+        if self._where is None:
+            return True
+        return self._where.value()
+
+    @where.setter
+    def where(self, where: 'Where') -> None:
+        self._where = where
+
+    async def run(self) -> None:
+        if not self.where:
+            return
+        record: Dict[str, Any] = {}
+        for expression, alias in self.expressions():
+            raw = expression.value()
+            # Deep copy objects to preserve their state
+            value = copy.deepcopy(raw) if isinstance(raw, (dict, list)) else raw
+            record[alias] = value
+        self._results.append(record)
+
+    async def initialize(self) -> None:
+        self._results = []
+
+    @property
+    def results(self) -> List[Dict[str, Any]]:
+        return self._results

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

@@ -0,0 +1,37 @@
+"""Represents an UNWIND operation that iterates over arrays."""
+
+from typing import Any
+
+from ..expressions.expression import Expression
+from .operation import Operation
+
+
+class Unwind(Operation):
+    """Represents an UNWIND operation that iterates over an array expression."""
+
+    def __init__(self, expression: Expression):
+        super().__init__()
+        self._value: Any = None
+        self.add_child(expression)
+
+    @property
+    def expression(self) -> Expression:
+        return self.children[0]
+
+    @property
+    def as_(self) -> str:
+        return self.children[1].value()
+
+    async def run(self) -> None:
+        expression_value = self.expression.value()
+        if not isinstance(expression_value, list):
+            raise ValueError("Expected array")
+        for item in expression_value:
+            self._value = item
+            if self.next:
+                await self.next.run()
+        if self.next:
+            self.next.reset()
+
+    def value(self) -> Any:
+        return self._value

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

@@ -0,0 +1,41 @@
+"""Represents a WHERE operation that filters data based on a condition."""
+
+from typing import Any
+
+from ..expressions.expression import Expression
+from .operation import Operation
+
+
+class Where(Operation):
+    """Represents a WHERE operation that filters data based on a condition.
+    
+    The WHERE operation evaluates a boolean expression and only continues
+    execution to the next operation if the condition is true.
+    
+    Example:
+        # RETURN x WHERE x > 0
+    """
+
+    def __init__(self, expression: Expression):
+        """Creates a new WHERE operation with the given condition.
+        
+        Args:
+            expression: The boolean expression to evaluate
+        """
+        super().__init__()
+        self.add_child(expression)
+
+    @property
+    def expression(self) -> Expression:
+        return self.children[0]
+
+    async def run(self) -> None:
+        for pattern in self.expression.patterns():
+            await pattern.fetch_data()
+            await pattern.evaluate()
+        if self.expression.value():
+            if self.next:
+                await self.next.run()
+
+    def value(self) -> Any:
+        return self.expression.value()

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

@@ -0,0 +1,18 @@
+"""Represents a WITH operation that defines variables or intermediate results."""
+
+from .projection import Projection
+
+
+class With(Projection):
+    """Represents a WITH operation that defines variables or intermediate results.
+    
+    The WITH operation creates named expressions that can be referenced later in the query.
+    It passes control to the next operation in the chain.
+    
+    Example:
+        # WITH x = 1, y = 2 RETURN x + y
+    """
+
+    async def run(self) -> None:
+        if self.next:
+            await self.next.run()