the data is not parsed any more (#400)

Author: martin-neotech

neo4j/__init__.py

@@ -50,10 +50,6 @@
     "Result",
     "ResultSummary",
     "SummaryCounters",
-    "Plan",
-    "ProfiledPlan",
-    "Notification",
-    "Position",
     "Query",
     "Session",
     "unit_of_work",
@@ -111,10 +107,6 @@
 from neo4j.work.summary import (
     ResultSummary,
     SummaryCounters,
-    Plan,
-    ProfiledPlan,
-    Notification,
-    Position,
 )
 
 

neo4j/work/summary.py

@@ -45,16 +45,16 @@ class ResultSummary:
     #: Dictionary of parameters passed with the statement.
     parameters = None
 
-    #: The type of query (``'r'`` = read-only, ``'rw'`` = read/write).
+    #: A string that describes the type of query (``'r'`` = read-only, ``'rw'`` = read/write).
     query_type = None
 
-    #: A :class:`.Counters` instance. Counters for operations the query triggered.
+    #: A :class:`neo4j.SummaryCounters` instance. Counters for operations the query triggered.
     counters = None
 
-    #: A :class:`.Plan` instance. This describes how the database will execute the query.
+    #: Dictionary that describes how the database will execute the query.
     plan = None
 
-    #: A :class:`.ProfiledPlan` instance
+    #: Dictionary that describes how the database executed the query.
     profile = None
 
     #: The time it took for the server to have the result available. (milliseconds)
@@ -63,7 +63,7 @@ class ResultSummary:
     #: The time it took for the server to consume the result. (milliseconds)
     result_consumed_after = None
 
-    #: A list of :class: `.Notification` instances
+    #: A list of Dictionaries containing notification information.
     #: Notifications provide extra information for a user executing a statement.
     #: They can be warnings about problematic queries or other valuable information that can be
     #: presented in a client.
@@ -77,25 +77,16 @@ def __init__(self, **metadata):
         self.query = metadata.get("query")
         self.parameters = metadata.get("parameters")
         self.query_type = metadata.get("type")
+        self.plan = metadata.get("plan")
+        self.profile = metadata.get("profile")
+        self.notifications = metadata.get("notifications")
         self.counters = SummaryCounters(metadata.get("stats", {}))
         if self.server.protocol_version[0] < BOLT_VERSION_3:
             self.result_available_after = metadata.get("result_available_after")
             self.result_consumed_after = metadata.get("result_consumed_after")
         else:
             self.result_available_after = metadata.get("t_first")
             self.result_consumed_after = metadata.get("t_last")
-        if "plan" in metadata:
-            self.plan = _make_plan(metadata["plan"])
-        if "profile" in metadata:
-            self.profile = _make_plan(metadata["profile"])
-            self.plan = self.profile
-        self.notifications = []
-        for notification in metadata.get("notifications", []):
-            position = notification.get("position")
-            if position is not None:
-                position = Position(position["offset"], position["line"], position["column"])
-            self.notifications.append(Notification(notification["code"], notification["title"],
-                                                   notification["description"], notification["severity"], position))
 
 
 class SummaryCounters:
@@ -159,68 +150,3 @@ def contains_updates(self):
     def contains_system_updates(self):
         """True if the system database was updated, otherwise False."""
         return self.system_updates > 0
-
-
-#: A plan describes how the database will execute your statement.
-#:
-#: operator_type:
-#:   the name of the operation performed by the plan
-#: identifiers:
-#:   the list of identifiers used by this plan
-#: arguments:
-#:   a dictionary of arguments used in the specific operation performed by the plan
-#: children:
-#:   a list of sub-plans
-Plan = namedtuple("Plan", ("operator_type", "identifiers", "arguments", "children"))
-
-#: A profiled plan describes how the database executed your statement.
-#:
-#: db_hits:
-#:   the number of times this part of the plan touched the underlying data stores
-#: rows:
-#:   the number of records this part of the plan produced
-ProfiledPlan = namedtuple("ProfiledPlan", Plan._fields + ("db_hits", "rows"))
-
-#: Representation for notifications found when executing a statement. A
-#: notification can be visualized in a client pinpointing problems or
-#: other information about the statement.
-#:
-#: code:
-#:   a notification code for the discovered issue.
-#: title:
-#:   a short summary of the notification
-#: description:
-#:   a long description of the notification
-#: severity:
-#:   the severity level of the notification
-#: position:
-#:   the position in the statement where this notification points to, if relevant.
-Notification = namedtuple("Notification", ("code", "title", "description", "severity", "position"))
-
-#: A position within a statement, consisting of offset, line and column.
-#:
-#: offset:
-#:   the character offset referred to by this position; offset numbers start at 0
-#: line:
-#:   the line number referred to by the position; line numbers start at 1
-#: column:
-#:   the column number referred to by the position; column numbers start at 1
-Position = namedtuple("Position", ("offset", "line", "column"))
-
-
-def _make_plan(plan_dict):
-    """ Construct a Plan or ProfiledPlan from a dictionary of metadata values.
-
-    :param plan_dict:
-    :return:
-    """
-    operator_type = plan_dict["operatorType"]
-    identifiers = plan_dict.get("identifiers", [])
-    arguments = plan_dict.get("args", [])
-    children = [_make_plan(child) for child in plan_dict.get("children", [])]
-    if "dbHits" in plan_dict or "rows" in plan_dict:
-        db_hits = plan_dict.get("dbHits", 0)
-        rows = plan_dict.get("rows", 0)
-        return ProfiledPlan(operator_type, identifiers, arguments, children, db_hits, rows)
-    else:
-        return Plan(operator_type, identifiers, arguments, children)

tests/integration/test_summary.py

@@ -23,10 +23,6 @@
 from neo4j import (
     ResultSummary,
     SummaryCounters,
-    Plan,
-    ProfiledPlan,
-    Notification,
-    Position,
     GraphDatabase,
 )
 from neo4j.exceptions import (
@@ -37,12 +33,6 @@
 )
 
 
-def get_operator_type(op):
-    # Fabric will suffix with db name, remove this to handle fabric on/off
-    op = op.split("@")
-    return op[0]
-
-
 def test_can_obtain_summary_after_consuming_result(session):
     # python -m pytest tests/integration/test_summary.py -s -v -k test_can_obtain_summary_after_consuming_result
 
@@ -62,30 +52,24 @@ def test_no_plan_info(session):
 
 
 def test_can_obtain_plan_info(session):
+    # python -m pytest tests/integration/test_summary.py -s -v -k test_can_obtain_plan_info
     result = session.run("EXPLAIN CREATE (n) RETURN n")
     summary = result.consume()
-    plan = summary.plan
-    assert get_operator_type(plan.operator_type) == "ProduceResults"
-    assert plan.identifiers == ["n"]
-    assert len(plan.children) == 1
+    assert isinstance(summary.plan, dict)
 
 
 def test_can_obtain_profile_info(session):
+    # python -m pytest tests/integration/test_summary.py -s -v -k test_can_obtain_profile_info
     result = session.run("PROFILE CREATE (n) RETURN n")
     summary = result.consume()
-    profile = summary.profile
-    assert profile.db_hits == 0
-    assert profile.rows == 1
-    assert get_operator_type(profile.operator_type) == "ProduceResults"
-    assert profile.identifiers == ["n"]
-    assert len(profile.children) == 1
+    assert isinstance(summary.profile, dict)
 
 
 def test_no_notification_info(session):
+    # python -m pytest tests/integration/test_summary.py -s -v -k test_no_notification_info
     result = session.run("CREATE (n) RETURN n")
     summary = result.consume()
-    notifications = summary.notifications
-    assert notifications == []
+    assert summary.notifications is None
 
 
 def test_can_obtain_notification_info(session):
@@ -97,14 +81,7 @@ def test_can_obtain_notification_info(session):
     notifications = summary.notifications
     assert isinstance(notifications, list)
     assert len(notifications) == 1
-
-    notification = notifications[0]
-    assert isinstance(notification, Notification)
-    assert notification.code.startswith("Neo.ClientNotification")           # "Neo.ClientNotification.Statement.CartesianProductWarning"
-    assert isinstance(notification.title, str)                              # "This query builds a cartesian product between disconnected patterns."
-    assert isinstance(notification.severity, str)                           # "WARNING"
-    assert isinstance(notification.description, str)
-    assert isinstance(notification.position, Position)
+    assert isinstance(notifications[0], dict)
 
 
 def test_contains_time_information(session):