Fix multiple Cypher parser and executor bugs

- Fix keys() and properties() returning empty results by changing
  EXISTS (... UNION ALL ...) to EXISTS (...) OR EXISTS (...)
- Allow 'end' as identifier in Cypher queries (variable names,
  property access) - only reserved in CASE...END context
- Fix list functions (range, tail, split) to return proper arrays
  instead of expanding into multiple rows
- Fix UNWIND with list literals and expressions
- Fix WITH clause variable scoping and expression handling
- Update Rust and Python bindings to handle new array return format
  with extract_algo_array() helpers

Includes regression tests for all fixes.

Author: Dylan Storey

bindings/python/src/graphqlite/algorithms/_parsing.py

@@ -1,6 +1,39 @@
 """Shared parsing helpers for algorithm results."""
 
-from typing import Any, Optional
+from typing import Any, List, Optional
+
+
+# Known column names for graph algorithm results
+ALGO_COLUMN_NAMES = [
+    "column_0", "wcc()", "scc()", "pagerank()", "degree_centrality()",
+    "betweenness_centrality()", "closeness_centrality()", "eigenvector_centrality()",
+    "labelPropagation()", "louvain()"
+]
+
+
+def extract_algo_array(result: List[dict]) -> List[dict]:
+    """Extract wrapped array results from graph algorithms.
+
+    Graph algorithms return results in one of two formats:
+    1. Old format: Multiple rows with fields directly accessible
+    2. New format: Single row with a column containing an array of objects
+
+    This function detects the new format and extracts the array elements.
+    """
+    # If multiple rows, assume old format - return as-is
+    if len(result) != 1:
+        return result
+
+    # Single row - check if it has an array column
+    row = result[0]
+
+    # Try common column names for wrapped array results
+    for col_name in ALGO_COLUMN_NAMES:
+        if col_name in row and isinstance(row[col_name], list):
+            return row[col_name]
+
+    # No array column found, return original result
+    return result
 
 
 def parse_score_result(row: dict, score_key: str = "score") -> Optional[dict]:

bindings/python/src/graphqlite/algorithms/centrality.py

@@ -3,7 +3,7 @@
 from typing import Any
 
 from ..graph._base import BaseMixin
-from ._parsing import safe_float, safe_int
+from ._parsing import extract_algo_array, safe_float, safe_int
 
 
 class CentralityMixin(BaseMixin):
