flowquery 1.0.34 → 1.0.36

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

@@ -249,6 +249,99 @@ class TestRunner:
         assert len(results) == 1
         assert results[0] == {"avg": 1}
 
+    @pytest.mark.asyncio
+    async def test_min(self):
+        """Test min aggregate function."""
+        runner = Runner("unwind [3, 1, 4, 1, 5, 9] as n return min(n) as minimum")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"minimum": 1}
+
+    @pytest.mark.asyncio
+    async def test_max(self):
+        """Test max aggregate function."""
+        runner = Runner("unwind [3, 1, 4, 1, 5, 9] as n return max(n) as maximum")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"maximum": 9}
+
+    @pytest.mark.asyncio
+    async def test_min_with_grouped_values(self):
+        """Test min with grouped values."""
+        runner = Runner(
+            "unwind [1, 1, 2, 2] as i unwind [10, 20, 30, 40] as j return i, min(j) as minimum"
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 2
+        assert results[0] == {"i": 1, "minimum": 10}
+        assert results[1] == {"i": 2, "minimum": 10}
+
+    @pytest.mark.asyncio
+    async def test_max_with_grouped_values(self):
+        """Test max with grouped values."""
+        runner = Runner(
+            "unwind [1, 1, 2, 2] as i unwind [10, 20, 30, 40] as j return i, max(j) as maximum"
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 2
+        assert results[0] == {"i": 1, "maximum": 40}
+        assert results[1] == {"i": 2, "maximum": 40}
+
+    @pytest.mark.asyncio
+    async def test_min_with_null(self):
+        """Test min with null."""
+        runner = Runner("return min(null) as minimum")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"minimum": None}
+
+    @pytest.mark.asyncio
+    async def test_max_with_null(self):
+        """Test max with null."""
+        runner = Runner("return max(null) as maximum")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"maximum": None}
+
+    @pytest.mark.asyncio
+    async def test_min_with_strings(self):
+        """Test min with string values."""
+        runner = Runner(
+            'unwind ["cherry", "apple", "banana"] as s return min(s) as minimum'
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"minimum": "apple"}
+
+    @pytest.mark.asyncio
+    async def test_max_with_strings(self):
+        """Test max with string values."""
+        runner = Runner(
+            'unwind ["cherry", "apple", "banana"] as s return max(s) as maximum'
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"maximum": "cherry"}
+
+    @pytest.mark.asyncio
+    async def test_min_and_max_together(self):
+        """Test min and max together."""
+        runner = Runner(
+            "unwind [3, 1, 4, 1, 5, 9] as n return min(n) as minimum, max(n) as maximum"
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"minimum": 1, "maximum": 9}
+
     @pytest.mark.asyncio
     async def test_with_and_return(self):
         """Test with and return."""
