maintain graph version

Author: swilly22

redisgraph/exceptions.py

@@ -0,0 +1,4 @@
+class VersionMismatchException(Exception):
+    def __init__(self, version):
+        self.version = version
+

redisgraph/graph.py

@@ -1,5 +1,6 @@
 from .util import *
 from .query_result import QueryResult
+from .exceptions import VersionMismatchException
 
 class Graph(object):
     """
@@ -11,7 +12,7 @@ def __init__(self, name, redis_con):
         Create a new graph.
         """
         self.name = name             # Graph key
-        self.version = None          # Graph version
+        self.version = 0             # Graph version
         self.redis_con = redis_con
         self.nodes = {}
         self.edges = []
@@ -143,16 +144,37 @@ def query(self, q, params=None, timeout=None):
         """
         Executes a query against the graph.
         """
+
+        # maintain original 'q'
+        query = q
+
+        # handle query parameters
         if params is not None:
-            q = self.build_params_header(params) + q
+            query = self.build_params_header(params) + query
+
+        # construct query command
+        # ask for compact result-set format
+        # specify known version
+        command = ["GRAPH.QUERY", self.name, query, "--compact", "version", self.version]
 
-        command = ["GRAPH.QUERY", self.name, q, "--compact"]
+        # include timeout is specified
         if timeout:
             if not isinstance(timeout, int):
                 raise Exception("Timeout argument must be a positive integer")
             command += ["timeout", timeout]
+
+        # issue query
         response = self.redis_con.execute_command(*command)
-        return QueryResult(self, response)
+
+        try:
+            return QueryResult(self, response)
+        except VersionMismatchException as e:
+            # client view over the graph schema is out of sync
+            # set client version and refresh local schema
+            self.version = e.version
+            self._refresh_schema()
+            # re-issue query
+            return self.query(q, params, timeout)
 
     def _execution_plan_to_string(self, plan):
         return "\n".join(plan)

redisgraph/query_result.py

@@ -1,6 +1,7 @@
 from .node import Node
 from .edge import Edge
 from .path import Path
+from .exceptions import VersionMismatchException
 from prettytable import PrettyTable
 from redis import ResponseError
 
@@ -14,11 +15,10 @@
 INDICES_DELETED = "Indices deleted"
 CACHED_EXECUTION = "Cached execution"
 INTERNAL_EXECUTION_TIME = 'internal execution time'
-GRAPH_VERSION = 'Graph version'
 
 STATS = [LABELS_ADDED, NODES_CREATED, PROPERTIES_SET, RELATIONSHIPS_CREATED,
         NODES_DELETED, RELATIONSHIPS_DELETED, INDICES_CREATED, INDICES_DELETED,
-        CACHED_EXECUTION, INTERNAL_EXECUTION_TIME, GRAPH_VERSION]
+        CACHED_EXECUTION, INTERNAL_EXECUTION_TIME]
 
 class ResultSetColumnTypes(object):
     COLUMN_UNKNOWN = 0
@@ -45,24 +45,27 @@ def __init__(self, graph, response):
         self.header = []
         self.result_set = []
 
-        # If we encountered a run-time error, the last response element will be an exception.
-        if isinstance(response[-1], ResponseError):
-            raise response[-1]
+        # incase of an error an exception will be raised
+        self._check_for_errors(response)
 
         if len(response) == 1:
             self.parse_statistics(response[0])
         else:
-            # start by parsing statistics, see if the reported graph version
-            # matches the one we have
+            # start by parsing statistics, matches the one we have
             self.parse_statistics(response[-1])  # Last element.
+            self.parse_results(response)
 
-            if(graph.version != self.graph_version):
-                # graph version miss-match, this is an indication that
-                # the graph schema was modified, sync it.
-                graph.version = self.graph_version
-                graph._refresh_schema()
+    def _check_for_errors(self, response):
+        if isinstance(response[0], ResponseError):
+            error = response[0]
+            if str(error) == "version mismatch":
+                version = response[1]
+                error = VersionMismatchException(version)
+            raise error
 
-            self.parse_results(response)
+        # If we encountered a run-time error, the last response element will be an exception.
+        if isinstance(response[-1], ResponseError):
+            raise response[-1]
 
     def parse_results(self, raw_result_set):
         self.header = self.parse_header(raw_result_set)
@@ -286,7 +289,3 @@ def cached_execution(self):
     def run_time_ms(self):
         return self._get_stat(INTERNAL_EXECUTION_TIME)
 
-    @property
-    def graph_version(self):
-        return self._get_stat(GRAPH_VERSION)
-