@@ -28,9 +28,10 @@ def pagerank(
         result = self._conn.cypher(
             f"RETURN pageRank({damping}, {iterations})"
         )
+        rows = extract_algo_array(result)
 
         ranks = []
-        for row in result:
+        for row in rows:
             node_id = row.get("node_id")
             user_id = row.get("user_id")
             score = row.get("score")
@@ -54,9 +55,10 @@ def degree_centrality(self) -> list[dict]:
             'out_degree', 'degree'
         """
         result = self._conn.cypher("RETURN degreeCentrality()")
+        rows = extract_algo_array(result)
 
         degrees = []
-        for row in result:
+        for row in rows:
             node_id = row.get("node_id")
             user_id = row.get("user_id")
             in_degree = row.get("in_degree")
@@ -86,9 +88,10 @@ def betweenness_centrality(self) -> list[dict]:
             where score is the betweenness centrality value
         """
         result = self._conn.cypher("RETURN betweennessCentrality()")
+        rows = extract_algo_array(result)
 
         scores = []
-        for row in result:
+        for row in rows:
             node_id = row.get("node_id")
             user_id = row.get("user_id")
             score = row.get("score")
@@ -118,9 +121,10 @@ def closeness_centrality(self) -> list[dict]:
             where score is the closeness centrality value (0 to 1)
         """
         result = self._conn.cypher("RETURN closenessCentrality()")
+        rows = extract_algo_array(result)
 
         scores = []
-        for row in result:
+        for row in rows:
             node_id = row.get("node_id")
             user_id = row.get("user_id")
             score = row.get("score")
@@ -156,9 +160,10 @@ def eigenvector_centrality(self, iterations: int = 100) -> list[dict]:
         """
         query = f"RETURN eigenvectorCentrality({iterations})"
         result = self._conn.cypher(query)
+        rows = extract_algo_array(result)
 
         scores = []
-        for row in result:
+        for row in rows:
             node_id = row.get("node_id")
             user_id = row.get("user_id")
             score = row.get("score")

bindings/python/src/graphqlite/algorithms/community.py

@@ -3,7 +3,7 @@
 from typing import Optional
 
 from ..graph._base import BaseMixin
-from ._parsing import safe_int
+from ._parsing import extract_algo_array, safe_int
 
 
 class CommunityMixin(BaseMixin):
@@ -20,9 +20,10 @@ def community_detection(self, iterations: int = 10) -> list[dict]:
             List of dicts with 'node_id', 'user_id', 'community'
         """
         result = self._conn.cypher(f"RETURN labelPropagation({iterations})")
+        rows = extract_algo_array(result)
 
         communities = []
-        for row in result:
+        for row in rows:
             node_id = row.get("node_id")
             user_id = row.get("user_id")
             community = row.get("community")
@@ -50,9 +51,10 @@ def louvain(self, resolution: float = 1.0) -> list[dict]:
             List of dicts with 'node_id', 'user_id', 'community'
         """
         result = self._conn.cypher(f"RETURN louvain({resolution})")
+        rows = extract_algo_array(result)
 
         communities = []
-        for row in result:
+        for row in rows:
             node_id = row.get("node_id")
             user_id = row.get("user_id")
             community = row.get("community")

bindings/python/src/graphqlite/algorithms/components.py

@@ -1,7 +1,7 @@
 """Connected components algorithms mixin."""
 
 from ..graph._base import BaseMixin
-from ._parsing import safe_int
+from ._parsing import extract_algo_array, safe_int
 
 
 class ComponentsMixin(BaseMixin):
@@ -19,9 +19,10 @@ def weakly_connected_components(self) -> list[dict]:
             where nodes in the same component share the same component number
         """
         result = self._conn.cypher("RETURN wcc()")
+        rows = extract_algo_array(result)
 
         components = []
-        for row in result:
+        for row in rows:
             node_id = row.get("node_id")
             user_id = row.get("user_id")
             component = row.get("component")
@@ -52,9 +53,10 @@ def strongly_connected_components(self) -> list[dict]:
             where nodes in the same SCC share the same component number
         """
         result = self._conn.cypher("RETURN scc()")
+        rows = extract_algo_array(result)
 
         components = []
-        for row in result:
+        for row in rows:
             node_id = row.get("node_id")
             user_id = row.get("user_id")
             component = row.get("component")

bindings/python/tests/test_connection.py

@@ -769,9 +769,11 @@ def test_tail_function(db):
     """Test tail() function."""
     results = db.cypher("RETURN tail([1, 2, 3]) AS result")
     assert len(results) == 1
-    # tail returns [2, 3] as JSON
-    import json
-    tail = json.loads(results[0]["result"])
+    # tail returns [2, 3] as a list (may be native list or JSON string)
+    tail = results[0]["result"]
+    if isinstance(tail, str):
+        import json
+        tail = json.loads(tail)
     assert tail == [2, 3]
 
 
@@ -786,8 +788,11 @@ def test_range_function(db):
     """Test range() function."""
     results = db.cypher("RETURN range(1, 5) AS result")
     assert len(results) == 1
-    import json
-    r = json.loads(results[0]["result"])
+    # range returns a list (may be native list or JSON string)
+    r = results[0]["result"]
+    if isinstance(r, str):
+        import json
+        r = json.loads(r)
     assert r == [1, 2, 3, 4, 5]
 
 
@@ -1078,9 +1083,11 @@ def test_path_nodes(db):
     """)
     assert len(results) == 1
     # Column alias may not be applied, check both possibilities
-    import json
     col_name = "path_nodes" if "path_nodes" in results[0] else "result"
-    nodes = json.loads(results[0][col_name])
+    nodes = results[0][col_name]
+    if isinstance(nodes, str):
+        import json
+        nodes = json.loads(nodes)
     assert len(nodes) == 2
 
 
@@ -1093,9 +1100,11 @@ def test_path_relationships(db):
     """)
     assert len(results) == 1
     # Column alias may not be applied, check both possibilities
