graphqlite 0.4.0__tar.gz → 0.4.2__tar.gz

{graphqlite-0.4.0/src/graphqlite.egg-info → graphqlite-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphqlite
-Version: 0.4.0
+Version: 0.4.2
 Summary: SQLite extension for graph queries using Cypher
 Author: GraphQLite Contributors
 License: MIT

{graphqlite-0.4.0 → graphqlite-0.4.2}/src/graphqlite/__init__.py

@@ -8,7 +8,7 @@ from .manager import GraphManager, graphs
 from .utils import escape_string, sanitize_rel_type, CYPHER_RESERVED
 from ._platform import get_loadable_path
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"
 __all__ = [
     "BulkInsertResult",
     "Connection", "connect", "wrap", "load", "loadable_path",

{graphqlite-0.4.0 → graphqlite-0.4.2}/src/graphqlite/connection.py

@@ -142,11 +142,23 @@ class Connection:
         Example:
             >>> db.cypher("MATCH (n) WHERE n.name = $name RETURN n", {"name": "Alice"})
         """
-        if params:
-            params_json = json.dumps(params)
-            cursor = self._conn.execute("SELECT cypher(?, ?)", (query, params_json))
-        else:
-            cursor = self._conn.execute("SELECT cypher(?)", (query,))
+        try:
+            if params:
+                params_json = json.dumps(params)
+                cursor = self._conn.execute("SELECT cypher(?, ?)", (query, params_json))
+            else:
+                cursor = self._conn.execute("SELECT cypher(?)", (query,))
+        except sqlite3.Error as e:
+            # Parse structured JSON error from extension
+            err_str = str(e)
+            try:
+                err_data = json.loads(err_str)
+                if isinstance(err_data, dict) and "error" in err_data:
+                    raise sqlite3.Error(err_data["error"]) from None
+            except (json.JSONDecodeError, TypeError):
+                pass
+            raise
+
         row = cursor.fetchone()
 
         if row is None or row[0] is None:
@@ -158,8 +170,8 @@ class Connection:
         try:
             data = json.loads(result_str)
         except json.JSONDecodeError:
-            # Non-JSON result (error message or scalar)
-            if result_str.startswith("Error"):
+            # Non-JSON result (scalar or legacy error)
+            if result_str.startswith("Error") or result_str.startswith("{\"error\""):
                 raise sqlite3.Error(result_str)
             return CypherResult([{"result": result_str}], ["result"])
 

{graphqlite-0.4.0 → graphqlite-0.4.2}/src/graphqlite/graph/edges.py

@@ -23,9 +23,10 @@ class EdgesMixin(BaseMixin):
         """
         rel_pattern = f":{sanitize_rel_type(rel_type)}" if rel_type else ""
         result = self._conn.cypher(
-            f"MATCH (a {{id: '{self._escape(source_id)}'}})-[r{rel_pattern}]->"
-            f"(b {{id: '{self._escape(target_id)}'}}) "
-            f"RETURN count(r) AS cnt"
+            f"MATCH (a {{id: $src}})-[r{rel_pattern}]->"
+            f"(b {{id: $tgt}}) "
+            f"RETURN count(r) AS cnt",
+            params={"src": source_id, "tgt": target_id},
         )
         if len(result) == 0:
             return False
@@ -46,8 +47,9 @@ class EdgesMixin(BaseMixin):
         """
         rel_pattern = f":{sanitize_rel_type(rel_type)}" if rel_type else ""
         result = self._conn.cypher(
-            f"MATCH (a {{id: '{self._escape(source_id)}'}})-[r{rel_pattern}]->"
-            f"(b {{id: '{self._escape(target_id)}'}}) RETURN r"
+            f"MATCH (a {{id: $src}})-[r{rel_pattern}]->"
+            f"(b {{id: $tgt}}) RETURN r",
+            params={"src": source_id, "tgt": target_id},
         )
         if len(result) == 0:
             return None
@@ -75,29 +77,25 @@ class EdgesMixin(BaseMixin):
             rel_type: Relationship type label
         """
         safe_rel_type = sanitize_rel_type(rel_type)
-        esc_source = self._escape(source_id)
-        esc_target = self._escape(target_id)
 
         self._conn.cypher(
-            f"MATCH (a {{id: '{esc_source}'}}), (b {{id: '{esc_target}'}}) "
-            f"MERGE (a)-[r:{safe_rel_type}]->(b)"
+            f"MATCH (a {{id: $src}}), (b {{id: $tgt}}) "
+            f"MERGE (a)-[r:{safe_rel_type}]->(b)",
+            params={"src": source_id, "tgt": target_id},
         )
 
         if edge_data:
+            params = {"src": source_id, "tgt": target_id}
             set_parts = []
-            for k, v in edge_data.items():
-                if isinstance(v, str):
-                    set_parts.append(f"r.{k} = '{self._escape(v)}'")
-                elif isinstance(v, bool):
-                    set_parts.append(f"r.{k} = {str(v).lower()}")
-                elif v is None:
-                    set_parts.append(f"r.{k} = null")
-                else:
-                    set_parts.append(f"r.{k} = {v}")
+            for i, (k, v) in enumerate(edge_data.items()):
+                param_name = f"v{i}"
+                set_parts.append(f"r.{k} = ${param_name}")
+                params[param_name] = v
             set_str = ", ".join(set_parts)
             self._conn.cypher(
-                f"MATCH (a {{id: '{esc_source}'}})-[r:{safe_rel_type}]->"
-                f"(b {{id: '{esc_target}'}}) SET {set_str}"
+                f"MATCH (a {{id: $src}})-[r:{safe_rel_type}]->"
+                f"(b {{id: $tgt}}) SET {set_str}",
+                params=params,
             )
 
     def delete_edge(self, source_id: str, target_id: str, rel_type: Optional[str] = None) -> None:
@@ -111,8 +109,9 @@ class EdgesMixin(BaseMixin):
         """
         rel_pattern = f":{sanitize_rel_type(rel_type)}" if rel_type else ""
         self._conn.cypher(
-            f"MATCH (a {{id: '{self._escape(source_id)}'}})-[r{rel_pattern}]->"
-            f"(b {{id: '{self._escape(target_id)}'}}) DELETE r"
+            f"MATCH (a {{id: $src}})-[r{rel_pattern}]->"
+            f"(b {{id: $tgt}}) DELETE r",
+            params={"src": source_id, "tgt": target_id},
         )
 
     def get_all_edges(self) -> list[dict]:

{graphqlite-0.4.0 → graphqlite-0.4.2}/src/graphqlite/graph/nodes.py

@@ -20,7 +20,8 @@ class NodesMixin(BaseMixin):
             True if node exists, False otherwise
         """
         result = self._conn.cypher(
-            f"MATCH (n {{id: '{self._escape(node_id)}'}}) RETURN count(n) AS cnt"
+            "MATCH (n {id: $id}) RETURN count(n) AS cnt",
+            params={"id": node_id},
         )
         if len(result) == 0:
             return False
@@ -38,7 +39,8 @@ class NodesMixin(BaseMixin):
             Node dict with 'id', 'labels', 'properties' or None if not found
         """
         result = self._conn.cypher(
-            f"MATCH (n {{id: '{self._escape(node_id)}'}}) RETURN n"
+            "MATCH (n {id: $id}) RETURN n",
+            params={"id": node_id},
         )
         if len(result) == 0:
             return None
@@ -66,17 +68,10 @@ class NodesMixin(BaseMixin):
         if self.has_node(node_id):
             # Update existing node
             for k, v in node_data.items():
-                if isinstance(v, str):
-                    val = f"'{self._escape(v)}'"
-                elif isinstance(v, bool):
-                    val = str(v).lower()
-                elif v is None:
-                    val = "null"
-                else:
-                    val = str(v)
                 self._conn.cypher(
-                    f"MATCH (n {{id: '{self._escape(node_id)}'}}) "
-                    f"SET n.{k} = {val} RETURN n"
+                    f"MATCH (n {{id: $id}}) "
+                    f"SET n.{k} = $val RETURN n",
+                    params={"id": node_id, "val": v},
                 )
         else:
             # Create new node
@@ -91,7 +86,8 @@ class NodesMixin(BaseMixin):
             node_id: The node's id property value
         """
         self._conn.cypher(
-            f"MATCH (n {{id: '{self._escape(node_id)}'}}) DETACH DELETE n"
+            "MATCH (n {id: $id}) DETACH DELETE n",
+            params={"id": node_id},
         )
 
     def get_all_nodes(self, label: Optional[str] = None) -> list[dict]:

{graphqlite-0.4.0 → graphqlite-0.4.2}/src/graphqlite/graph/queries.py

@@ -21,8 +21,9 @@ class QueriesMixin(BaseMixin):
             Number of edges connected to the node
         """
         result = self._conn.cypher(
-            f"MATCH (n {{id: '{self._escape(node_id)}'}})-[r]-() "
-            f"RETURN count(r) AS degree"
+            "MATCH (n {id: $id})-[r]-() "
+            "RETURN count(r) AS degree",
+            params={"id": node_id},
         )
         if len(result) == 0:
             return 0
@@ -42,8 +43,9 @@ class QueriesMixin(BaseMixin):
             List of neighbor node dicts
         """
         result = self._conn.cypher(
-            f"MATCH (n {{id: '{self._escape(node_id)}'}})-[]-(m) "
-            f"RETURN DISTINCT m"
+            "MATCH (n {id: $id})-[]-(m) "
+            "RETURN DISTINCT m",
+            params={"id": node_id},
         )
         return [row.get("m") for row in result if row.get("m")]
 
@@ -58,8 +60,9 @@ class QueriesMixin(BaseMixin):
             List of (source_id, target_id, properties) tuples
         """
         result = self._conn.cypher(
-            f"MATCH (n {{id: '{self._escape(node_id)}'}})-[r]-(m) "
-            f"RETURN n.id AS source, m.id AS target, r"
+            "MATCH (n {id: $id})-[r]-(m) "
+            "RETURN n.id AS source, m.id AS target, r",
+            params={"id": node_id},
         )
         return [(row["source"], row["target"], row.get("r", {})) for row in result]
 
@@ -74,8 +77,9 @@ class QueriesMixin(BaseMixin):
             List of dicts with 'source', 'target', 'r' keys
         """
         result = self._conn.cypher(
-            f"MATCH (a {{id: '{self._escape(node_id)}'}})-[r]->(b) "
-            f"RETURN a.id AS source, b.id AS target, r"
+            "MATCH (a {id: $id})-[r]->(b) "
+            "RETURN a.id AS source, b.id AS target, r",
+            params={"id": node_id},
         )
         return result.to_list()
 
@@ -90,8 +94,9 @@ class QueriesMixin(BaseMixin):
             List of dicts with 'source', 'target', 'r' keys
         """
         result = self._conn.cypher(
-            f"MATCH (a)-[r]->(b {{id: '{self._escape(node_id)}'}}) "
-            f"RETURN a.id AS source, b.id AS target, r"
+            "MATCH (a)-[r]->(b {id: $id}) "
+            "RETURN a.id AS source, b.id AS target, r",
+            params={"id": node_id},
         )
         return result.to_list()
 
@@ -109,8 +114,9 @@ class QueriesMixin(BaseMixin):
         from ..utils import sanitize_rel_type
         safe_type = sanitize_rel_type(rel_type)
         result = self._conn.cypher(
-            f"MATCH (a {{id: '{self._escape(node_id)}'}})-[r:{safe_type}]->(b) "
-            f"RETURN a.id AS source, b.id AS target, r"
+            f"MATCH (a {{id: $id}})-[r:{safe_type}]->(b) "
+            f"RETURN a.id AS source, b.id AS target, r",
+            params={"id": node_id},
         )
         return result.to_list()
 

{graphqlite-0.4.0 → graphqlite-0.4.2}/src/graphqlite/manager.py

@@ -258,9 +258,29 @@ class GraphManager:
         import json
         if params:
             params_json = json.dumps(params)
-            cursor = coord.execute("SELECT cypher(?, ?)", (cypher, params_json))
+            try:
+                cursor = coord.execute("SELECT cypher(?, ?)", (cypher, params_json))
+            except sqlite3.Error as e:
+                err_str = str(e)
+                try:
+                    err_data = json.loads(err_str)
+                    if isinstance(err_data, dict) and "error" in err_data:
+                        raise sqlite3.Error(err_data["error"]) from None
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                raise
         else:
-            cursor = coord.execute("SELECT cypher(?)", (cypher,))
+            try:
+                cursor = coord.execute("SELECT cypher(?)", (cypher,))
+            except sqlite3.Error as e:
+                err_str = str(e)
+                try:
+                    err_data = json.loads(err_str)
+                    if isinstance(err_data, dict) and "error" in err_data:
+                        raise sqlite3.Error(err_data["error"]) from None
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                raise
 
         row = cursor.fetchone()
 
@@ -273,7 +293,7 @@ class GraphManager:
         try:
             data = json.loads(result_str)
         except json.JSONDecodeError:
-            if result_str.startswith("Error"):
+            if result_str.startswith("Error") or result_str.startswith("{\"error\""):
                 raise sqlite3.Error(result_str)
             return CypherResult([{"result": result_str}], ["result"])
 

{graphqlite-0.4.0 → graphqlite-0.4.2/src/graphqlite.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphqlite
-Version: 0.4.0
+Version: 0.4.2
 Summary: SQLite extension for graph queries using Cypher
 Author: GraphQLite Contributors
 License: MIT

{graphqlite-0.4.0 → graphqlite-0.4.2}/tests/test_graph.py

@@ -1492,6 +1492,70 @@ def test_merge_on_match_set_function(g):
     assert result[0]["n.name"] == "UPDATED"
 
 
+def test_merge_with_set_return(g):
+    """Issue #48: MERGE + WITH + SET + RETURN returns column data."""
+    result = g.query("""
+        MERGE (n:MergeWithPy {id: 'mwp1'})
+        WITH n
+        SET n.updated = true
+        RETURN n.id, n.updated
+    """)
+    assert len(result) == 1
+    assert result[0]["n.id"] == "mwp1"
+    assert result[0]["n.updated"] is True
+
+
+def test_merge_with_set_no_return(g):
+    """Issue #48: MERGE + WITH + SET without RETURN succeeds."""
+    g.query("""
+        MERGE (n:MergeWithPy2 {id: 'mwp2'})
+        WITH n
+        SET n.updated = true
+    """)
+    result = g.query("MATCH (n:MergeWithPy2 {id: 'mwp2'}) RETURN n.updated")
+    assert len(result) == 1
+    assert result[0]["n.updated"] is True
+
+
+def test_merge_with_return_no_set(g):
+    """Issue #48: MERGE + WITH + RETURN without SET returns column data."""
+    result = g.query("""
+        MERGE (n:MergeWithPy3 {id: 'mwp3'})
+        WITH n
+        RETURN n.id
+    """)
+    assert len(result) == 1
+    assert result[0]["n.id"] == "mwp3"
+
+
+def test_merge_with_multiple_set(g):
+    """Issue #54: MERGE + WITH + multiple SET clauses all execute."""
+    result = g.query("""
+        MERGE (n:MergeMultiSetPy {id: 'mms1'})
+        WITH n
+        SET n.a = 'one'
+        SET n.b = 'two'
+        RETURN n.a, n.b
+    """)
+    assert len(result) == 1
+    assert result[0]["n.a"] == "one"
+    assert result[0]["n.b"] == "two"
+
+
+def test_merge_with_edge_variable(g):
+    """Issue #54: MERGE relationship + WITH carries edge variable."""
+    g.query("""
+        MERGE (a:EdgeVarPy {id: 'evp1'})-[:KNOWS]->(b:EdgeVarPy {id: 'evp2'})
+    """)
+    result = g.query("""
+        MERGE (a:EdgeVarPy {id: 'evp1'})-[r:KNOWS]->(b:EdgeVarPy {id: 'evp2'})
+        WITH a, r
+        RETURN a.id
+    """)
+    assert len(result) == 1
+    assert result[0]["a.id"] == "evp1"
+
+
 def test_remove_return(g):
     """Test REMOVE + RETURN in a single query."""
     g.query('CREATE (n:RemRetPy {name: "Dave", temp: "delete_me"})')
@@ -1499,3 +1563,157 @@ def test_remove_return(g):
     assert len(result) == 1
     assert result[0]["n.name"] == "Dave"
     assert result[0]["n.temp"] is None
+
+
+# =============================================================================
+# CALL {} Subquery
+# =============================================================================
+
+def test_call_subquery_standalone(g):
+    """Test standalone CALL { MATCH ... RETURN }."""
+    g.connection.cypher('CREATE (:CallPy {name: "Alice"})')
+    g.connection.cypher('CREATE (:CallPy {name: "Bob"})')
+    result = g.query('CALL { MATCH (n:CallPy) RETURN n.name ORDER BY n.name }')
+    assert len(result) == 2
+    assert result[0]["n.name"] == "Alice"
+    assert result[1]["n.name"] == "Bob"
+
+
+def test_call_subquery_with_import(g):
+    """Test CALL with WITH variable import and SET."""
+    g.connection.cypher('CREATE (:CallPyW {name: "Carol"})')
+    g.connection.cypher(
+        'MATCH (n:CallPyW {name: "Carol"}) CALL { WITH n SET n.touched = true }'
+    )
+    result = g.query('MATCH (n:CallPyW) RETURN n.name, n.touched')
+    assert len(result) == 1
+    assert result[0]["n.name"] == "Carol"
+    assert result[0]["n.touched"] is True
+
+
+def test_call_subquery_union(g):
+    """Test CALL with UNION inside."""
+    result = g.query('CALL { RETURN 1 AS n UNION RETURN 2 AS n }')
+    assert len(result) == 2
+    values = sorted([r["n"] for r in result])
+    assert values == [1, 2]
+
+
+# =============================================================================
+# Issue Regression Tests (#34b, #49, #50, #51, #55)
+# =============================================================================
+
+def test_issue_49_unwind_param_create_set(g):
+    """Issue #49: UNWIND $param + CREATE + SET should work."""
+    g.query(
+        'UNWIND $items AS item CREATE (n:Uw49Py) SET n.id = item.id, n.name = item.name',
+        {"items": [{"id": "a", "name": "Alpha"}, {"id": "b", "name": "Beta"}]}
+    )
+    result = g.query('MATCH (n:Uw49Py) RETURN n.id, n.name ORDER BY n.id')
+    assert len(result) == 2
+    assert result[0]["n.id"] == "a"
+    assert result[0]["n.name"] == "Alpha"
+    assert result[1]["n.id"] == "b"
+    assert result[1]["n.name"] == "Beta"
+
+
+def test_issue_49_unwind_param_merge(g):
+    """Issue #49: UNWIND $param + MERGE should iterate per item."""
+    g.query(
+        'UNWIND $items AS item MERGE (n:Uw49MgPy {id: item.id})',
+        {"items": [{"id": "x"}, {"id": "y"}]}
+    )
+    result = g.query('MATCH (n:Uw49MgPy) RETURN n.id ORDER BY n.id')
+    assert len(result) == 2
+    assert result[0]["n.id"] == "x"
+    assert result[1]["n.id"] == "y"
+
+
+def test_issue_49_unwind_literal_set(g):
+    """Issue #49: UNWIND literal + SET should propagate item value."""
+    g.query('UNWIND ["a", "b"] AS item CREATE (n:Uw49LPy) SET n.id = item')
+    result = g.query('MATCH (n:Uw49LPy) RETURN n.id ORDER BY n.id')
+    assert len(result) == 2
+    assert result[0]["n.id"] == "a"
+    assert result[1]["n.id"] == "b"
+
+
+def test_issue_50_startnode_endnode_same_return(g):
+    """Issue #50: startNode(r).name and endNode(r).name in same RETURN should have distinct columns."""
+    g.connection.cypher('CREATE (a:Sn50Py {name: "Alice"})-[:K50Py]->(b:Sn50Py {name: "Bob"})')
+    result = g.query('MATCH ()-[r:K50Py]->() RETURN startNode(r).name, endNode(r).name')
+    assert len(result) == 1
+    row = result[0]
+    # Columns must be distinct — both values present
+    values = list(row.values())
+    assert "Alice" in values
+    assert "Bob" in values
+    assert len(row) == 2  # Two distinct keys, not one
+
+
+def test_issue_51_call_merge_scoping(g):
+    """Issue #51: CALL { WITH c MATCH (d) MERGE (c)-[:REL]->(d) } should link c to d, not self-loop."""
+    g.connection.cypher('CREATE (c:Co51Py {id: "acme"})')
+    g.connection.cypher('CREATE (d:Dep51Py {id: "eng"})')
+    g.connection.cypher(
+        'MATCH (c:Co51Py {id: "acme"}) '
+        'CALL { With c MATCH (d:Dep51Py {id: "eng"}) MERGE (c)-[:HAS51Py]->(d) }'
+    )
+    result = g.query('MATCH (a)-[:HAS51Py]->(b) RETURN a.id, b.id')
+    assert len(result) == 1
+    assert result[0]["a.id"] == "acme"
+    assert result[0]["b.id"] == "eng"  # NOT "acme" (self-loop)
+
+
+def test_issue_34b_optional_match_where_null_row(g):
+    """Issue #34b: OPTIONAL MATCH WHERE filter should preserve null rows."""
+    g.connection.cypher('CREATE (a:P34bPy {id: "alice"})')
+    g.connection.cypher('CREATE (r:Pet34bPy {id: "rex", name: "Rex"})')
+    g.connection.cypher(
+        'MATCH (a:P34bPy {id: "alice"}), (r:Pet34bPy {id: "rex"}) CREATE (a)-[:OWNS34bPy]->(r)'
+    )
+    result = g.query(
+        'MATCH (a:P34bPy {id: "alice"}) '
+        'OPTIONAL MATCH (a)-[:OWNS34bPy]->(r:Pet34bPy) WHERE r.name = "nonexistent" '
+        'RETURN a.id, r.id'
+    )
+    assert len(result) == 1
+    assert result[0]["a.id"] == "alice"
+    assert result[0]["r.id"] is None
+
+
+def test_with_match_merge(g):
+    """MATCH+WITH+MATCH+MERGE should work without errors."""
+    g.connection.cypher('CREATE (a:WmmPy {id: "src"})')
+    g.connection.cypher('CREATE (b:WmmPy {id: "tgt"})')
+    g.connection.cypher(
+        'MATCH (a:WmmPy {id: "src"}) WITH a '
+        'MATCH (b:WmmPy {id: "tgt"}) MERGE (a)-[:LinkPy]->(b)'
+    )
+    result = g.query('MATCH (a)-[:LinkPy]->(b) RETURN a.id, b.id')
+    assert len(result) == 1
+    assert result[0]["a.id"] == "src"
+    assert result[0]["b.id"] == "tgt"
+
+
+def test_functions_in_set(g):
+    """SET n.x = func(n.prop) should resolve node properties in function args."""
+    g.connection.cypher('CREATE (n:FnSetPy {name: "  Hello World  "})')
+    g.connection.cypher('MATCH (n:FnSetPy) SET n.trimmed = trim(n.name)')
+    result = g.query('MATCH (n:FnSetPy) RETURN n.trimmed')
+    assert len(result) == 1
+    assert result[0]["n.trimmed"] == "Hello World"
+
+
+def test_unwind_merge_on_create_set(g):
+    """Batch MERGE with ON CREATE SET from params."""
+    g.query(
+        'UNWIND $items AS item MERGE (n:BatchPy {id: item.id}) ON CREATE SET n.name = item.name',
+        {"items": [{"id": "b1", "name": "First"}, {"id": "b2", "name": "Second"}]}
+    )
+    result = g.query('MATCH (n:BatchPy) RETURN n.id, n.name ORDER BY n.id')
+    assert len(result) == 2
+    assert result[0]["n.id"] == "b1"
+    assert result[0]["n.name"] == "First"
+    assert result[1]["n.id"] == "b2"
+    assert result[1]["n.name"] == "Second"