Add class diagram for Intepreter to docs

Summary:
This is a short update which should explain the primary entrypoint to
query parsing and execution.

Reviewers: mtomic, llugovic

Reviewed By: mtomic

Subscribers: pullbot

Differential Revision: https://phabricator.memgraph.io/D1856

docs/dev/query/build-html

@@ -9,3 +9,8 @@ for markdown_file in $(find $script_dir -name '*.md'); do
   sed -e 's/.md/.html/' $markdown_file | \
     pandoc -s -f markdown -t html -o $script_dir/html/$name.html
 done
+
+for dot_file in $(find $script_dir -name '*.dot'); do
+  name=$(basename -s .dot $dot_file)
+  dot -Tpng $dot_file -o $script_dir/html/$name.png
+done

docs/dev/query/contents.md

@@ -12,3 +12,23 @@ following phases:
   3.  [Semantic Analysis and Symbol Generation](semantic.md)
   4.  [Logical Planning](planning.md)
   5.  [Logical Plan Execution](execution.md)
+
+The main entry point is `Interpreter::operator()`, which takes a query text
+string and produces a `Results` object. To instantiate the object,
+`Interpreter` needs to perform the above steps from 1 to 4. If any of the
+steps fail, a `QueryException` is thrown. The complete `LogicalPlan` is
+wrapped into a `CachedPlan` and stored for reuse. This way we can skip the
+whole process of analysing a query if it appears to be the same as before.
+
+When we have valid plan, the client code can invoke `Results::PullAll` with a
+stream object. The `Results` instance will then execute the plan and fill the
+stream with the obtained results.
+
+Since we want to optionally run Memgraph as a distributed database, we have
+hooks for creating a different plan of logical operators.
+`DistributedInterpreter` inherits from `Interpreter` and overrides
+`MakeLogicalPlan` method. This method needs to return a concrete instance of
+`LogicalPlan`, and in case of distributed database that will be
+`DistributedLogicalPlan`.
+
+![Intepreter Class Diagram](interpreter-class.png)

docs/dev/query/interpreter-class.dot

@@ -0,0 +1,23 @@
+digraph interpreter {
+  node [fontname="dejavusansmono"]
+  edge [fontname="dejavusansmono"]
+  node [shape=record]
+  edge [dir=back,arrowtail=empty,arrowsize=1.5]
+  Interpreter [label="{\N|+ operator(query : string, ...) : Results\l|
+                      # MakeLogicalPlan(...) : LogicalPlan\l|
+                      - plan_cache_ : Map(QueryHash, CachedPlan)\l}"]
+  Interpreter -> DistributedInterpreter
+  Results [label="{\N|+ PullAll(stream) : void\l|- plan_ : CachedPlan\l}"]
+  Interpreter -> Results
+    [dir=forward,style=dashed,arrowhead=open,label="<<create>>"]
+  CachedPlan -> Results
+    [dir=forward,arrowhead=odiamond,taillabel="1",headlabel="*"]
+  Interpreter -> CachedPlan [arrowtail=diamond,taillabel="1",headlabel="*"]
+  CachedPlan -> LogicalPlan [arrowtail=diamond]
+  LogicalPlan [label="{\N|+ GetRoot() : LogicalOperator
+                      \l+ GetCost() : double\l}"]
+  LogicalPlan -> SingleNodeLogicalPlan [style=dashed]
+  LogicalPlan -> DistributedLogicalPlan [style=dashed]
+  DistributedInterpreter -> DistributedLogicalPlan
+    [dir=forward,style=dashed,arrowhead=open,label="<<create>>"]
+}