-    import json
     col_name = "rels" if "rels" in results[0] else "result"
-    rels = json.loads(results[0][col_name])
+    rels = results[0][col_name]
+    if isinstance(rels, str):
+        import json
+        rels = json.loads(rels)
     assert len(rels) == 1
 
 
@@ -1171,10 +1180,12 @@ def test_labels_function(db):
     db.cypher("CREATE (n:Person:Employee:Manager {name: 'Alice'})")
     results = db.cypher("MATCH (n:Person {name: 'Alice'}) RETURN labels(n) AS lbls")
     assert len(results) == 1
-    import json
     # Column alias may not be applied, check both possibilities
     col_name = "lbls" if "lbls" in results[0] else "result"
-    labels = json.loads(results[0][col_name])
+    labels = results[0][col_name]
+    if isinstance(labels, str):
+        import json
+        labels = json.loads(labels)
     assert "Person" in labels
     assert "Employee" in labels
     assert "Manager" in labels

bindings/rust/Cargo.lock

@@ -5,7 +5,7 @@ use crate::Result;
 use super::{
     PageRankResult, DegreeCentralityResult, BetweennessCentralityResult,
     ClosenessCentralityResult, EigenvectorCentralityResult,
-    parsing::{extract_node_id, extract_user_id, extract_float, extract_int},
+    parsing::{extract_algo_array, extract_node_id, extract_user_id, extract_float, extract_int},
 };
 
 impl Graph {
@@ -18,9 +18,10 @@ impl Graph {
     pub fn pagerank(&self, damping: f64, iterations: i32) -> Result<Vec<PageRankResult>> {
         let query = format!("RETURN pageRank({}, {})", damping, iterations);
         let result = self.connection().cypher(&query)?;
+        let rows = extract_algo_array(result.iter().collect::<Vec<_>>().as_slice());
 
         let mut ranks = Vec::new();
-        for row in result.iter() {
+        for row in rows.iter() {
             if let Some(node_id) = extract_node_id(row) {
                 ranks.push(PageRankResult {
                     node_id,
@@ -35,9 +36,10 @@ impl Graph {
     /// Calculate degree centrality for all nodes.
     pub fn degree_centrality(&self) -> Result<Vec<DegreeCentralityResult>> {
         let result = self.connection().cypher("RETURN degreeCentrality()")?;
+        let rows = extract_algo_array(result.iter().collect::<Vec<_>>().as_slice());
 
         let mut degrees = Vec::new();
-        for row in result.iter() {
+        for row in rows.iter() {
             if let Some(node_id) = extract_node_id(row) {
                 degrees.push(DegreeCentralityResult {
                     node_id,
@@ -54,9 +56,10 @@ impl Graph {
     /// Calculate betweenness centrality for all nodes.
     pub fn betweenness_centrality(&self) -> Result<Vec<BetweennessCentralityResult>> {
         let result = self.connection().cypher("RETURN betweennessCentrality()")?;
+        let rows = extract_algo_array(result.iter().collect::<Vec<_>>().as_slice());
 
         let mut scores = Vec::new();
-        for row in result.iter() {
+        for row in rows.iter() {
             if let Some(node_id) = extract_node_id(row) {
                 scores.push(BetweennessCentralityResult {
                     node_id,
@@ -71,9 +74,10 @@ impl Graph {
     /// Calculate closeness centrality for all nodes.
     pub fn closeness_centrality(&self) -> Result<Vec<ClosenessCentralityResult>> {
         let result = self.connection().cypher("RETURN closenessCentrality()")?;
+        let rows = extract_algo_array(result.iter().collect::<Vec<_>>().as_slice());
 
         let mut scores = Vec::new();
-        for row in result.iter() {
+        for row in rows.iter() {
             if let Some(node_id) = extract_node_id(row) {
                 scores.push(ClosenessCentralityResult {
                     node_id,
@@ -93,9 +97,10 @@ impl Graph {
     pub fn eigenvector_centrality(&self, iterations: i32) -> Result<Vec<EigenvectorCentralityResult>> {
         let query = format!("RETURN eigenvectorCentrality({})", iterations);
         let result = self.connection().cypher(&query)?;
+        let rows = extract_algo_array(result.iter().collect::<Vec<_>>().as_slice());
 
         let mut scores = Vec::new();
-        for row in result.iter() {
+        for row in rows.iter() {
             if let Some(node_id) = extract_node_id(row) {
                 scores.push(EigenvectorCentralityResult {
                     node_id,

bindings/rust/src/algorithms/centrality.rs

@@ -4,7 +4,7 @@ use crate::graph::Graph;
 use crate::Result;
 use super::{
     CommunityResult,
-    parsing::{extract_node_id, extract_user_id, extract_int},
+    parsing::{extract_algo_array, extract_node_id, extract_user_id, extract_int},
 };
 
 impl Graph {
@@ -16,9 +16,10 @@ impl Graph {
     pub fn community_detection(&self, iterations: i32) -> Result<Vec<CommunityResult>> {
         let query = format!("RETURN labelPropagation({})", iterations);
         let result = self.connection().cypher(&query)?;
+        let rows = extract_algo_array(result.iter().collect::<Vec<_>>().as_slice());
 
         let mut communities = Vec::new();
-        for row in result.iter() {
+        for row in rows.iter() {
             if let Some(node_id) = extract_node_id(row) {
                 communities.push(CommunityResult {
                     node_id,
@@ -38,9 +39,10 @@ impl Graph {
     pub fn louvain(&self, resolution: f64) -> Result<Vec<CommunityResult>> {
         let query = format!("RETURN louvain({})", resolution);
         let result = self.connection().cypher(&query)?;
+        let rows = extract_algo_array(result.iter().collect::<Vec<_>>().as_slice());
 
         let mut communities = Vec::new();
-        for row in result.iter() {
+        for row in rows.iter() {
             if let Some(node_id) = extract_node_id(row) {
                 communities.push(CommunityResult {
                     node_id,

bindings/rust/src/algorithms/community.rs

@@ -4,7 +4,7 @@ use crate::graph::Graph;
 use crate::Result;
 use super::{
     ComponentResult,
-    parsing::{extract_node_id, extract_user_id, extract_int},
+    parsing::{extract_algo_array, extract_node_id, extract_user_id, extract_int},
 };
 
 impl Graph {
@@ -13,9 +13,10 @@ impl Graph {
     /// Treats the graph as undirected and finds connected components.
     pub fn wcc(&self) -> Result<Vec<ComponentResult>> {
         let result = self.connection().cypher("RETURN wcc()")?;
+        let rows = extract_algo_array(result.iter().collect::<Vec<_>>().as_slice());
 
         let mut components = Vec::new();
-        for row in result.iter() {
+        for row in rows.iter() {
             if let Some(node_id) = extract_node_id(row) {
                 components.push(ComponentResult {
                     node_id,
@@ -33,9 +34,10 @@ impl Graph {
     /// other node following edge directions. Uses Tarjan's algorithm.
     pub fn scc(&self) -> Result<Vec<ComponentResult>> {
         let result = self.connection().cypher("RETURN scc()")?;
+        let rows = extract_algo_array(result.iter().collect::<Vec<_>>().as_slice());
 
         let mut components = Vec::new();
-        for row in result.iter() {
+        for row in rows.iter() {
             if let Some(node_id) = extract_node_id(row) {
                 components.push(ComponentResult {
                     node_id,