flowquery 1.0.34 → 1.0.35

package/flowquery-py/pyproject.toml

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

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

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Optional, Union
+from typing import Any, AsyncIterator, Dict, List, Optional, Union
 
 from ..parsing.ast_node import ASTNode
 from .node import Node
@@ -48,35 +48,57 @@ class Database:
         physical = PhysicalRelationship()
         physical.type = relationship.type
         physical.statement = statement
+        if relationship.source is not None:
+            physical.source = relationship.source
+        if relationship.target is not None:
+            physical.target = relationship.target
         Database._relationships[relationship.type] = physical
 
     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
 
-    async def schema(self) -> list[dict[str, Any]]:
+    def get_relationships(self, relationship: 'Relationship') -> list['PhysicalRelationship']:
+        """Gets multiple physical relationships for ORed types."""
+        result = []
+        for rel_type in relationship.types:
+            physical = Database._relationships.get(rel_type)
+            if physical:
+                result.append(physical)
+        return result
+
+    async def schema(self) -> List[Dict[str, Any]]:
         """Returns the graph schema with node/relationship labels and sample data."""
-        result: list[dict[str, Any]] = []
+        return [item async for item in self._schema()]
 
+    async def _schema(self) -> AsyncIterator[Dict[str, Any]]:
+        """Async generator for graph schema with node/relationship labels and sample data."""
         for label, physical_node in Database._nodes.items():
             records = await physical_node.data()
-            entry: dict[str, Any] = {"kind": "node", "label": label}
+            entry: Dict[str, Any] = {"kind": "Node", "label": label}
             if records:
                 sample = {k: v for k, v in records[0].items() if k != "id"}
-                if sample:
+                properties = list(sample.keys())
+                if properties:
+                    entry["properties"] = properties
                     entry["sample"] = sample
-            result.append(entry)
+            yield entry
 
         for rel_type, physical_rel in Database._relationships.items():
             records = await physical_rel.data()
-            entry_rel: dict[str, Any] = {"kind": "relationship", "type": rel_type}
+            entry_rel: Dict[str, Any] = {
+                "kind": "Relationship",
+                "type": rel_type,
+                "from_label": physical_rel.source.label if physical_rel.source else None,
+                "to_label": physical_rel.target.label if physical_rel.target else None,
+            }
             if records:
                 sample = {k: v for k, v in records[0].items() if k not in ("left_id", "right_id")}
-                if sample:
+                properties = list(sample.keys())
+                if properties:
+                    entry_rel["properties"] = properties
                     entry_rel["sample"] = sample
-            result.append(entry_rel)
-
-        return result
+            yield entry_rel
 
     async def get_data(self, element: Union['Node', 'Relationship']) -> Union['NodeData', 'RelationshipData']:
         """Gets data for a node or relationship."""
@@ -87,6 +109,17 @@ class Database:
             data = await node.data()
             return NodeData(data)
         elif isinstance(element, Relationship):
+            if len(element.types) > 1:
+                physicals = self.get_relationships(element)
+                if not physicals:
+                    raise ValueError(f"No physical relationships found for types {', '.join(element.types)}")
+                all_records = []
+                for i, physical in enumerate(physicals):
+                    records = await physical.data()
+                    type_name = element.types[i]
+                    for record in records:
+                        all_records.append({**record, "_type": type_name})
+                return RelationshipData(all_records)
             relationship = self.get_relationship(element)
             if relationship is None:
                 raise ValueError(f"Physical relationship not found for type {element.type}")

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

@@ -19,7 +19,7 @@ class Relationship(ASTNode):
     def __init__(self) -> None:
         super().__init__()
         self._identifier: Optional[str] = None
-        self._type: Optional[str] = None
+        self._types: List[str] = []
         self._hops: Hops = Hops()
         self._source: Optional['Node'] = None
         self._target: Optional['Node'] = None
@@ -39,11 +39,19 @@ class Relationship(ASTNode):
 
     @property
     def type(self) -> Optional[str]:
-        return self._type
+        return self._types[0] if self._types else None
 
     @type.setter
     def type(self, value: str) -> None:
-        self._type = value
+        self._types = [value]
+
+    @property
+    def types(self) -> List[str]:
+        return self._types
+
+    @types.setter
+    def types(self, value: List[str]) -> None:
+        self._types = value
 
     @property
     def hops(self) -> Hops:

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

@@ -25,11 +25,12 @@ class RelationshipData(Data):
         return self._find(id, hop, key)
 
     def properties(self) -> Optional[Dict[str, Any]]:
