Merge pull request #13 from memgraph/T402-FL-rename-execute_query

Rename `execute_query` to `execute`

Author: jbajic

README.md

@@ -41,7 +41,7 @@ When working with the `gqlalchemy`, Python developer can connect to database and
 from gqlalchemy import Memgraph
 
 memgraph = Memgraph("127.0.0.1", 7687)
-memgraph.execute_query("CREATE (:Node)-[:Connection]->(:Node)")
+memgraph.execute("CREATE (:Node)-[:Connection]->(:Node)")
 results = memgraph.execute_and_fetch("""
     MATCH (from:Node)-[:Connection]->(to:Node)
     RETURN from, to;

gqlalchemy/connection.py

@@ -16,7 +16,8 @@
 from typing import Any, Dict, Iterator
 
 import mgclient
-from .models import Node, Relationship, Path
+
+from .models import Node, Path, Relationship
 
 __all__ = ("Connection",)
 
@@ -37,7 +38,7 @@ def __init__(
         self.encrypted = encrypted
 
     @abstractmethod
-    def execute_query(self, query: str) -> None:
+    def execute(self, query: str) -> None:
         """Executes Cypher query without returning any results."""
         pass
 
@@ -71,7 +72,7 @@ def __init__(
         self.lazy = lazy
         self._connection = self._create_connection()
 
-    def execute_query(self, query: str) -> None:
+    def execute(self, query: str) -> None:
         """Executes Cypher query without returning any results."""
         cursor = self._connection.cursor()
         cursor.execute(query)

gqlalchemy/memgraph.py

@@ -16,12 +16,7 @@
 from typing import Any, Dict, Iterator, List, Optional, Union
 
 from .connection import Connection
-from .models import (
-    MemgraphConstraint,
-    MemgraphConstraintExists,
-    MemgraphConstraintUnique,
-    MemgraphIndex,
-)
+from .models import MemgraphConstraint, MemgraphConstraintExists, MemgraphConstraintUnique, MemgraphIndex
 
 __all__ = ("Memgraph",)
 
@@ -62,20 +57,20 @@ def execute_and_fetch(self, query: str, connection: Connection = None) -> Iterat
         connection = connection or self._get_cached_connection()
         return connection.execute_and_fetch(query)
 
-    def execute_query(self, query: str, connection: Connection = None) -> None:
+    def execute(self, query: str, connection: Connection = None) -> None:
         """Executes Cypher query without returning any results."""
         connection = connection or self._get_cached_connection()
-        connection.execute_query(query)
+        connection.execute(query)
 
     def create_index(self, index: MemgraphIndex) -> None:
         """Creates an index (label or label-property type) in the database"""
         query = f"CREATE INDEX ON {index.to_cypher()}"
-        self.execute_query(query)
+        self.execute(query)
 
     def drop_index(self, index: MemgraphIndex) -> None:
         """Drops an index (label or label-property type) in the database"""
         query = f"DROP INDEX ON {index.to_cypher()}"
-        self.execute_query(query)
+        self.execute(query)
 
     def get_indexes(self) -> List[MemgraphIndex]:
         """Returns a list of all database indexes (label and label-property types)"""
@@ -96,12 +91,12 @@ def ensure_indexes(self, indexes: List[MemgraphIndex]) -> None:
     def create_constraint(self, index: MemgraphConstraint) -> None:
         """Creates a constraint (label or label-property type) in the database"""
         query = f"CREATE CONSTRAINT ON {index.to_cypher()}"
-        self.execute_query(query)
+        self.execute(query)
 
     def drop_constraint(self, index: MemgraphConstraint) -> None:
         """Drops a constraint (label or label-property type) in the database"""
         query = f"DROP CONSTRAINT ON {index.to_cypher()}"
-        self.execute_query(query)
+        self.execute(query)
 
     def get_constraints(self) -> List[Union[MemgraphConstraintExists, MemgraphConstraintUnique]]:
         """Returns a list of all database constraints (label and label-property types)"""
@@ -130,7 +125,7 @@ def ensure_constraints(self, constraints: List[Union[MemgraphConstraintExists, M
 
     def drop_database(self):
         """Drops database by removing all nodes and edges"""
-        self.execute_query("MATCH (n) DETACH DELETE n")
+        self.execute("MATCH (n) DETACH DELETE n")
 
     def _get_cached_connection(self) -> Connection:
         """Returns cached connection if it exists, creates it otherwise"""

gqlalchemy/transformations.py

@@ -120,7 +120,7 @@ def _insert_queries(queries: List[str], host: str, port: int, username: str, pas
     while len(queries) > 0:
         try:
             query = queries.pop()
-            memgraph.execute_query(query)
+            memgraph.execute(query)
         except mgclient.DatabaseError as e:
             queries.append(query)
             logging.getLogger(__file__).warning(f"Ignoring database error: {e}")

tests/conftest.py

@@ -39,7 +39,7 @@ def populated_memgraph(dataset_file: str) -> Memgraph:
     memgraph.drop_database()
     with get_data_dir().joinpath(dataset_file).open("r") as dataset:
         for query in dataset:
-            memgraph.execute_query(query)
+            memgraph.execute(query)
 
     yield memgraph
 

tests/intergration/test_networkx.py

@@ -49,7 +49,7 @@ def test_simple_nx_to_memgraph(memgraph: Memgraph):
     graph.add_edges_from([(1, 2), (1, 3)])
 
     for query in nx_to_cypher(graph):
-        memgraph.execute_query(query)
+        memgraph.execute(query)
 
     actual_nodes = list(memgraph.execute_and_fetch("MATCH (n) RETURN n ORDER BY n.id"))
     assert len(actual_nodes) == 3
@@ -80,7 +80,7 @@ def test_simple_index_nx_to_memgraph(memgraph: Memgraph):
     }
 
     for query in nx_to_cypher(graph, True):
-        memgraph.execute_query(query)
+        memgraph.execute(query)
     actual_indexes = set(memgraph.get_indexes())
 
     assert actual_indexes == expected_indexes
@@ -98,7 +98,7 @@ def test_nx_to_memgraph(memgraph: Memgraph):
     graph.add_edges_from(expected_edges)
 
     for query in nx_to_cypher(graph):
-        memgraph.execute_query(query)
+        memgraph.execute(query)
 
     actual_nodes = list(memgraph.execute_and_fetch("MATCH (n) RETURN n ORDER BY n.id"))
     assert len(actual_nodes) == 3
@@ -123,14 +123,14 @@ def test_big_nx_to_memgraph_with_manual_index(memgraph: Memgraph, random_nx_grap
     memgraph.create_index(MemgraphIndex("Label", "id"))
 
     for query in nx_to_cypher(random_nx_graph):
-        memgraph.execute_query(query)
+        memgraph.execute(query)
 
 
 @pytest.mark.timeout(60)
 @pytest.mark.slow
 def test_big_nx_to_memgraph(memgraph: Memgraph, random_nx_graph: nx.Graph):
     for query in nx_to_cypher(random_nx_graph, create_index=True):
-        memgraph.execute_query(query)
+        memgraph.execute(query)
 
 
 @pytest.mark.timeout(240)