@@ -681,6 +774,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."""
@@ -865,6 +994,144 @@ class TestRunner:
         assert len(results) == 1
         assert results[0] == {"keys": ["name", "age"]}
 
+    @pytest.mark.asyncio
+    async def test_properties_function_with_map(self):
+        """Test properties function with a plain map."""
+        runner = Runner('RETURN properties({name: "Alice", age: 30}) as props')
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"props": {"name": "Alice", "age": 30}}
+
+    @pytest.mark.asyncio
+    async def test_properties_function_with_node(self):
+        """Test properties function with a graph node."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:Animal) AS {
+                UNWIND [
+                    {id: 1, name: 'Dog', legs: 4},
+                    {id: 2, name: 'Cat', legs: 4}
+                ] AS record
+                RETURN record.id AS id, record.name AS name, record.legs AS legs
+            }
+            """
+        ).run()
+        match = Runner(
+            """
+            MATCH (a:Animal)
+            RETURN properties(a) AS props
+            """
+        )
+        await match.run()
+        results = match.results
+        assert len(results) == 2
+        assert results[0] == {"props": {"name": "Dog", "legs": 4}}
+        assert results[1] == {"props": {"name": "Cat", "legs": 4}}
+
+    @pytest.mark.asyncio
+    async def test_properties_function_with_null(self):
+        """Test properties function with null."""
+        runner = Runner("RETURN properties(null) as props")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"props": None}
+
+    @pytest.mark.asyncio
+    async def test_nodes_function(self):
+        """Test nodes function with a graph path."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:City) AS {
+                UNWIND [
+                    {id: 1, name: 'New York'},
+                    {id: 2, name: 'Boston'}
+                ] AS record
+                RETURN record.id AS id, record.name AS name
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:City)-[:CONNECTED_TO]-(:City) AS {
+                UNWIND [
+                    {left_id: 1, right_id: 2}
+                ] AS record
+                RETURN record.left_id AS left_id, record.right_id AS right_id
+            }
+            """
+        ).run()
+        match = Runner(
+            """
+            MATCH p=(:City)-[:CONNECTED_TO]-(:City)
+            RETURN nodes(p) AS cities
+            """
+        )
+        await match.run()
+        results = match.results
+        assert len(results) == 1
+        assert len(results[0]["cities"]) == 2
+        assert results[0]["cities"][0]["id"] == 1
+        assert results[0]["cities"][0]["name"] == "New York"
+        assert results[0]["cities"][1]["id"] == 2
+        assert results[0]["cities"][1]["name"] == "Boston"
+
+    @pytest.mark.asyncio
+    async def test_relationships_function(self):
+        """Test relationships function with a graph path."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:City) AS {
+                UNWIND [
+                    {id: 1, name: 'New York'},
+                    {id: 2, name: 'Boston'}
+                ] AS record
+                RETURN record.id AS id, record.name AS name
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:City)-[:CONNECTED_TO]-(:City) AS {
+                UNWIND [
+                    {left_id: 1, right_id: 2, distance: 190}
+                ] AS record
+                RETURN record.left_id AS left_id, record.right_id AS right_id, record.distance AS distance
+            }
+            """
+        ).run()
+        match = Runner(
+            """
+            MATCH p=(:City)-[:CONNECTED_TO]-(:City)
+            RETURN relationships(p) AS rels
+            """
+        )
+        await match.run()
+        results = match.results
+        assert len(results) == 1
+        assert len(results[0]["rels"]) == 1
+        assert results[0]["rels"][0]["type"] == "CONNECTED_TO"
+        assert results[0]["rels"][0]["properties"]["distance"] == 190
+
+    @pytest.mark.asyncio
+    async def test_nodes_function_with_null(self):
+        """Test nodes function with null."""
+        runner = Runner("RETURN nodes(null) as n")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"n": []}
+
+    @pytest.mark.asyncio
+    async def test_relationships_function_with_null(self):
+        """Test relationships function with null."""
+        runner = Runner("RETURN relationships(null) as r")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"r": []}
+
     @pytest.mark.asyncio
     async def test_type_function(self):
         """Test type function."""
@@ -1940,6 +2207,46 @@ class TestRunner:
         assert results[2]["name"] == "Person 3"
         assert results[2]["friend"] is None
 
+    @pytest.mark.asyncio
+    async def test_optional_match_property_access_on_null_node_returns_null(self):
+        """Test that accessing a property on a null node from optional match returns null."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:OptPropPerson) AS {
+                unwind [
+                    {id: 1, name: 'Person 1'},
+                    {id: 2, name: 'Person 2'},
+                    {id: 3, name: 'Person 3'}
+                ] as record
+                RETURN record.id as id, record.name as name
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:OptPropPerson)-[:KNOWS]-(:OptPropPerson) AS {
+                unwind [
+                    {left_id: 1, right_id: 2}
+                ] as record
+                RETURN record.left_id as left_id, record.right_id as right_id
+            }
+            """
+        ).run()
+        # When accessing b.name and b is null (no match), should return null like Neo4j
+        match = Runner(
+            """
+            MATCH (a:OptPropPerson)
+            OPTIONAL MATCH (a)-[:KNOWS]->(b:OptPropPerson)
+            RETURN a.name AS name, b.name AS friend_name
+            """
+        )
+        await match.run()
+        results = match.results
+        assert len(results) == 3
+        assert results[0] == {"name": "Person 1", "friend_name": "Person 2"}
+        assert results[1] == {"name": "Person 2", "friend_name": None}
+        assert results[2] == {"name": "Person 3", "friend_name": None}
+
     @pytest.mark.asyncio
     async def test_optional_match_where_all_nodes_match(self):
         """Test optional match where all nodes have matching relationships."""
@@ -2152,20 +2459,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 +2860,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 +3223,713 @@ 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}
+
+    @pytest.mark.asyncio
+    async def test_coalesce_returns_first_non_null(self):
+        """Test coalesce returns first non-null value."""
+        runner = Runner("RETURN coalesce(null, null, 'hello', 'world') as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": "hello"}
+
+    @pytest.mark.asyncio
+    async def test_coalesce_returns_first_argument_when_not_null(self):
+        """Test coalesce returns first argument when not null."""
+        runner = Runner("RETURN coalesce('first', 'second') as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": "first"}
+
+    @pytest.mark.asyncio
+    async def test_coalesce_returns_null_when_all_null(self):
+        """Test coalesce returns null when all arguments are null."""
+        runner = Runner("RETURN coalesce(null, null, null) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": None}
+
+    @pytest.mark.asyncio
+    async def test_coalesce_with_single_non_null_argument(self):
+        """Test coalesce with single non-null argument."""
+        runner = Runner("RETURN coalesce(42) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": 42}
+
+    @pytest.mark.asyncio
+    async def test_coalesce_with_mixed_types(self):
+        """Test coalesce with mixed types."""
+        runner = Runner("RETURN coalesce(null, 42, 'hello') as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": 42}
+
+    @pytest.mark.asyncio
+    async def test_coalesce_with_property_access(self):
+        """Test coalesce with property access."""
+        runner = Runner("WITH {name: 'Alice'} AS person RETURN coalesce(person.nickname, person.name) as result")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"result": "Alice"}
+
+    # ============================================================
+    # Temporal / Time Functions (Neo4j-style)
+    # ============================================================
+
+    @pytest.mark.asyncio
+    async def test_datetime_returns_current_datetime_object(self):
+        """Test datetime() returns current datetime object."""
+        import time
+        before = int(time.time() * 1000)
+        runner = Runner("RETURN datetime() AS dt")
+        await runner.run()
+        after = int(time.time() * 1000)
+        results = runner.results
+        assert len(results) == 1
+        dt = results[0]["dt"]
+        assert dt is not None
+        assert isinstance(dt["year"], int)
+        assert isinstance(dt["month"], int)
+        assert isinstance(dt["day"], int)
+        assert isinstance(dt["hour"], int)
+        assert isinstance(dt["minute"], int)
+        assert isinstance(dt["second"], int)
+        assert isinstance(dt["millisecond"], int)
+        assert isinstance(dt["epochMillis"], int)
+        assert isinstance(dt["epochSeconds"], int)
+        assert isinstance(dt["dayOfWeek"], int)
+        assert isinstance(dt["dayOfYear"], int)
+        assert isinstance(dt["quarter"], int)
+        assert isinstance(dt["formatted"], str)
+        # epochMillis should be between before and after
+        assert dt["epochMillis"] >= before
+        assert dt["epochMillis"] <= after
+
+    @pytest.mark.asyncio
+    async def test_datetime_with_iso_string_argument(self):
+        """Test datetime() with ISO string argument."""
+        runner = Runner("RETURN datetime('2025-06-15T12:30:45.123Z') AS dt")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        dt = results[0]["dt"]
+        assert dt["year"] == 2025
+        assert dt["month"] == 6
+        assert dt["day"] == 15
+        assert dt["hour"] == 12
+        assert dt["minute"] == 30
+        assert dt["second"] == 45
+        assert dt["millisecond"] == 123
+        assert dt["formatted"] == "2025-06-15T12:30:45.123Z"
+
+    @pytest.mark.asyncio
+    async def test_datetime_property_access(self):
+        """Test datetime() property access."""
+        runner = Runner(
+            "WITH datetime('2025-06-15T12:30:45.123Z') AS dt RETURN dt.year AS year, dt.month AS month, dt.day AS day"
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"year": 2025, "month": 6, "day": 15}
+
+    @pytest.mark.asyncio
+    async def test_date_returns_current_date_object(self):
+        """Test date() returns current date object."""
+        runner = Runner("RETURN date() AS d")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        d = results[0]["d"]
+        assert d is not None
+        assert isinstance(d["year"], int)
+        assert isinstance(d["month"], int)
+        assert isinstance(d["day"], int)
+        assert isinstance(d["epochMillis"], int)
+        assert isinstance(d["dayOfWeek"], int)
+        assert isinstance(d["dayOfYear"], int)
+        assert isinstance(d["quarter"], int)
+        assert isinstance(d["formatted"], str)
+        # Should not have time fields
+        assert "hour" not in d
+        assert "minute" not in d
+
+    @pytest.mark.asyncio
+    async def test_date_with_iso_date_string(self):
+        """Test date() with ISO date string."""
+        runner = Runner("RETURN date('2025-06-15') AS d")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        d = results[0]["d"]
+        assert d["year"] == 2025
+        assert d["month"] == 6
+        assert d["day"] == 15
+        assert d["formatted"] == "2025-06-15"
+
+    @pytest.mark.asyncio
+    async def test_date_dayofweek_and_quarter(self):
+        """Test date() dayOfWeek and quarter."""
+        # 2025-06-15 is a Sunday
+        runner = Runner("RETURN date('2025-06-15') AS d")
+        await runner.run()
+        d = runner.results[0]["d"]
+        assert d["dayOfWeek"] == 7  # Sunday = 7 in ISO
+        assert d["quarter"] == 2  # June = Q2
+
+    @pytest.mark.asyncio
+    async def test_time_returns_current_utc_time(self):
+        """Test time() returns current UTC time."""
+        runner = Runner("RETURN time() AS t")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        t = results[0]["t"]
+        assert isinstance(t["hour"], int)
+        assert isinstance(t["minute"], int)
+        assert isinstance(t["second"], int)
+        assert isinstance(t["millisecond"], int)
+        assert isinstance(t["formatted"], str)
+        assert t["formatted"].endswith("Z")  # UTC time ends in Z
+
+    @pytest.mark.asyncio
+    async def test_localtime_returns_current_local_time(self):
+        """Test localtime() returns current local time."""
+        runner = Runner("RETURN localtime() AS t")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        t = results[0]["t"]
+        assert isinstance(t["hour"], int)
+        assert isinstance(t["minute"], int)
+        assert isinstance(t["second"], int)
+        assert isinstance(t["millisecond"], int)
+        assert isinstance(t["formatted"], str)
+        assert not t["formatted"].endswith("Z")  # Local time does not end in Z
+
+    @pytest.mark.asyncio
+    async def test_localdatetime_returns_current_local_datetime(self):
+        """Test localdatetime() returns current local datetime."""
+        runner = Runner("RETURN localdatetime() AS dt")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        dt = results[0]["dt"]
+        assert isinstance(dt["year"], int)
+        assert isinstance(dt["month"], int)
+        assert isinstance(dt["day"], int)
+        assert isinstance(dt["hour"], int)
+        assert isinstance(dt["minute"], int)
+        assert isinstance(dt["second"], int)
+        assert isinstance(dt["millisecond"], int)
+        assert isinstance(dt["epochMillis"], int)
+        assert isinstance(dt["formatted"], str)
+        assert not dt["formatted"].endswith("Z")  # Local datetime does not end in Z
+
+    @pytest.mark.asyncio
+    async def test_localdatetime_with_string_argument(self):
+        """Test localdatetime() with string argument."""
+        runner = Runner("RETURN localdatetime('2025-01-20T08:15:30.500') AS dt")
+        await runner.run()
+        dt = runner.results[0]["dt"]
+        assert isinstance(dt["year"], int)
+        assert isinstance(dt["hour"], int)
+        assert dt["epochMillis"] is not None
+
+    @pytest.mark.asyncio
+    async def test_timestamp_returns_epoch_millis(self):
+        """Test timestamp() returns epoch millis."""
+        import time
+        before = int(time.time() * 1000)
+        runner = Runner("RETURN timestamp() AS ts")
+        await runner.run()
+        after = int(time.time() * 1000)
+        results = runner.results
+        assert len(results) == 1
+        ts = results[0]["ts"]
+        assert isinstance(ts, int)
+        assert ts >= before
+        assert ts <= after
+
+    @pytest.mark.asyncio
+    async def test_datetime_epochmillis_matches_timestamp(self):
+        """Test datetime() epochMillis matches timestamp()."""
+        runner = Runner(
+            "WITH datetime() AS dt, timestamp() AS ts RETURN dt.epochMillis AS dtMillis, ts AS tsMillis"
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        # They should be very close (within a few ms)
+        assert abs(results[0]["dtMillis"] - results[0]["tsMillis"]) < 100
+
+    @pytest.mark.asyncio
+    async def test_date_with_property_access_in_where(self):
+        """Test date() with property access in WHERE."""
+        runner = Runner(
+            "UNWIND [1, 2, 3] AS x WITH x, date('2025-06-15') AS d WHERE d.quarter = 2 RETURN x"
+        )
+        await runner.run()
+        results = runner.results
+        assert len(results) == 3  # All 3 pass through since Q2 = 2
+
+    @pytest.mark.asyncio
+    async def test_datetime_with_map_argument(self):
+        """Test datetime() with map argument."""
+        runner = Runner(
+            "RETURN datetime({year: 2024, month: 12, day: 25, hour: 10, minute: 30}) AS dt"
+        )
+        await runner.run()
+        dt = runner.results[0]["dt"]
+        assert dt["year"] == 2024
+        assert dt["month"] == 12
+        assert dt["day"] == 25
+        assert dt["quarter"] == 4  # December = Q4
+
+    @pytest.mark.asyncio
+    async def test_date_with_map_argument(self):
+        """Test date() with map argument."""
+        runner = Runner(
+            "RETURN date({year: 2025, month: 3, day: 1}) AS d"
+        )
+        await runner.run()
+        d = runner.results[0]["d"]
+        assert d["year"] == 2025
+        assert d["month"] == 3
+        assert d["day"] == 1
+        assert d["quarter"] == 1  # March = Q1
+
+    @pytest.mark.asyncio
+    async def test_id_function_with_node(self):
+        """Test id() function with a graph node."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:Person) AS {
+                UNWIND [
+                    {id: 1, name: 'Alice'},
+                    {id: 2, name: 'Bob'}
+                ] AS record
+                RETURN record.id AS id, record.name AS name
+            }
+            """
+        ).run()
+        match = Runner(
+            """
+            MATCH (n:Person)
+            RETURN id(n) AS nodeId
+            """
+        )
+        await match.run()
+        results = match.results
+        assert len(results) == 2
+        assert results[0] == {"nodeId": 1}
+        assert results[1] == {"nodeId": 2}
+
+    @pytest.mark.asyncio
+    async def test_id_function_with_null(self):
+        """Test id() function with null."""
+        runner = Runner("RETURN id(null) AS nodeId")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"nodeId": None}
+
+    @pytest.mark.asyncio
+    async def test_id_function_with_relationship(self):
+        """Test id() function with a relationship."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:City) AS {
+                UNWIND [
+                    {id: 1, name: 'New York'},
+                    {id: 2, name: 'Boston'}
+                ] AS record
+                RETURN record.id AS id, record.name AS name
+            }
+            """
+        ).run()
+        await Runner(
+            """
+            CREATE VIRTUAL (:City)-[:CONNECTED_TO]-(:City) AS {
+                UNWIND [
+                    {left_id: 1, right_id: 2}
+                ] AS record
+                RETURN record.left_id AS left_id, record.right_id AS right_id
+            }
+            """
+        ).run()
+        match = Runner(
+            """
+            MATCH (a:City)-[r:CONNECTED_TO]->(b:City)
+            RETURN id(r) AS relId
+            """
+        )
+        await match.run()
+        results = match.results
+        assert len(results) == 1
+        assert results[0] == {"relId": "CONNECTED_TO"}
+
+    @pytest.mark.asyncio
+    async def test_element_id_function_with_node(self):
+        """Test elementId() function with a graph node."""
+        await Runner(
+            """
+            CREATE VIRTUAL (:Person) AS {
+                UNWIND [
+                    {id: 1, name: 'Alice'},
+                    {id: 2, name: 'Bob'}
+                ] AS record
+                RETURN record.id AS id, record.name AS name
+            }
+            """
+        ).run()
+        match = Runner(
+            """
+            MATCH (n:Person)
+            RETURN elementId(n) AS eid
+            """
+        )
+        await match.run()
+        results = match.results
+        assert len(results) == 2
+        assert results[0] == {"eid": "1"}
+        assert results[1] == {"eid": "2"}
+
+    @pytest.mark.asyncio
+    async def test_element_id_function_with_null(self):
+        """Test elementId() function with null."""
+        runner = Runner("RETURN elementId(null) AS eid")
+        await runner.run()
+        results = runner.results
+        assert len(results) == 1
+        assert results[0] == {"eid": None}
+
+    @pytest.mark.asyncio
+    async def test_head_function(self):
+        """Test head() function."""
+        runner = Runner("RETURN head([1, 2, 3]) AS h")
+        await runner.run()
+        assert len(runner.results) == 1
+        assert runner.results[0] == {"h": 1}
+
+    @pytest.mark.asyncio
+    async def test_head_function_empty_list(self):
+        """Test head() function with empty list."""
+        runner = Runner("RETURN head([]) AS h")
+        await runner.run()
+        assert runner.results[0] == {"h": None}
+
+    @pytest.mark.asyncio
+    async def test_head_function_null(self):
+        """Test head() function with null."""
+        runner = Runner("RETURN head(null) AS h")
+        await runner.run()
+        assert runner.results[0] == {"h": None}
+
+    @pytest.mark.asyncio
+    async def test_tail_function(self):
+        """Test tail() function."""
+        runner = Runner("RETURN tail([1, 2, 3]) AS t")
+        await runner.run()
+        assert len(runner.results) == 1
+        assert runner.results[0] == {"t": [2, 3]}
+
+    @pytest.mark.asyncio
+    async def test_tail_function_single_element(self):
+        """Test tail() function with single element."""
+        runner = Runner("RETURN tail([1]) AS t")
+        await runner.run()
+        assert runner.results[0] == {"t": []}
+
+    @pytest.mark.asyncio
+    async def test_tail_function_null(self):
+        """Test tail() function with null."""
+        runner = Runner("RETURN tail(null) AS t")
+        await runner.run()
+        assert runner.results[0] == {"t": None}
+
+    @pytest.mark.asyncio
+    async def test_last_function(self):
+        """Test last() function."""
+        runner = Runner("RETURN last([1, 2, 3]) AS l")
+        await runner.run()
+        assert len(runner.results) == 1
+        assert runner.results[0] == {"l": 3}
+
+    @pytest.mark.asyncio
+    async def test_last_function_empty_list(self):
+        """Test last() function with empty list."""
+        runner = Runner("RETURN last([]) AS l")
+        await runner.run()
+        assert runner.results[0] == {"l": None}
+
+    @pytest.mark.asyncio
+    async def test_last_function_null(self):
+        """Test last() function with null."""
+        runner = Runner("RETURN last(null) AS l")
+        await runner.run()
+        assert runner.results[0] == {"l": None}
+
+    @pytest.mark.asyncio
+    async def test_to_integer_function_string(self):
+        """Test toInteger() function with string."""
+        runner = Runner('RETURN toInteger("42") AS i')
+        await runner.run()
+        assert runner.results[0] == {"i": 42}
+
+    @pytest.mark.asyncio
+    async def test_to_integer_function_float(self):
+        """Test toInteger() function with float."""
+        runner = Runner("RETURN toInteger(3.14) AS i")
+        await runner.run()
+        assert runner.results[0] == {"i": 3}
+
+    @pytest.mark.asyncio
+    async def test_to_integer_function_boolean(self):
+        """Test toInteger() function with boolean."""
+        runner = Runner("RETURN toInteger(true) AS i")
+        await runner.run()
+        assert runner.results[0] == {"i": 1}
+
+    @pytest.mark.asyncio
+    async def test_to_integer_function_null(self):
+        """Test toInteger() function with null."""
+        runner = Runner("RETURN toInteger(null) AS i")
+        await runner.run()
+        assert runner.results[0] == {"i": None}
+
+    @pytest.mark.asyncio
+    async def test_to_float_function_string(self):
+        """Test toFloat() function with string."""
+        runner = Runner('RETURN toFloat("3.14") AS f')
+        await runner.run()
+        assert runner.results[0] == {"f": 3.14}
+
+    @pytest.mark.asyncio
+    async def test_to_float_function_integer(self):
+        """Test toFloat() function with integer."""
+        runner = Runner("RETURN toFloat(42) AS f")
+        await runner.run()
+        assert runner.results[0] == {"f": 42}
+
+    @pytest.mark.asyncio
+    async def test_to_float_function_boolean(self):
+        """Test toFloat() function with boolean."""
+        runner = Runner("RETURN toFloat(true) AS f")
+        await runner.run()
+        assert runner.results[0] == {"f": 1.0}
+
+    @pytest.mark.asyncio
+    async def test_to_float_function_null(self):
+        """Test toFloat() function with null."""
+        runner = Runner("RETURN toFloat(null) AS f")
+        await runner.run()
+        assert runner.results[0] == {"f": None}
+
+    @pytest.mark.asyncio
+    async def test_duration_iso_string(self):
+        """Test duration() with ISO 8601 string."""
+        runner = Runner("RETURN duration('P1Y2M3DT4H5M6S') AS d")
+        await runner.run()
+        d = runner.results[0]["d"]
+        assert d["years"] == 1
+        assert d["months"] == 2
+        assert d["days"] == 3
+        assert d["hours"] == 4
+        assert d["minutes"] == 5
+        assert d["seconds"] == 6
+        assert d["totalMonths"] == 14
+        assert d["formatted"] == "P1Y2M3DT4H5M6S"
+
+    @pytest.mark.asyncio
+    async def test_duration_map_argument(self):
+        """Test duration() with map argument."""
+        runner = Runner("RETURN duration({days: 14, hours: 16}) AS d")
+        await runner.run()
+        d = runner.results[0]["d"]
+        assert d["days"] == 14
+        assert d["hours"] == 16
+        assert d["totalDays"] == 14
+        assert d["totalSeconds"] == 57600
+
+    @pytest.mark.asyncio
+    async def test_duration_weeks(self):
+        """Test duration() with weeks."""
+        runner = Runner("RETURN duration('P2W') AS d")
+        await runner.run()
+        d = runner.results[0]["d"]
+        assert d["weeks"] == 2
+        assert d["days"] == 14
+        assert d["totalDays"] == 14
+
+    @pytest.mark.asyncio
+    async def test_duration_null(self):
+        """Test duration() with null."""
+        runner = Runner("RETURN duration(null) AS d")
+        await runner.run()
+        assert runner.results[0] == {"d": None}
+
+    @pytest.mark.asyncio
+    async def test_duration_time_only(self):
+        """Test duration() with time-only string."""
+        runner = Runner("RETURN duration('PT2H30M') AS d")
+        await runner.run()
+        d = runner.results[0]["d"]
+        assert d["hours"] == 2
+        assert d["minutes"] == 30
+        assert d["totalSeconds"] == 9000
+        assert d["formatted"] == "PT2H30M"