-        """Get properties of current relationship, excluding left_id and right_id."""
+        """Get properties of current relationship, excluding left_id, right_id, and _type."""
         current = self.current()
         if current:
             props = dict(current)
             props.pop("left_id", None)
             props.pop("right_id", None)
+            props.pop("_type", None)
             return props
         return None

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

@@ -28,9 +28,15 @@ class RelationshipMatchCollector:
         """Push a new match onto the collector."""
         start_node_value = relationship.source.value() if relationship.source else None
         rel_data = relationship.get_data()
+        current_record = rel_data.current() if rel_data else None
+        default_type = relationship.type or ""
+        if current_record and isinstance(current_record, dict):
+            actual_type = current_record.get('_type', default_type)
+        else:
+            actual_type = default_type
         rel_props: Dict[str, Any] = (rel_data.properties() or {}) if rel_data else {}
         match: RelationshipMatchRecord = {
-            "type": relationship.type or "",
+            "type": actual_type,
             "startNode": start_node_value or {},
             "endNode": None,
             "properties": rel_props,

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

@@ -10,8 +10,8 @@ class RelationshipReference(Relationship):
     def __init__(self, relationship: Relationship, referred: ASTNode) -> None:
         super().__init__()
         self._referred = referred
-        if relationship.type:
-            self.type = relationship.type
+        if relationship.types:
+            self.types = relationship.types
 
     @property
     def referred(self) -> ASTNode:

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

@@ -39,6 +39,7 @@ from .sum import Sum
 from .to_json import ToJson
 from .to_lower import ToLower
 from .to_string import ToString
+from .trim import Trim
 from .type_ import Type
 from .value_holder import ValueHolder
 
@@ -78,6 +79,7 @@ __all__ = [
     "ToJson",
     "ToLower",
     "ToString",
+    "Trim",
     "Type",
     "Functions",
     "Schema",

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

@@ -1,6 +1,6 @@
 """PredicateSum function."""
 
-from typing import Any, Optional
+from typing import Any
 
 from .function_metadata import FunctionDef
 from .predicate_function import PredicateFunction
@@ -41,12 +41,9 @@ class PredicateSum(PredicateFunction):
         if array is None or not isinstance(array, list):
             raise ValueError("Invalid array for sum function")
 
-        _sum: Optional[Any] = None
+        _sum: int = 0
         for item in array:
             self._value_holder.holder = item
             if self.where is None or self.where.value():
-                if _sum is None:
-                    _sum = self._return.value()
-                else:
-                    _sum += self._return.value()
+                _sum += self._return.value()
         return _sum

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

@@ -9,23 +9,27 @@ from .function_metadata import FunctionDef
 @FunctionDef({
     "description": (
         "Returns the graph schema listing all nodes and relationships "
-        "with a sample of their data."
+        "with their properties and a sample of their data."
     ),
     "category": "async",
     "parameters": [],
     "output": {
-        "description": "Schema entry with kind, label/type, and optional sample data",
+        "description": "Schema entry with label/type, properties, and optional sample data",
         "type": "object",
     },
     "examples": [
-        "CALL schema() YIELD kind, label, type, sample RETURN kind, label, type, sample",
+        "CALL schema() YIELD label, type, from_label, to_label, properties, sample "
+        "RETURN label, type, from_label, to_label, properties, sample",
     ],
 })
 class Schema(AsyncFunction):
     """Returns the graph schema of the database.
 
-    Lists all nodes and relationships with their labels/types and a sample
-    of their data (excluding id from nodes, left_id and right_id from relationships).
+    Lists all nodes and relationships with their labels/types, properties,
+    and a sample of their data (excluding id from nodes, left_id and right_id from relationships).
+
+    Nodes: {label, properties, sample}
+    Relationships: {type, from_label, to_label, properties, sample}
     """
 
     async def generate(self) -> AsyncGenerator[Any, None]:

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

@@ -0,0 +1,35 @@
+"""Trim function."""
+
+from typing import Any
+
+from .function import Function
+from .function_metadata import FunctionDef
+
+
+@FunctionDef({
+    "description": "Removes leading and trailing whitespace from a string",
+    "category": "scalar",
+    "parameters": [
+        {"name": "text", "description": "String to trim", "type": "string"}
+    ],
+    "output": {"description": "Trimmed string", "type": "string", "example": "hello"},
+    "examples": [
+        "WITH '  hello  ' AS s RETURN trim(s)",
+        "WITH '\\tfoo\\n' AS s RETURN trim(s)"
+    ]
+})
+class Trim(Function):
+    """Trim function.
+
+    Removes leading and trailing whitespace from a string.
+    """
+
+    def __init__(self) -> None:
+        super().__init__("trim")
+        self._expected_parameter_count = 1
+
+    def value(self) -> Any:
+        val = self.get_children()[0].value()
+        if not isinstance(val, str):
+            raise ValueError("Invalid argument for trim function: expected a string")
+        return val.strip()

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

@@ -122,6 +122,8 @@ class GroupBy(Projection):
                 self.mappers[mapper_index].overridden = child.value
                 yield from self.generate_results(mapper_index + 1, child)
         else:
+            if node.elements is None:
+                node.elements = [reducer.element() for reducer in self.reducers]
             if node.elements:
                 for i, element in enumerate(node.elements):
                     self.reducers[i].overridden = element.value

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

@@ -398,6 +398,8 @@ class Parser(BaseParser):
                 raise ValueError("Expected target node definition")
             relationship = Relationship()
             relationship.type = rel_type
+            relationship.source = node
+            relationship.target = target
 
         self._expect_and_skip_whitespace_and_comments()
         if not self.token.is_as():
@@ -576,8 +578,16 @@ class Parser(BaseParser):
         self.set_next_token()
         if not self.token.is_identifier_or_keyword():
             raise ValueError("Expected relationship type identifier")
-        rel_type: str = self.token.value or ""
+        rel_types: List[str] = [self.token.value or ""]
         self.set_next_token()
+        while self.token.is_pipe():
+            self.set_next_token()
+            if self.token.is_colon():
+                self.set_next_token()
+            if not self.token.is_identifier_or_keyword():
+                raise ValueError("Expected relationship type identifier after '|'")
+            rel_types.append(self.token.value or "")
+            self.set_next_token()
         hops = self._parse_relationship_hops()
         properties: Dict[str, Expression] = dict(self._parse_properties())
         if not self.token.is_closing_bracket():
@@ -607,7 +617,7 @@ class Parser(BaseParser):
             self._state.variables[variable] = relationship
         if hops is not None:
             relationship.hops = hops
-        relationship.type = rel_type
+        relationship.types = rel_types
         return relationship
 
     def _parse_properties(self) -> Iterator[Tuple[str, Expression]]:

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

@@ -681,6 +681,42 @@ class TestRunner:
         assert len(results) == 1
         assert results[0] == {"result": "foo bar"}
 
+    @pytest.mark.asyncio
+    async def test_trim_function(self):
+        """Test trim function."""
+        runner = Runner('RETURN trim("  hello  ") as result')
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": "hello"}
+
+    @pytest.mark.asyncio
+    async def test_trim_function_with_tabs_and_newlines(self):
+        """Test trim function with tabs and newlines."""
+        runner = Runner('WITH "\tfoo\n" AS s RETURN trim(s) as result')
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": "foo"}
+
+    @pytest.mark.asyncio
+    async def test_trim_function_with_no_whitespace(self):
+        """Test trim function with no whitespace."""
+        runner = Runner('RETURN trim("hello") as result')
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": "hello"}
+
+    @pytest.mark.asyncio
+    async def test_trim_function_with_empty_string(self):
+        """Test trim function with empty string."""
+        runner = Runner('RETURN trim("") 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."""
@@ -2152,20 +2188,24 @@ class TestRunner:
         ).run()
 
         runner = Runner(
-            "CALL schema() YIELD kind, label, type, sample RETURN kind, label, type, sample"
+            "CALL schema() YIELD kind, label, type, from_label, to_label, properties, sample RETURN kind, label, type, from_label, to_label, properties, sample"
         )
         await runner.run()
         results = runner.results
 
-        animal = next((r for r in results if r.get("kind") == "node" and r.get("label") == "Animal"), None)
+        animal = next((r for r in results if r.get("kind") == "Node" and r.get("label") == "Animal"), None)
         assert animal is not None
+        assert animal["properties"] == ["species", "legs"]
         assert animal["sample"] is not None
         assert "id" not in animal["sample"]
         assert "species" in animal["sample"]
         assert "legs" in animal["sample"]
 
-        chases = next((r for r in results if r.get("kind") == "relationship" and r.get("type") == "CHASES"), None)
+        chases = next((r for r in results if r.get("kind") == "Relationship" and r.get("type") == "CHASES"), None)
         assert chases is not None
+        assert chases["from_label"] == "Animal"
+        assert chases["to_label"] == "Animal"
+        assert chases["properties"] == ["speed"]
         assert chases["sample"] is not None
         assert "left_id" not in chases["sample"]
         assert "right_id" not in chases["sample"]
@@ -2549,6 +2589,64 @@ class TestRunner:
     # Add operator tests
     # ============================================================
 
+    @pytest.mark.asyncio
+    async def test_collected_patterns_and_unwind(self):
+        """Test collecting graph patterns and unwinding them."""
+        await Runner("""
+            CREATE VIRTUAL (:Person) AS {
+                unwind [
+                    {id: 1, name: 'Person 1'},
+                    {id: 2, name: 'Person 2'},
+                    {id: 3, name: 'Person 3'},
+                    {id: 4, name: 'Person 4'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+        """).run()
+        await Runner("""
+            CREATE VIRTUAL (:Person)-[:KNOWS]-(:Person) AS {
+                unwind [
+                    {left_id: 1, right_id: 2},
+                    {left_id: 2, right_id: 3},
+                    {left_id: 3, right_id: 4}
+                ] as record
+                RETURN record.left_id as left_id, record.right_id as right_id
+            }
+        """).run()
+        runner = Runner("""
+            MATCH p=(a:Person)-[:KNOWS*0..3]->(b:Person)
+            WITH collect(p) AS patterns
+            UNWIND patterns AS pattern
+            RETURN pattern
+        """)
+        await runner.run()
+        results = runner.results
+        assert len(results) == 10
+        # Index 0: Person 1 zero-hop - pattern = [node1] (single node)
+        assert len(results[0]["pattern"]) == 1
+        assert results[0]["pattern"][0]["id"] == 1
+        # Index 1: Person 1 -> Person 2 (1-hop)
+        assert len(results[1]["pattern"]) == 3
+        # Index 2: Person 1 -> Person 2 -> Person 3 (2-hop)
+        assert len(results[2]["pattern"]) == 5
+        # Index 3: Person 1 -> Person 2 -> Person 3 -> Person 4 (3-hop)
+        assert len(results[3]["pattern"]) == 7
+        # Index 4: Person 2 zero-hop
+        assert len(results[4]["pattern"]) == 1
+        assert results[4]["pattern"][0]["id"] == 2
+        # Index 5: Person 2 -> Person 3 (1-hop)
+        assert len(results[5]["pattern"]) == 3
+        # Index 6: Person 2 -> Person 3 -> Person 4 (2-hop)
+        assert len(results[6]["pattern"]) == 5
+        # Index 7: Person 3 zero-hop
+        assert len(results[7]["pattern"]) == 1
+        assert results[7]["pattern"][0]["id"] == 3
+        # Index 8: Person 3 -> Person 4 (1-hop)
+        assert len(results[8]["pattern"]) == 3
+        # Index 9: Person 4 zero-hop
+        assert len(results[9]["pattern"]) == 1
+        assert results[9]["pattern"][0]["id"] == 4
+
     @pytest.mark.asyncio
     async def test_add_two_integers(self):
         """Test add two integers."""
@@ -2854,4 +2952,151 @@ class TestRunner:
         await runner.run()
         results = runner.results
         assert len(results) == 1
-        assert results == [{"x": 1}]
+        assert results == [{"x": 1}]
+
+    @pytest.mark.asyncio
+    async def test_language_name_hits_query_with_virtual_graph(self):
+        """Test full language-name-hits query with virtual graph.
+
+        Reproduces the original bug: collect(distinct ...) on MATCH results,
+        then sum(lang IN langs | ...) in a WITH clause, was throwing
+        "Invalid array for sum function" because collect() returned null
+        instead of [] when no rows entered aggregation.
+        """
+        # Create Language nodes
+        await Runner(
+            """
+            CREATE VIRTUAL (:Language) AS {
+                UNWIND [
+                    {id: 1, name: 'Python'},
+                    {id: 2, name: 'JavaScript'},
+                    {id: 3, name: 'TypeScript'}
+                ] AS record
+                RETURN record.id AS id, record.name AS name
+            }
+            """
+        ).run()
+
+        # Create Chat nodes with messages
+        await Runner(
+            """
+            CREATE VIRTUAL (:Chat) AS {
+                UNWIND [
+                    {id: 1, name: 'Dev Discussion', messages: [
+                        {From: 'Alice', SentDateTime: '2025-01-01T10:00:00', Content: 'I love Python and JavaScript'},
+                        {From: 'Bob', SentDateTime: '2025-01-01T10:05:00', Content: 'What languages do you prefer?'}
+                    ]},
+                    {id: 2, name: 'General', messages: [
+                        {From: 'Charlie', SentDateTime: '2025-01-02T09:00:00', Content: 'The weather is nice today'},
+                        {From: 'Alice', SentDateTime: '2025-01-02T09:05:00', Content: 'TypeScript is great for language tooling'}
+                    ]}
+                ] AS record
+                RETURN record.id AS id, record.name AS name, record.messages AS messages
+            }
+            """
+        ).run()
+
+        # Create User nodes
+        await Runner(
+            """
+            CREATE VIRTUAL (:User) AS {
+                UNWIND [
+                    {id: 1, displayName: 'Alice'},
+                    {id: 2, displayName: 'Bob'},
+                    {id: 3, displayName: 'Charlie'}
+                ] AS record
+                RETURN record.id AS id, record.displayName AS displayName
+            }
+            """
+        ).run()
+
+        # Create PARTICIPATES_IN relationships
+        await Runner(
+            """
+            CREATE VIRTUAL (:User)-[:PARTICIPATES_IN]-(:Chat) AS {
+                UNWIND [
+                    {left_id: 1, right_id: 1},
+                    {left_id: 2, right_id: 1},
+                    {left_id: 3, right_id: 2},
+                    {left_id: 1, right_id: 2}
+                ] AS record
+                RETURN record.left_id AS left_id, record.right_id AS right_id
+            }
+            """
+        ).run()
+
+        # Run the original query (using 'sender' alias since 'from' is a reserved keyword)
+        runner = Runner(
+            """
+            MATCH (l:Language)
+            WITH collect(distinct l.name) AS langs
+            MATCH (c:Chat)
+            UNWIND c.messages AS msg
+            WITH c, msg, langs,
+                 sum(lang IN langs | 1 where toLower(msg.Content) CONTAINS toLower(lang)) AS langNameHits
+            WHERE toLower(msg.Content) CONTAINS "language"
+               OR toLower(msg.Content) CONTAINS "languages"
+               OR langNameHits > 0
+            OPTIONAL MATCH (u:User)-[:PARTICIPATES_IN]->(c)
+            RETURN
+              c.name AS chat,
+              collect(distinct u.displayName) AS participants,
+              msg.From AS sender,
+              msg.SentDateTime AS sentDateTime,
+              msg.Content AS message
+            """
+        )
+        await runner.run()
+        results = runner.results
+
+        # Messages that mention a language name or the word "language(s)":
+        # 1. "I love Python and JavaScript" - langNameHits=2
+        # 2. "What languages do you prefer?" - contains "languages"
+        # 3. "TypeScript is great for language tooling" - langNameHits=1, also "language"
+        assert len(results) == 3
+        assert results[0]["chat"] == "Dev Discussion"
+        assert results[0]["message"] == "I love Python and JavaScript"
+        assert results[0]["sender"] == "Alice"
+        assert results[1]["chat"] == "Dev Discussion"
+        assert results[1]["message"] == "What languages do you prefer?"
+        assert results[1]["sender"] == "Bob"
+        assert results[2]["chat"] == "General"
+        assert results[2]["message"] == "TypeScript is great for language tooling"
+        assert results[2]["sender"] == "Alice"
+
+    @pytest.mark.asyncio
+    async def test_sum_with_empty_collected_array(self):
+        """Reproduces the original bug: collect on empty input should yield []
+        and sum over that empty array should return 0, not throw."""
+        runner = Runner(
+            """
+            UNWIND [] AS lang
+            WITH collect(distinct lang) AS langs
+            UNWIND ['hello', 'world'] AS msg
+            WITH msg, langs, sum(l IN langs | 1 where toLower(msg) CONTAINS toLower(l)) AS hits
+            RETURN msg, hits
+            """
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 2
+        assert results[0] == {"msg": "hello", "hits": 0}
+        assert results[1] == {"msg": "world", "hits": 0}
+
+    @pytest.mark.asyncio
+    async def test_sum_where_all_elements_filtered_returns_0(self):
+        """Test sum returns 0 when where clause filters everything."""
+        runner = Runner("RETURN sum(n in [1, 2, 3] | n where n > 100) as sum")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"sum": 0}
+
+    @pytest.mark.asyncio
+    async def test_sum_over_empty_array_returns_0(self):
+        """Test sum over empty array returns 0."""
+        runner = Runner("WITH [] AS arr RETURN sum(n in arr | n) as sum")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"sum": 0}