Added profile and explain

Author: Zhen

neo4j/session.py

@@ -139,7 +139,8 @@ def on_footer(self, metadata):
         """
         self.complete = True
         self.summary = ResultSummary(self.statement, self.parameters,
-                                     metadata.get("type"), metadata.get("stats"))
+                                     metadata.get("type"), metadata.get("stats"),
+                                     metadata.get("plan"), metadata.get("profile"))
         if self.bench_test:
             self.bench_test.end_recv = perf_counter()
 
@@ -181,11 +182,22 @@ class ResultSummary(object):
     #: A set of statistical information held in a :class:`.StatementStatistics` instance.
     statistics = None
 
-    def __init__(self, statement, parameters, statement_type, statistics):
+    #: A :class:`.Plan` instance
+    plan = None
+
+    #: A :class:`.ProfiledPlan` instance
+    profile = None
+
+    def __init__(self, statement, parameters, statement_type, statistics, plan, profile):
         self.statement = statement
         self.parameters = parameters
         self.statement_type = statement_type
         self.statistics = StatementStatistics(statistics or {})
+        if plan is not None:
+            self.plan = Plan(plan)
+        if profile is not None:
+            self.profile = ProfiledPlan(profile)
+            self.plan = self.profile
 
 
 class StatementStatistics(object):
@@ -237,6 +249,45 @@ def __repr__(self):
         return repr(vars(self))
 
 
+class Plan(object):
+    """ This describes how the database will execute your statement.
+    """
+
+    #: The operation name performed by the plan
+    operator_type = None
+
+    #: A list of identifiers used by this plan
+    identifiers = None
+
+    #: A map of arguments used in the specific operation performed by the plan
+    arguments = None
+
+    #: A list of sub plans
+    children = None
+
+    def __init__(self, plan):
+        self.operator_type = plan["operatorType"]
+        self.identifiers = plan.get("identifiers", [])
+        self.arguments = plan.get("args", [])
+        self.children = [Plan(child) for child in plan.get("children", [])]
+
+
+class ProfiledPlan(Plan):
+    """ This describes how the database excuted your statement.
+    """
+
+    #: The number of times this part of the plan touched the underlying data stores
+    db_hits = 0
+
+    #: The number of records this part of the plan produced
+    rows = 0
+
+    def __init__(self, profile):
+        self.db_hits = profile.get("dbHits", 0);
+        self.rows = profile.get("rows", 0);
+        super(ProfiledPlan, self).__init__(profile)
+
+
 class Session(object):
     """ Logical session carried out over an established TCP connection.
     Sessions should generally be constructed using the :meth:`.Driver.session`

test/session_test.py

@@ -25,7 +25,6 @@
 
 
 class RunTestCase(TestCase):
-
     def test_must_use_valid_url_scheme(self):
         try:
             GraphDatabase.driver("x://xxx")
@@ -169,9 +168,38 @@ def test_can_obtain_summary_info(self):
             assert summary.statement_type == "rw"
             assert summary.statistics.nodes_created == 1
 
+    def test_no_plan_info(self):
+        with GraphDatabase.driver("bolt://localhost").session() as session:
+            result = session.run("CREATE (n) RETURN n")
+            assert result.summarize().plan is None
+            assert result.summarize().profile is None
+
+    def test_can_obtain_plan_info(self):
+        with GraphDatabase.driver("bolt://localhost").session() as session:
+            result = session.run("EXPLAIN CREATE (n) RETURN n")
+            plan = result.summarize().plan
+            assert plan.operator_type == "ProduceResults"
+            assert plan.identifiers == ["n"]
+            assert plan.arguments == {"planner": "COST", "EstimatedRows": 1.0, "version": "CYPHER 3.0",
+                                      "KeyNames": "n", "runtime-impl": "INTERPRETED", "planner-impl": "IDP",
+                                      "runtime": "INTERPRETED"}
+            assert len(plan.children) == 1
+
+    def test_can_obtain_profile_info(self):
+        with GraphDatabase.driver("bolt://localhost").session() as session:
+            result = session.run("PROFILE CREATE (n) RETURN n")
+            profile = result.summarize().profile
+            assert profile.db_hits == 0
+            assert profile.rows == 1
+            assert profile.operator_type == "ProduceResults"
+            assert profile.identifiers == ["n"]
+            assert profile.arguments == {"planner": "COST", "EstimatedRows": 1.0, "version": "CYPHER 3.0",
+                                         "KeyNames": "n", "runtime-impl": "INTERPRETED", "planner-impl": "IDP",
+                                         "runtime": "INTERPRETED", "Rows": 1, "DbHits": 0}
+            assert len(profile.children) == 1
 
-class TransactionTestCase(TestCase):
 
+class TransactionTestCase(TestCase):
     def test_can_commit_transaction(self):
         with GraphDatabase.driver("bolt://localhost").session() as session:
             tx = session.new_transaction()
@@ -189,7 +217,7 @@ def test_can_commit_transaction(self):
 
             # Check the property value
             result = session.run("MATCH (a) WHERE id(a) = {n} "
-                                  "RETURN a.foo", {"n": node_id})
+                                 "RETURN a.foo", {"n": node_id})
             foo = result[0][0]
             assert foo == "bar"
 
@@ -210,13 +238,12 @@ def test_can_rollback_transaction(self):
 
             # Check the property value
             result = session.run("MATCH (a) WHERE id(a) = {n} "
-                                  "RETURN a.foo", {"n": node_id})
+                                 "RETURN a.foo", {"n": node_id})
             assert len(result) == 0
 
     def test_can_commit_transaction_using_with_block(self):
         with GraphDatabase.driver("bolt://localhost").session() as session:
             with session.new_transaction() as tx:
-
                 # Create a node
                 result = tx.run("CREATE (a) RETURN id(a)")
                 node_id = result[0][0]
@@ -230,14 +257,13 @@ def test_can_commit_transaction_using_with_block(self):
 
             # Check the property value
             result = session.run("MATCH (a) WHERE id(a) = {n} "
-                                  "RETURN a.foo", {"n": node_id})
+                                 "RETURN a.foo", {"n": node_id})
             foo = result[0][0]
             assert foo == "bar"
 
     def test_can_rollback_transaction_using_with_block(self):
         with GraphDatabase.driver("bolt://localhost").session() as session:
             with session.new_transaction() as tx:
-
                 # Create a node
                 result = tx.run("CREATE (a) RETURN id(a)")
                 node_id = result[0][0]
@@ -249,7 +275,7 @@ def test_can_rollback_transaction_using_with_block(self):
 
             # Check the property value
             result = session.run("MATCH (a) WHERE id(a) = {n} "
-                                  "RETURN a.foo", {"n": node_id})
+                                 "RETURN a.foo", {"n": node_id})
             assert len(result) == 0