flowquery 1.0.38 → 1.0.40

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."""
@@ -2798,6 +2837,58 @@ class TestRunner:
         assert len(results) == 3
         assert [r["n"] for r in results] == [10, 15, 20]
 
+    @pytest.mark.asyncio
+    async def test_where_with_and_before_in(self):
+        """Test WHERE with AND before IN (IN on right side of AND)."""
+        runner = Runner("""
+            unwind ['expert', 'intermediate', 'beginner'] as proficiency
+            with proficiency where 1=1 and proficiency in ['expert']
+            return proficiency
+        """)
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"proficiency": "expert"}
+
+    @pytest.mark.asyncio
+    async def test_where_with_and_before_not_in(self):
+        """Test WHERE with AND before NOT IN."""
+        runner = Runner("""
+            unwind ['expert', 'intermediate', 'beginner'] as proficiency
+            with proficiency where 1=1 and proficiency not in ['expert']
+            return proficiency
+        """)
+        await runner.run()
+        results = runner.results
+        assert len(results) == 2
+        assert [r["proficiency"] for r in results] == ["intermediate", "beginner"]
+
+    @pytest.mark.asyncio
+    async def test_where_with_or_before_in(self):
+        """Test WHERE with OR before IN."""
+        runner = Runner("""
+            unwind range(1, 10) as n
+            with n where 1=0 or n in [3, 7]
+            return n
+        """)
+        await runner.run()
+        results = runner.results
+        assert len(results) == 2
+        assert [r["n"] for r in results] == [3, 7]
+
+    @pytest.mark.asyncio
+    async def test_in_as_return_expression_with_and_in_where(self):
+        """Test IN as return expression with AND in WHERE."""
+        runner = Runner("""
+            unwind ['expert', 'intermediate', 'beginner'] as proficiency
+            with proficiency where 1=1 and proficiency in ['expert']
+            return proficiency, proficiency in ['expert'] as isExpert
+        """)
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"proficiency": "expert", "isExpert": 1}
+
     @pytest.mark.asyncio
     async def test_where_with_contains(self):
         """Test WHERE with CONTAINS."""
@@ -4011,4 +4102,241 @@ class TestRunner:
         assert d["hours"] == 2
         assert d["minutes"] == 30
         assert d["totalSeconds"] == 9000
-        assert d["formatted"] == "PT2H30M"
+        assert d["formatted"] == "PT2H30M"
+
+    # ORDER BY tests
+
+    @pytest.mark.asyncio
+    async def test_order_by_ascending(self):
+        """Test ORDER BY ascending (default)."""
+        runner = Runner("unwind [3, 1, 2] as x return x order by x")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 3
+        assert results[0] == {"x": 1}
+        assert results[1] == {"x": 2}
+        assert results[2] == {"x": 3}
+
+    @pytest.mark.asyncio
+    async def test_order_by_descending(self):
+        """Test ORDER BY descending."""
+        runner = Runner("unwind [3, 1, 2] as x return x order by x desc")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 3
+        assert results[0] == {"x": 3}
+        assert results[1] == {"x": 2}
+        assert results[2] == {"x": 1}
+
+    @pytest.mark.asyncio
+    async def test_order_by_ascending_explicit(self):
+        """Test ORDER BY with explicit ASC."""
+        runner = Runner("unwind [3, 1, 2] as x return x order by x asc")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 3
+        assert results[0] == {"x": 1}
+        assert results[1] == {"x": 2}
+        assert results[2] == {"x": 3}
+
+    @pytest.mark.asyncio
+    async def test_order_by_with_multiple_fields(self):
+        """Test ORDER BY with multiple sort fields."""
+        runner = Runner(
+            "unwind [{name: 'Alice', age: 30}, {name: 'Bob', age: 25}, {name: 'Alice', age: 25}] as person "
+            "return person.name as name, person.age as age "
+            "order by name asc, age asc"
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 3
+        assert results[0] == {"name": "Alice", "age": 25}
+        assert results[1] == {"name": "Alice", "age": 30}
+        assert results[2] == {"name": "Bob", "age": 25}
+
+    @pytest.mark.asyncio
+    async def test_order_by_with_strings(self):
+        """Test ORDER BY with string values."""
+        runner = Runner(
+            "unwind ['banana', 'apple', 'cherry'] as fruit return fruit order by fruit"
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 3
+        assert results[0] == {"fruit": "apple"}
+        assert results[1] == {"fruit": "banana"}
+        assert results[2] == {"fruit": "cherry"}
+
+    @pytest.mark.asyncio
+    async def test_order_by_with_aggregated_return(self):
+        """Test ORDER BY with aggregated RETURN."""
+        runner = Runner(
+            "unwind [1, 1, 2, 2, 3, 3] as x "
+            "return x, count(x) as cnt "
+            "order by x desc"
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 3
+        assert results[0] == {"x": 3, "cnt": 2}
+        assert results[1] == {"x": 2, "cnt": 2}
+        assert results[2] == {"x": 1, "cnt": 2}
+
+    @pytest.mark.asyncio
+    async def test_order_by_with_limit(self):
+        """Test ORDER BY combined with LIMIT."""
+        runner = Runner(
+            "unwind [3, 1, 4, 1, 5, 9, 2, 6] as x return x order by x limit 3"
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 3
+        assert results[0] == {"x": 1}
+        assert results[1] == {"x": 1}
+        assert results[2] == {"x": 2}
+
+    @pytest.mark.asyncio
+    async def test_order_by_with_where(self):
+        """Test ORDER BY combined with WHERE."""
+        runner = Runner(
+            "unwind [3, 1, 4, 1, 5, 9, 2, 6] as x return x where x > 2 order by x desc"
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 5
+        assert results[0] == {"x": 9}
+        assert results[1] == {"x": 6}
+        assert results[2] == {"x": 5}
+        assert results[3] == {"x": 4}
+        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"