Prepare release v0.12.0

Reviewers: buda, teon.banek

Subscribers: pullbot

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

.arcconfig

@@ -0,0 +1,7 @@
+{
+  "project_id" : "memgraph",
+  "conduit_uri" : "https://phabricator.memgraph.io",
+  "phabricator_uri" : "https://phabricator.memgraph.io",
+  "git.default-relative-commit": "origin/master",
+  "arc.land.onto.default": "master"
+}

.clang-format

@@ -1,10 +1,9 @@
 ---
 Language:     Cpp
 BasedOnStyle: Google
-Standard:     "c++20"
+Standard:     "C++11"
 UseTab:       Never
 DerivePointerAlignment: false
 PointerAlignment: Right
-ColumnLimit : 120
-IncludeBlocks: Preserve
+ColumnLimit : 80
 ...

.clang-tidy

@@ -1,82 +0,0 @@
----
-Checks: '*,
-         -android-*,
-         -cert-err58-cpp,
-         -cppcoreguidelines-avoid-c-arrays,
-         -cppcoreguidelines-avoid-goto,
-         -cppcoreguidelines-avoid-magic-numbers,
-         -cppcoreguidelines-no-malloc,
-         -cppcoreguidelines-non-private-member-variables-in-classes,
-         -cppcoreguidelines-owning-memory,
-         -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
-         -cppcoreguidelines-pro-bounds-constant-array-index,
-         -cppcoreguidelines-pro-bounds-pointer-arithmetic,
-         -cppcoreguidelines-pro-type-member-init,
-         -cppcoreguidelines-pro-type-reinterpret-cast,
-         -cppcoreguidelines-pro-type-static-cast-downcast,
-         -cppcoreguidelines-pro-type-union-access,
-         -cppcoreguidelines-pro-type-vararg,
-         -cppcoreguidelines-special-member-functions,
-         -fuchsia-default-arguments,
-         -fuchsia-default-arguments-calls,
-         -fuchsia-default-arguments-declarations,
-         -fuchsia-overloaded-operator,
-         -fuchsia-statically-constructed-objects,
-         -fuchsia-trailing-return,
-         -fuchsia-virtual-inheritance,
-         -google-explicit-constructor,
-         -google-readability-*,
-         -hicpp-avoid-c-arrays,
-         -hicpp-avoid-goto,
-         -hicpp-braces-around-statements,
-         -hicpp-member-init,
-         -hicpp-no-array-decay,
-         -hicpp-no-assembler,
-         -hicpp-no-malloc,
-         -hicpp-use-equals-default,
-         -hicpp-vararg,
-         -llvm-header-guard,
-         -llvmlibc-callee-namespace,
-         -llvmlibc-implementation-in-namespace,
-         -llvmlibc-restrict-system-libc-headers,
-         -misc-non-private-member-variables-in-classes,
-         -misc-unused-parameters,
-         -modernize-avoid-c-arrays,
-         -modernize-concat-nested-namespaces,
-         -modernize-pass-by-value,
-         -modernize-use-equals-default,
-         -modernize-use-nodiscard,
-         -modernize-use-trailing-return-type,
-         -performance-unnecessary-value-param,
-         -readability-braces-around-statements,
-         -readability-else-after-return,
-         -readability-implicit-bool-conversion,
-         -readability-magic-numbers,
-         -readability-named-parameter'
-WarningsAsErrors: ''
-HeaderFilterRegex: 'src/.*'
-AnalyzeTemporaryDtors: false
-FormatStyle:     none
-CheckOptions:
-  - key:             google-readability-braces-around-statements.ShortStatementLines
-    value:           '1'
-  - key:             google-readability-function-size.StatementThreshold
-    value:           '800'
-  - key:             google-readability-namespace-comments.ShortNamespaceLines
-    value:           '10'
-  - key:             google-readability-namespace-comments.SpacesBeforeComments
-    value:           '2'
-  - key:             modernize-loop-convert.MaxCopySize
-    value:           '16'
-  - key:             modernize-loop-convert.MinConfidence
-    value:           reasonable
-  - key:             modernize-loop-convert.NamingStyle
-    value:           CamelCase
-  - key:             modernize-pass-by-value.IncludeStyle
-    value:           llvm
-  - key:             modernize-replace-auto-ptr.IncludeStyle
-    value:           llvm
-  - key:             modernize-use-nullptr.NullMacros
-    value:           'NULL'
-...
-

.githooks/pre-commit

@@ -1,35 +0,0 @@
-#!/bin/sh
-
-project_folder=$(git rev-parse --show-toplevel)
-if git rev-parse --verify HEAD >/dev/null 2>&1
-then
-	against=HEAD
-else
-	# Initial commit: diff against an empty tree object
-	against=$(git hash-object -t tree /dev/null)
-fi
-
-# Redirect output to stderr.
-exec 1>&2
-
-tmpdir=$(mktemp -d repo-XXXXXXXX)
-trap "rm -rf $tmpdir" EXIT INT
-
-modified_files=$(git diff --cached --name-only --diff-filter=AM $against | sed -nE "/.*\.(cpp|cc|cxx|c|h|hpp)$/p")
-for file in $modified_files; do
-  echo "Checking $file..."
-
-  cp $project_folder/.clang-format $project_folder/.clang-tidy $tmpdir
-
-  git checkout-index --prefix="$tmpdir/" -- $file
-
-  echo "Running clang-format..."
-  $project_folder/tools/git-clang-format $tmpdir/$file
-  code=$?
-
-  if [ $code -ne 0 ]; then
-    break
-  fi
-done;
-
-return $code

.github/workflows/diff.yaml

@@ -1,403 +0,0 @@
-name: Diff
-
-on:
-  push:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-      - '.clang-*'
-
-jobs:
-  community_build:
-    name: "Community build"
-    runs-on: [self-hosted, Linux, X64, Diff]
-    env:
-      THREADS: 24
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build community binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build community binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=release -DMG_ENTERPRISE=OFF ..
-          make -j$THREADS
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__unit --output-on-failure -j$THREADS
-
-      - name: Run stress test
-        run: |
-          cd tests/stress
-          ./continuous_integration
-
-      - name: Create community DEB package
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Create community DEB package.
-          cd build
-          mkdir output && cd output
-          cpack -G DEB --config ../CPackConfig.cmake
-
-      - name: Save community DEB package
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Community DEB package"
-          path: build/output/memgraph*.deb
-
-  code_analysis:
-    name: "Code analysis"
-    runs-on: [self-hosted, Linux, X64, Diff]
-    env:
-      THREADS: 24
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build combined ASAN, UBSAN and coverage binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          cd build
-          cmake -DTEST_COVERAGE=ON -DASAN=ON -DUBSAN=ON ..
-          make -j$THREADS memgraph__unit
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run unit tests. It is restricted to 2 threads intentionally, because higher concurrency makes the timing related tests unstable.
-          cd build
-          LSAN_OPTIONS=suppressions=$PWD/../tools/lsan.supp UBSAN_OPTIONS=halt_on_error=1 ctest -R memgraph__unit --output-on-failure -j2
-
-      - name: Compute code coverage
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Compute code coverage.
-          cd tools/github
-          ./coverage_convert
-
-          # Package code coverage.
-          cd generated
-          tar -czf code_coverage.tar.gz coverage.json html report.json summary.rmu
-
-      - name: Save code coverage
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Code coverage"
-          path: tools/github/generated/code_coverage.tar.gz
-
-      - name: Run clang-tidy
-        run: |
-          source /opt/toolchain-v2/activate
-
-          # Restrict clang-tidy results only to the modified parts
-          git diff -U0 master... -- src ':!*.hpp' | ./tools/github/clang-tidy/clang-tidy-diff.py -p 1 -j $THREADS -path build | tee ./build/clang_tidy_output.txt
-
-          # Fail if any warning is reported
-          ! cat ./build/clang_tidy_output.txt | ./tools/github/clang-tidy/grep_error_lines.sh > /dev/null
-
-  debug_build:
-    name: "Debug build"
-    runs-on: [self-hosted, Linux, X64, Diff]
-    env:
-      THREADS: 24
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build debug binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build debug binaries.
-          cd build
-          cmake ..
-          make -j$THREADS
-
-      - name: Run leftover CTest tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run leftover CTest tests (all except unit and benchmark tests).
-          cd build
-          ctest -E "(memgraph__unit|memgraph__benchmark)" --output-on-failure
-
-      - name: Run drivers tests
-        run: |
-          ./tests/drivers/run.sh
-
-      - name: Run integration tests
-        run: |
-          cd tests/integration
-          for name in *; do
-            if [ ! -d $name ]; then continue; fi
-            pushd $name >/dev/null
-            echo "Running: $name"
-            if [ -x prepare.sh ]; then
-              ./prepare.sh
-            fi
-            if [ -x runner.py ]; then
-              ./runner.py
-            elif [ -x runner.sh ]; then
-              ./runner.sh
-            fi
-            echo
-            popd >/dev/null
-          done
-
-      - name: Run cppcheck and clang-format
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run cppcheck and clang-format.
-          cd tools/github
-          ./cppcheck_and_clang_format diff
-
-      - name: Save cppcheck and clang-format errors
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Code coverage"
-          path: tools/github/cppcheck_and_clang_format.txt
-
-  release_build:
-    name: "Release build"
-    runs-on: [self-hosted, Linux, X64, Diff]
-    env:
-      THREADS: 24
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=release ..
-          make -j$THREADS
-
-      - name: Run GQL Behave tests
-        run: |
-          cd tests/gql_behave
-          ./continuous_integration
-
-      - name: Save quality assurance status
-        uses: actions/upload-artifact@v2
-        with:
-          name: "GQL Behave Status"
-          path: |
-            tests/gql_behave/gql_behave_status.csv
-            tests/gql_behave/gql_behave_status.html
-
-      - name: Run e2e replication tests
-        run: |
-          # TODO(gitbuda): Setup mgclient and pymgclient properly.
-          cd tests
-          ./setup.sh
-          source ve3/bin/activate
-          cd e2e
-          LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../../libs/mgclient/lib python runner.py --workloads-path replication/workloads.yaml
-
-      - name: Run e2e memory control tests
-        run: |
-          cd tests
-          ./setup.sh
-          source ve3/bin/activate
-          cd e2e
-          LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../../libs/mgclient/lib python runner.py --workloads-path memory/workloads.yaml
-
-      - name: Run stress test (plain)
-        run: |
-          cd tests/stress
-          ./continuous_integration
-
-      - name: Run stress test (SSL)
-        run: |
-          cd tests/stress
-          ./continuous_integration --use-ssl
-
-      - name: Run durability test
-        run: |
-          cd tests/stress
-          source ve3/bin/activate
-          python3 durability --num-steps 5
-
-      - name: Create enterprise DEB package
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Create enterprise DEB package.
-          cd build
-          mkdir output && cd output
-          cpack -G DEB --config ../CPackConfig.cmake
-
-      - name: Save enterprise DEB package
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Enterprise DEB package"
-          path: build/output/memgraph*.deb
-
-      - name: Save test data
-        uses: actions/upload-artifact@v2
-        if: always()
-        with:
-          name: "Test data"
-          path: |
-            # multiple paths could be defined
-            build/logs
-
-  release_jepsen_test:
-    name: "Release Jepsen Test"
-    runs-on: [self-hosted, Linux, X64, Debian10, JepsenControl]
-    #continue-on-error: true
-    env:
-      THREADS: 24
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build only memgraph release binarie.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=release ..
-          make -j$THREADS memgraph
-
-      - name: Run Jepsen tests
-        run: |
-          cd tests/jepsen
-          ./run.sh test --binary ../../build/memgraph --run-args "test-all --node-configs resources/node-config.edn" --ignore-run-stdout-logs --ignore-run-stderr-logs
-
-      - name: Save Jepsen report
-        uses: actions/upload-artifact@v2
-        if: ${{ always() }}
-        with:
-          name: "Jepsen Report"
-          path: tests/jepsen/Jepsen.tar.gz
-
-  release_benchmarks:
-    name: "Release benchmarks"
-    runs-on: [self-hosted, Linux, X64, Diff, Gen7]
-    env:
-      THREADS: 24
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build only memgraph release binarie.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=release ..
-          make -j$THREADS
-
-      - name: Run macro benchmarks
-        run: |
-          cd tests/macro_benchmark
-          ./harness QuerySuite MemgraphRunner \
-            --groups aggregation 1000_create unwind_create dense_expand match \
-            --no-strict
-
-      - name: Upload macro benchmark results
-        run: |
-          cd tools/bench-graph-client
-          virtualenv -p python3 ve3
-          source ve3/bin/activate
-          pip install -r requirements.txt
-          ./main.py --benchmark-name "macro_benchmark" \
-                    --benchmark-results-path "../../tests/macro_benchmark/.harness_summary" \
-                    --github-run-id "${{ github.run_id }}" \
-                    --github-run-number "${{ github.run_number }}"
-
-      - name: Run mgbench
-        run: |
-          cd tests/mgbench
-          ./benchmark.py --num-workers-for-benchmark 12 --export-results benchmark_result.json pokec/medium/*/*
-
-      - name: Upload mgbench results
-        run: |
-          cd tools/bench-graph-client
-          virtualenv -p python3 ve3
-          source ve3/bin/activate
-          pip install -r requirements.txt
-          ./main.py --benchmark-name "mgbench" \
-                    --benchmark-results-path "../../tests/mgbench/benchmark_result.json" \
-                    --github-run-id "${{ github.run_id }}" \
-                    --github-run-number "${{ github.run_number }}"

.github/workflows/full_clang_tidy.yaml

@@ -1,44 +0,0 @@
-name: Run clang-tidy on the full codebase
-
-on:
-  workflow_dispatch:
-
-jobs:
-  clang_tidy_check:
-    name: "Clang-tidy check"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    env:
-      THREADS: 24
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build debug binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build debug binaries.
-
-          cd build
-          cmake ..
-          make -j$THREADS
-
-      - name: Run clang-tidy
-        run: |
-          source /opt/toolchain-v2/activate
-
-          # The results are also written to standard output in order to retain them in the logs
-          ./tools/github/clang-tidy/run-clang-tidy.py -p build -j $THREADS -clang-tidy-binary=/opt/toolchain-v2/bin/clang-tidy "$PWD/src/*" |
-            tee ./build/full_clang_tidy_output.txt
-
-      - name: Summarize clang-tidy results
-        run: cat ./build/full_clang_tidy_output.txt | ./tools/github/clang-tidy/count_errors.sh

.github/workflows/package_all.yaml

@@ -1,248 +0,0 @@
-name: Package All
-
-# TODO(gitbuda): Cleanup docker container if GHA job was canceled.
-
-on: workflow_dispatch
-
-jobs:
-  centos-7_community:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package community centos-7
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: centos-7_community
-          path: build/output/centos-7/memgraph*.rpm
-
-  centos-8_community:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package community centos-8
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: centos-8_community
-          path: build/output/centos-8/memgraph*.rpm
-
-  debian-9_community:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package community debian-9
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: debian-9_community
-          path: build/output/debian-9/memgraph*.deb
-
-  debian-10_community:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package community debian-10
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: debian-10_community
-          path: build/output/debian-10/memgraph*.deb
-
-  docker_community:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          cd release/package
-          ./run.sh package community debian-10 --for-docker
-          ./run.sh docker
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: docker_community
-          path: build/output/docker/memgraph*.tar.gz
-
-  ubuntu-1804_community:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package community ubuntu-18.04
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: ubuntu-1804_community
-          path: build/output/ubuntu-18.04/memgraph*.deb
-
-  ubuntu-2004_community:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package community ubuntu-20.04
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: ubuntu-2004_community
-          path: build/output/ubuntu-20.04/memgraph*.deb
-
-  centos-7_enterprise:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package enterprise centos-7
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: centos-7_enterprise
-          path: build/output/centos-7/memgraph*.rpm
-
-  centos-8_enterprise:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package enterprise centos-8
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: centos-8_enterprise
-          path: build/output/centos-8/memgraph*.rpm
-
-  debian-9_enterprise:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package enterprise debian-9
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: debian-9_enterprise
-          path: build/output/debian-9/memgraph*.deb
-
-  debian-10_enterprise:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package enterprise debian-10
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: debian-10_enterprise
-          path: build/output/debian-10/memgraph*.deb
-
-  docker_enterprise:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          cd release/package
-          ./run.sh package enterprise debian-10 --for-docker
-          ./run.sh docker
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: docker_enterprise
-          path: build/output/docker/memgraph*.tar.gz
-
-  ubuntu-1804_enterprise:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package enterprise ubuntu-18.04
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: ubuntu-1804_enterprise
-          path: build/output/ubuntu-18.04/memgraph*.deb
-
-  ubuntu-2004_enterprise:
-    runs-on: [self-hosted, DockerMgBuild]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v2
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package enterprise ubuntu-20.04
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: ubuntu-2004_enterprise
-          path: build/output/ubuntu-20.04/memgraph*.deb

.github/workflows/release_centos8.yaml

@@ -1,328 +0,0 @@
-name: Release CentOS 8
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: "0 1 * * *"
-
-jobs:
-  community_build:
-    name: "Community build"
-    runs-on: [self-hosted, Linux, X64, CentOS8]
-    env:
-      THREADS: 24
-    timeout-minutes: 960
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build community binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build community binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=release -DMG_ENTERPRISE=OFF ..
-          make -j$THREADS
-
-      - name: Create community RPM package
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Create community RPM package.
-          cd build
-          mkdir output && cd output
-          cpack -G RPM --config ../CPackConfig.cmake
-          rpmlint memgraph*.rpm
-
-      - name: Save community RPM package
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Community RPM package"
-          path: build/output/memgraph*.rpm
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__unit --output-on-failure
-
-      - name: Run stress test (plain)
-        run: |
-          cd tests/stress
-          ./continuous_integration
-
-      - name: Run stress test (large)
-        run: |
-          cd tests/stress
-          ./continuous_integration --large-dataset
-
-  coverage_build:
-    name: "Coverage build"
-    runs-on: [self-hosted, Linux, X64, CentOS8]
-    env:
-      THREADS: 24
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build coverage binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build coverage binaries.
-          cd build
-          cmake -DTEST_COVERAGE=ON ..
-          make -j$THREADS memgraph__unit
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__unit --output-on-failure
-
-      - name: Compute code coverage
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Compute code coverage.
-          cd tools/github
-          ./coverage_convert
-
-          # Package code coverage.
-          cd generated
-          tar -czf code_coverage.tar.gz coverage.json html report.json summary.rmu
-
-      - name: Save code coverage
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Code coverage"
-          path: tools/github/generated/code_coverage.tar.gz
-
-  debug_build:
-    name: "Debug build"
-    runs-on: [self-hosted, Linux, X64, CentOS8]
-    env:
-      THREADS: 24
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build debug binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build debug binaries.
-          cd build
-          cmake ..
-          make -j$THREADS
-
-      - name: Run leftover CTest tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run leftover CTest tests (all except unit and benchmark tests).
-          cd build
-          ctest -E "(memgraph__unit|memgraph__benchmark)" --output-on-failure
-
-      - name: Run drivers tests
-        run: |
-          ./tests/drivers/run.sh
-
-      - name: Run integration tests
-        run: |
-          cd tests/integration
-          for name in *; do
-            if [ ! -d $name ]; then continue; fi
-            pushd $name >/dev/null
-            echo "Running: $name"
-            if [ -x prepare.sh ]; then
-              ./prepare.sh
-            fi
-            if [ -x runner.py ]; then
-              ./runner.py
-            elif [ -x runner.sh ]; then
-              ./runner.sh
-            fi
-            echo
-            popd >/dev/null
-          done
-
-      - name: Run cppcheck and clang-format
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run cppcheck and clang-format.
-          cd tools/github
-          ./cppcheck_and_clang_format diff
-
-      - name: Save cppcheck and clang-format errors
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Code coverage"
-          path: tools/github/cppcheck_and_clang_format.txt
-
-  release_build:
-    name: "Release build"
-    runs-on: [self-hosted, Linux, X64, CentOS8]
-    env:
-      THREADS: 24
-    timeout-minutes: 960
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=release ..
-          make -j$THREADS
-
-      - name: Create enterprise RPM package
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Create enterprise RPM package.
-          cd build
-          mkdir output && cd output
-          cpack -G RPM --config ../CPackConfig.cmake
-          rpmlint memgraph*.rpm
-
-      - name: Save enterprise RPM package
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Enterprise RPM package"
-          path: build/output/memgraph*.rpm
-
-      - name: Run micro benchmark tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run micro benchmark tests.
-          cd build
-          # The `eval` benchmark needs a large stack limit.
-          ulimit -s 262144
-          ctest -R memgraph__benchmark -V
-
-      - name: Run macro benchmark tests
-        run: |
-          cd tests/macro_benchmark
-          ./harness QuerySuite MemgraphRunner \
-            --groups aggregation 1000_create unwind_create dense_expand match \
-            --no-strict
-
-      - name: Run parallel macro benchmark tests
-        run: |
-          cd tests/macro_benchmark
-          ./harness QueryParallelSuite MemgraphRunner \
-            --groups aggregation_parallel create_parallel bfs_parallel \
-            --num-database-workers 9 --num-clients-workers 30 \
-            --no-strict
-
-      - name: Run GQL Behave tests
-        run: |
-          cd tests/gql_behave
-          ./continuous_integration
-
-      - name: Save quality assurance status
-        uses: actions/upload-artifact@v2
-        with:
-          name: "GQL Behave Status"
-          path: |
-            tests/gql_behave/gql_behave_status.csv
-            tests/gql_behave/gql_behave_status.html
-
-      - name: Run e2e replication tests
-        run: |
-          # TODO(gitbuda): Setup mgclient and pymgclient properly.
-          cd tests
-          ./setup.sh
-          source ve3/bin/activate
-          cd e2e
-          LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../../libs/mgclient/lib python runner.py --workloads-path replication/workloads.yaml
-
-      - name: Run e2e memory control tests
-        run: |
-          cd tests
-          ./setup.sh
-          source ve3/bin/activate
-          cd e2e
-          LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../../libs/mgclient/lib python runner.py --workloads-path memory/workloads.yaml
-
-      - name: Run stress test (plain)
-        run: |
-          cd tests/stress
-          ./continuous_integration
-
-      - name: Run stress test (SSL)
-        run: |
-          cd tests/stress
-          ./continuous_integration --use-ssl
-
-      - name: Run stress test (large)
-        run: |
-          cd tests/stress
-          ./continuous_integration --large-dataset
-
-      - name: Run durability test (plain)
-        run: |
-          cd tests/stress
-          source ve3/bin/activate
-          python3 durability --num-steps 5
-
-      - name: Run durability test (large)
-        run: |
-          cd tests/stress
-          source ve3/bin/activate
-          python3 durability --num-steps 20

.github/workflows/release_debian10.yaml

@@ -1,366 +0,0 @@
-name: Release Debian 10
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: "0 1 * * *"
-
-jobs:
-  community_build:
-    name: "Community build"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    env:
-      THREADS: 24
-    timeout-minutes: 960
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build community binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build community binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=release -DMG_ENTERPRISE=OFF ..
-          make -j$THREADS
-
-      - name: Create community DEB package
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Create community DEB package.
-          cd build
-          mkdir output && cd output
-          cpack -G DEB --config ../CPackConfig.cmake
-
-      - name: Save community DEB package
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Community DEB package"
-          path: build/output/memgraph*.deb
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__unit --output-on-failure
-
-      - name: Run stress test (plain)
-        run: |
-          cd tests/stress
-          ./continuous_integration
-
-      - name: Run stress test (large)
-        run: |
-          cd tests/stress
-          ./continuous_integration --large-dataset
-
-  coverage_build:
-    name: "Coverage build"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    env:
-      THREADS: 24
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build coverage binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build coverage binaries.
-          cd build
-          cmake -DTEST_COVERAGE=ON ..
-          make -j$THREADS memgraph__unit
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__unit --output-on-failure
-
-      - name: Compute code coverage
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Compute code coverage.
-          cd tools/github
-          ./coverage_convert
-
-          # Package code coverage.
-          cd generated
-          tar -czf code_coverage.tar.gz coverage.json html report.json summary.rmu
-
-      - name: Save code coverage
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Code coverage"
-          path: tools/github/generated/code_coverage.tar.gz
-
-  debug_build:
-    name: "Debug build"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    env:
-      THREADS: 24
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build debug binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build debug binaries.
-          cd build
-          cmake ..
-          make -j$THREADS
-
-      - name: Run leftover CTest tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run leftover CTest tests (all except unit and benchmark tests).
-          cd build
-          ctest -E "(memgraph__unit|memgraph__benchmark)" --output-on-failure
-
-      - name: Run drivers tests
-        run: |
-          ./tests/drivers/run.sh
-
-      - name: Run integration tests
-        run: |
-          cd tests/integration
-          for name in *; do
-            if [ ! -d $name ]; then continue; fi
-            pushd $name >/dev/null
-            echo "Running: $name"
-            if [ -x prepare.sh ]; then
-              ./prepare.sh
-            fi
-            if [ -x runner.py ]; then
-              ./runner.py
-            elif [ -x runner.sh ]; then
-              ./runner.sh
-            fi
-            echo
-            popd >/dev/null
-          done
-
-      - name: Run cppcheck and clang-format
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run cppcheck and clang-format.
-          cd tools/github
-          ./cppcheck_and_clang_format diff
-
-      - name: Save cppcheck and clang-format errors
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Code coverage"
-          path: tools/github/cppcheck_and_clang_format.txt
-
-  release_build:
-    name: "Release build"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    env:
-      THREADS: 24
-    timeout-minutes: 960
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=release ..
-          make -j$THREADS
-
-      - name: Create enterprise DEB package
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Create enterprise DEB package.
-          cd build
-          mkdir output && cd output
-          cpack -G DEB --config ../CPackConfig.cmake
-
-      - name: Save enterprise DEB package
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Enterprise DEB package"
-          path: build/output/memgraph*.deb
-
-      - name: Run micro benchmark tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run micro benchmark tests.
-          cd build
-          # The `eval` benchmark needs a large stack limit.
-          ulimit -s 262144
-          ctest -R memgraph__benchmark -V
-
-      - name: Run macro benchmark tests
-        run: |
-          cd tests/macro_benchmark
-          ./harness QuerySuite MemgraphRunner \
-            --groups aggregation 1000_create unwind_create dense_expand match \
-            --no-strict
-
-      - name: Run parallel macro benchmark tests
-        run: |
-          cd tests/macro_benchmark
-          ./harness QueryParallelSuite MemgraphRunner \
-            --groups aggregation_parallel create_parallel bfs_parallel \
-            --num-database-workers 9 --num-clients-workers 30 \
-            --no-strict
-
-      - name: Run GQL Behave tests
-        run: |
-          cd tests/gql_behave
-          ./continuous_integration
-
-      - name: Save quality assurance status
-        uses: actions/upload-artifact@v2
-        with:
-          name: "GQL Behave Status"
-          path: |
-            tests/gql_behave/gql_behave_status.csv
-            tests/gql_behave/gql_behave_status.html
-
-      - name: Run e2e replication tests
-        run: |
-          # TODO(gitbuda): Setup mgclient and pymgclient properly.
-          cd tests
-          ./setup.sh
-          source ve3/bin/activate
-          cd e2e
-          LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../../libs/mgclient/lib python runner.py --workloads-path replication/workloads.yaml
-
-      - name: Run e2e memory control tests
-        run: |
-          cd tests
-          ./setup.sh
-          source ve3/bin/activate
-          cd e2e
-          LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../../libs/mgclient/lib python runner.py --workloads-path memory/workloads.yaml
-
-      - name: Run stress test (plain)
-        run: |
-          cd tests/stress
-          ./continuous_integration
-
-      - name: Run stress test (SSL)
-        run: |
-          cd tests/stress
-          ./continuous_integration --use-ssl
-
-      - name: Run stress test (large)
-        run: |
-          cd tests/stress
-          ./continuous_integration --large-dataset
-
-      - name: Run durability test (plain)
-        run: |
-          cd tests/stress
-          source ve3/bin/activate
-          python3 durability --num-steps 5
-
-      - name: Run durability test (large)
-        run: |
-          cd tests/stress
-          source ve3/bin/activate
-          python3 durability --num-steps 20
-
-  release_jepsen_test:
-    name: "Release Jepsen Test"
-    runs-on: [self-hosted, Linux, X64, Debian10, JepsenControl]
-    env:
-      THREADS: 24
-    timeout-minutes: 60
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build only memgraph release binary.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=release ..
-          make -j$THREADS memgraph
-
-      - name: Run Jepsen tests
-        run: |
-          cd tests/jepsen
-          ./run.sh test --binary ../../build/memgraph --run-args "test-all --node-configs resources/node-config.edn" --ignore-run-stdout-logs --ignore-run-stderr-logs
-
-      - name: Save Jepsen report
-        uses: actions/upload-artifact@v2
-        if: ${{ always() }}
-        with:
-          name: "Jepsen Report"
-          path: tests/jepsen/Jepsen.tar.gz

.github/workflows/release_ubuntu2004.yaml

@@ -1,326 +0,0 @@
-name: Release Ubuntu 20.04
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: "0 1 * * *"
-
-jobs:
-  community_build:
-    name: "Community build"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    env:
-      THREADS: 24
-    timeout-minutes: 960
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build community binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build community binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=release -DMG_ENTERPRISE=OFF ..
-          make -j$THREADS
-
-      - name: Create community DEB package
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Create community DEB package.
-          cd build
-          mkdir output && cd output
-          cpack -G DEB --config ../CPackConfig.cmake
-
-      - name: Save community DEB package
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Community DEB package"
-          path: build/output/memgraph*.deb
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__unit --output-on-failure
-
-      - name: Run stress test (plain)
-        run: |
-          cd tests/stress
-          ./continuous_integration
-
-      - name: Run stress test (large)
-        run: |
-          cd tests/stress
-          ./continuous_integration --large-dataset
-
-  coverage_build:
-    name: "Coverage build"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    env:
-      THREADS: 24
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build coverage binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build coverage binaries.
-          cd build
-          cmake -DTEST_COVERAGE=ON ..
-          make -j$THREADS memgraph__unit
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__unit --output-on-failure
-
-      - name: Compute code coverage
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Compute code coverage.
-          cd tools/github
-          ./coverage_convert
-
-          # Package code coverage.
-          cd generated
-          tar -czf code_coverage.tar.gz coverage.json html report.json summary.rmu
-
-      - name: Save code coverage
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Code coverage"
-          path: tools/github/generated/code_coverage.tar.gz
-
-  debug_build:
-    name: "Debug build"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    env:
-      THREADS: 24
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build debug binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build debug binaries.
-          cd build
-          cmake ..
-          make -j$THREADS
-
-      - name: Run leftover CTest tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run leftover CTest tests (all except unit and benchmark tests).
-          cd build
-          ctest -E "(memgraph__unit|memgraph__benchmark)" --output-on-failure
-
-      - name: Run drivers tests
-        run: |
-          ./tests/drivers/run.sh
-
-      - name: Run integration tests
-        run: |
-          cd tests/integration
-          for name in *; do
-            if [ ! -d $name ]; then continue; fi
-            pushd $name >/dev/null
-            echo "Running: $name"
-            if [ -x prepare.sh ]; then
-              ./prepare.sh
-            fi
-            if [ -x runner.py ]; then
-              ./runner.py
-            elif [ -x runner.sh ]; then
-              ./runner.sh
-            fi
-            echo
-            popd >/dev/null
-          done
-
-      - name: Run cppcheck and clang-format
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run cppcheck and clang-format.
-          cd tools/github
-          ./cppcheck_and_clang_format diff
-
-      - name: Save cppcheck and clang-format errors
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Code coverage"
-          path: tools/github/cppcheck_and_clang_format.txt
-
-  release_build:
-    name: "Release build"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    env:
-      THREADS: 24
-    timeout-minutes: 960
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v2
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=release ..
-          make -j$THREADS
-
-      - name: Create enterprise DEB package
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Create enterprise DEB package.
-          cd build
-          mkdir output && cd output
-          cpack -G DEB --config ../CPackConfig.cmake
-
-      - name: Save enterprise DEB package
-        uses: actions/upload-artifact@v2
-        with:
-          name: "Enterprise DEB package"
-          path: build/output/memgraph*.deb
-
-      - name: Run micro benchmark tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v2/activate
-
-          # Run micro benchmark tests.
-          cd build
-          # The `eval` benchmark needs a large stack limit.
-          ulimit -s 262144
-          ctest -R memgraph__benchmark -V
-
-      - name: Run macro benchmark tests
-        run: |
-          cd tests/macro_benchmark
-          ./harness QuerySuite MemgraphRunner \
-            --groups aggregation 1000_create unwind_create dense_expand match \
-            --no-strict
-
-      - name: Run parallel macro benchmark tests
-        run: |
-          cd tests/macro_benchmark
-          ./harness QueryParallelSuite MemgraphRunner \
-            --groups aggregation_parallel create_parallel bfs_parallel \
-            --num-database-workers 9 --num-clients-workers 30 \
-            --no-strict
-
-      - name: Run GQL Behave tests
-        run: |
-          cd tests/gql_behave
-          ./continuous_integration
-
-      - name: Save quality assurance status
-        uses: actions/upload-artifact@v2
-        with:
-          name: "GQL Behave Status"
-          path: |
-            tests/gql_behave/gql_behave_status.csv
-            tests/gql_behave/gql_behave_status.html
-
-      - name: Run e2e replication tests
-        run: |
-          # TODO(gitbuda): Setup mgclient and pymgclient properly.
-          cd tests
-          ./setup.sh
-          source ve3/bin/activate
-          cd e2e
-          LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../../libs/mgclient/lib python runner.py --workloads-path replication/workloads.yaml
-
-      - name: Run e2e memory control tests
-        run: |
-          cd tests
-          ./setup.sh
-          source ve3/bin/activate
-          cd e2e
-          LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../../libs/mgclient/lib python runner.py --workloads-path memory/workloads.yaml
-
-      - name: Run stress test (plain)
-        run: |
-          cd tests/stress
-          ./continuous_integration
-
-      - name: Run stress test (SSL)
-        run: |
-          cd tests/stress
-          ./continuous_integration --use-ssl
-
-      - name: Run stress test (large)
-        run: |
-          cd tests/stress
-          ./continuous_integration --large-dataset
-
-      - name: Run durability test (plain)
-        run: |
-          cd tests/stress
-          source ve3/bin/activate
-          python3 durability --num-steps 5
-
-      - name: Run durability test (large)
-        run: |
-          cd tests/stress
-          source ve3/bin/activate
-          python3 durability --num-steps 20

.gitignore

@@ -34,35 +34,43 @@ TAGS
 *.fas
 *.fasl
 
-# LCP generated C++ files
-*.lcp.cpp
+# Cap'n Proto generated files
+*.capnp.c++
+*.capnp.h
 
-src/database/distributed/serialization.hpp
-src/database/single_node_ha/serialization.hpp
+# LCP generated C++ & Cap'n Proto files
+*.lcp.cpp
+src/database/counters_rpc_messages.capnp
+src/database/counters_rpc_messages.hpp
+src/database/state_delta.capnp
+src/database/state_delta.hpp
+src/distributed/bfs_rpc_messages.capnp
 src/distributed/bfs_rpc_messages.hpp
+src/distributed/coordination_rpc_messages.capnp
 src/distributed/coordination_rpc_messages.hpp
+src/distributed/data_rpc_messages.capnp
 src/distributed/data_rpc_messages.hpp
+src/distributed/durability_rpc_messages.capnp
 src/distributed/durability_rpc_messages.hpp
-src/distributed/dynamic_worker_rpc_messages.hpp
+src/distributed/index_rpc_messages.capnp
 src/distributed/index_rpc_messages.hpp
+src/distributed/plan_rpc_messages.capnp
 src/distributed/plan_rpc_messages.hpp
+src/distributed/pull_produce_rpc_messages.capnp
 src/distributed/pull_produce_rpc_messages.hpp
+src/distributed/storage_gc_rpc_messages.capnp
 src/distributed/storage_gc_rpc_messages.hpp
+src/distributed/token_sharing_rpc_messages.capnp
 src/distributed/token_sharing_rpc_messages.hpp
+src/distributed/transactional_cache_cleaner_rpc_messages.capnp
+src/distributed/transactional_cache_cleaner_rpc_messages.hpp
+src/distributed/updates_rpc_messages.capnp
 src/distributed/updates_rpc_messages.hpp
-src/query/frontend/ast/ast.hpp
-src/query/distributed/frontend/ast/ast_serialization.hpp
-src/durability/distributed/state_delta.hpp
-src/durability/single_node/state_delta.hpp
-src/durability/single_node_ha/state_delta.hpp
-src/query/frontend/semantic/symbol.hpp
-src/query/distributed/frontend/semantic/symbol_serialization.hpp
-src/query/distributed/plan/ops.hpp
+src/query/plan/operator.capnp
 src/query/plan/operator.hpp
-src/raft/log_entry.hpp
-src/raft/raft_rpc_messages.hpp
-src/raft/snapshot_metadata.hpp
-src/raft/storage_info_rpc_messages.hpp
+src/stats/stats_rpc_messages.capnp
 src/stats/stats_rpc_messages.hpp
-src/storage/distributed/rpc/concurrent_id_mapper_rpc_messages.hpp
-src/transactions/distributed/engine_rpc_messages.hpp
+src/storage/concurrent_id_mapper_rpc_messages.capnp
+src/storage/concurrent_id_mapper_rpc_messages.hpp
+src/transactions/engine_rpc_messages.capnp
+src/transactions/engine_rpc_messages.hpp

.ycm_extra_conf.py

@@ -0,0 +1,171 @@
+import os
+import os.path
+import fnmatch
+import logging
+import ycm_core
+
+BASE_FLAGS = [
+    '-Wall',
+    '-Wextra',
+    '-Werror',
+    '-Wno-long-long',
+    '-Wno-variadic-macros',
+    '-fexceptions',
+    '-ferror-limit=10000',
+    '-std=c++1z',
+    '-xc++',
+    '-I/usr/lib/',
+    '-I/usr/include/',
+    '-I./src',
+    '-I./include',
+    '-I./libs/fmt',
+    '-I./libs/yaml-cpp',
+    '-I./libs/glog/include',
+    '-I./libs/googletest/googletest/include',
+    '-I./libs/googletest/googlemock/include',
+    '-I./libs/benchmark/include',
+    '-I./libs/cereal/include',
+    # We include cppitertools headers directly from libs directory.
+    '-I./libs',
+    '-I./libs/rapidcheck/include',
+    '-I./libs/antlr4/runtime/Cpp/runtime/src',
+    '-I./libs/gflags/include',
+    '-I./experimental/distributed/src',
+    '-I./libs/postgresql/include',
+    '-I./libs/bzip2',
+    '-I./libs/zlib',
+    '-I./libs/rocksdb/include',
+    '-I./build/include'
+]
+
+SOURCE_EXTENSIONS = [
+    '.cpp',
+    '.cxx',
+    '.cc',
+    '.c',
+    '.m',
+    '.mm'
+]
+
+HEADER_EXTENSIONS = [
+    '.h',
+    '.hxx',
+    '.hpp',
+    '.hh'
+]
+
+# set the working directory of YCMD to be this file
+os.chdir(os.path.dirname(os.path.realpath(__file__)))
+
+def IsHeaderFile(filename):
+    extension = os.path.splitext(filename)[1]
+    return extension in HEADER_EXTENSIONS
+
+def GetCompilationInfoForFile(database, filename):
+    if IsHeaderFile(filename):
+        basename = os.path.splitext(filename)[0]
+        for extension in SOURCE_EXTENSIONS:
+            replacement_file = basename + extension
+            if os.path.exists(replacement_file):
+                compilation_info = database.GetCompilationInfoForFile(replacement_file)
+                if compilation_info.compiler_flags_:
+                    return compilation_info
+        return None
+    return database.GetCompilationInfoForFile(filename)
+
+def FindNearest(path, target):
+    candidate = os.path.join(path, target)
+    if(os.path.isfile(candidate) or os.path.isdir(candidate)):
+        logging.info("Found nearest " + target + " at " + candidate)
+        return candidate;
+    else:
+        parent = os.path.dirname(os.path.abspath(path));
+        if(parent == path):
+            raise RuntimeError("Could not find " + target);
+        return FindNearest(parent, target)
+
+def MakeRelativePathsInFlagsAbsolute(flags, working_directory):
+    if not working_directory:
+        return list(flags)
+    new_flags = []
+    make_next_absolute = False
+    path_flags = [ '-isystem', '-I', '-iquote', '--sysroot=' ]
+    for flag in flags:
+        new_flag = flag
+
+        if make_next_absolute:
+            make_next_absolute = False
+            if not flag.startswith('/'):
+                new_flag = os.path.join(working_directory, flag)
+
+        for path_flag in path_flags:
+            if flag == path_flag:
+                make_next_absolute = True
+                break
+
+            if flag.startswith(path_flag):
+                path = flag[ len(path_flag): ]
+                new_flag = path_flag + os.path.join(working_directory, path)
+                break
+
+        if new_flag:
+            new_flags.append(new_flag)
+    return new_flags
+
+
+def FlagsForClangComplete(root):
+    try:
+        clang_complete_path = FindNearest(root, '.clang_complete')
+        clang_complete_flags = open(clang_complete_path, 'r').read().splitlines()
+        return clang_complete_flags
+    except:
+        return None
+
+def FlagsForInclude(root):
+    try:
+        include_path = FindNearest(root, 'include')
+        flags = []
+        for dirroot, dirnames, filenames in os.walk(include_path):
+            for dir_path in dirnames:
+                real_path = os.path.join(dirroot, dir_path)
+                flags = flags + ["-I" + real_path]
+        return flags
+    except:
+        return None
+
+def FlagsForCompilationDatabase(root, filename):
+    try:
+        compilation_db_path = FindNearest(root, 'compile_commands.json')
+        compilation_db_dir = os.path.dirname(compilation_db_path)
+        logging.info("Set compilation database directory to " + compilation_db_dir)
+        compilation_db =  ycm_core.CompilationDatabase(compilation_db_dir)
+        if not compilation_db:
+            logging.info("Compilation database file found but unable to load")
+            return None
+        compilation_info = GetCompilationInfoForFile(compilation_db, filename)
+        if not compilation_info:
+            logging.info("No compilation info for " + filename + " in compilation database")
+            return None
+        return MakeRelativePathsInFlagsAbsolute(
+            compilation_info.compiler_flags_,
+            compilation_info.compiler_working_dir_)
+    except:
+        return None
+
+def FlagsForFile(filename):
+    root = os.path.realpath(filename);
+    compilation_db_flags = FlagsForCompilationDatabase(root, filename)
+    if compilation_db_flags:
+        final_flags = compilation_db_flags
+    else:
+        final_flags = BASE_FLAGS
+        clang_flags = FlagsForClangComplete(root)
+        if clang_flags:
+            final_flags = final_flags + clang_flags
+        include_flags = FlagsForInclude(root)
+        if include_flags:
+            final_flags = final_flags + include_flags
+    return {
+        'flags': final_flags,
+        'do_cache': True
+    }

CHANGELOG.md

@@ -1,313 +1,5 @@
 # Change Log
 
-## Future
-
-### Bug Fixes
-
-* Fixed parsing of types for Python procedures for types nested in `mgp.List`.
-  For example, parsing of `mgp.List[mgp.Map]` works now.
-* Fixed memory tracking issues. Some of the allocation and deallocation weren't
-  tracked during the query execution.
-* Fixed reading CSV files that are using CRLF as the newline symbol.
-
-## v1.4.0
-
-### Breaking Changes
-
-* Changed `MEMORY LIMIT num (KB|MB)` clause in the procedure calls to `PROCEDURE MEMORY LIMIT num (KB|MB)`.
-  The functionality is still the same.
-
-### Major Feature and Improvements
-
-* Added replication to community version.
-* Added support for multiple query modules directories at the same time.
-  You can now define multiple, comma-separated paths to directories from
-  which the modules will be loaded using the `--query-modules-directory` flag.
-* Added support for programatically reading in data from CSV files through the
-  `LOAD CSV` clause. We support CSV files with and without a header, the
-  supported dialect being Excel.
-* Added a new flag `--memory-limit` which enables the user to set the maximum total amount of memory
-  memgraph can allocate during its runtime.
-* Added `FREE MEMORY` query which tries to free unusued memory chunks in different parts of storage.
-* Added the memory limit and amount of currently allocated bytes in the result of `SHOW STORAGE INFO` query.
-* Added `QUERY MEMORY LIMIT num (KB|MB)` to Cypher queries which allows you to limit memory allocation for
-  the entire query. It can be added only at the end of the entire Cypher query.
-* Added logs for the different parts of the recovery process. `INFO`, `DEBUG` and `TRACE` level all contain
-  additional information that is printed out while the recovery is in progress.
-
-### Bug Fixes
-
-* Fixed garbage collector by correctly marking the oldest current timestamp
-  after the database was recovered using the durability files.
-* Fixed reloading of the modules with changed result names.
-* Fixed profile query to show the correct name of the ScanAll operator variant.
-
-## v1.3.0
-
-### Breaking Changes
-
-* Added extra information in durability files to support replication, making it
-  incompatible with the durability files generated by older versions of
-  Memgraph. Even though the replication is an Enterprise feature, the files are
-  compatible with the Community version.
-
-### Major Features and Improvements
-
-* Added support for data replication across a cluster of Memgraph instances.
-  Supported instance types are MAIN and REPLICA. Supported replication modes
-  are SYNC (all SYNC REPLICAS have to receive data before the MAIN can commit
-  the transaction), ASYNC (MAIN doesn't care if data is replicated), SYNC WITH
-  TIMEOUT (MAIN will wait for REPLICAS within the given timeout period, after
-  timout, replication isn't aborted but the replication demotes the REPLICA to
-  the ASYNC mode).
-* Added support for query type deduction. Possible query types are `r` (read),
-  `w` (write), `rw` (read-write). The query type is returned as a part of the
-  summary.
-* Improved logging capabilities by introducing granular logging levels. Added
-  new flag, `--log-level`, which specifies the minimum log level that will be
-  printed. E.g., it's possible to print incoming queries or Bolt server states.
-* Added ability to lock the storage data directory by executing the `LOCK DATA
-  DIRECTORY;` query which delays the deletion of the files contained in the
-  data directory. The data directory can be unlocked again by executing the
-  `UNLOCK DATA DIRECTORY;` query.
-
-### Bug Fixes and Other Changes
-
-* Added cleanup of query executions if not in an explicit transaction.
-* Fix RPC dangling reference.
-
-## v1.2.0
-
-### Breaking Changes
-
-* SSL is disabled by default (`--bolt-cert-file` and `--bolt-key-file` are
-  empty). This change might only affect the client connection configuration.
-
-### Major Features and Improvements
-
-* Added support for Bolt v4.0 and v4.1.
-* Added `mgp_networkx.py` as an alternative implementation of NetworkX graph
-  objects, which is useful to use Memgraph data from NetworkX algorithms
-  optimally.
-* Added `nxalg.py` query module as a proxy to NetworkX algorithms.
-* Added plan optimization to use a label-property index where the property is
-  not null. As a result, the query engine, instead of scanning all elements and
-  applying the filter, performs a label-property index lookup when possible.
-
-### Bug Fixes and Other Changes
-
-* Fixed Cypher `ID` function `Null` handling. When the `ID` function receives
-  `Null`, it will also return `Null`.
-* Fixed bug that caused random crashes in SSL communication on platforms
-  that use older versions of OpenSSL (< 1.1) by adding proper multi-threading
-  handling.
-* Fix `DISCARD` message handling. The query is now executed before discarding
-  the results.
-
-## v1.1.0
-
-### Major Features and Improvements
-
-* Properties in nodes and edges are now stored encoded and compressed. This
-  change significantly reduces memory usage. Depending on the specific dataset,
-  total memory usage can be reduced up to 50%.
-* Added support for rescanning query modules. Previously, the query modules
-  directory was scanned only upon startup. Now it is scanned each time the user
-  requests to load a query module. The functions used to load the query modules
-  were renamed to `mg.load()` and `mg.load_all()` (from `mg.reload()` and
-  `mg.reload_all()`).
-* Improved execution performance of queries that have an IN list filter by
-  using label+property indices.
-  Example: `MATCH (n:Label) WHERE n.property IN [] ...`
-* Added support for `ANY` and `NONE` openCypher functions. Previously, only
-  `ALL` and `SINGLE` functions were implemented.
-
-### Bug Fixes and Other Changes
-
-* Fixed invalid paths returned by variable expansion when the starting node and
-  destination node used the same symbol.
-  Example: `MATCH path = (n:Person {name: "John"})-[:KNOWS*]->(n) RETURN path`
-* Improved semantics of `ALL` and `SINGLE` functions to be consistent with
-  openCypher when handling lists with `Null`s.
-* `SHOW CONSTRAINT INFO` now returns property names as a list for unique
-  constraints.
-* Escaped label/property/edgetype names in `DUMP DATABASE` to support names
-  with spaces in them.
-* Fixed handling of `DUMP DATABASE` queries in multi-command transactions
-  (`BEGIN`, ..., `COMMIT`).
-* Fixed handling of various query types in explicit transactions. For example,
-  constraints were allowed to be created in multi-command transactions
-  (`BEGIN`, ..., `COMMIT`) but that isn't a transactional operation and as such
-  can't be allowed in multi-command transactions.
-* Fixed integer overflow bugs in `COUNT`, `LIMIT` and `SKIP`.
-* Fixed integer overflow bugs in weighted shortest path expansions.
-* Fixed various other integer overflow bugs in query execution.
-* Added Marvel Comic Universe tutorial.
-* Added FootballTransfers tutorial.
-
-## v1.0.0
-
-### Major Features and Improvements
-
-* [Enterprise Ed.] Exposed authentication username/rolename regex as a flag
-  (`--auth-user-or-role-name-regex`).
-* [Enterprise Ed.] Improved auth module error handling and added support for
-  relative paths.
-* Added support for Python query modules. This release of Memgraph supports
-  query modules written using the already existing C API and the new Python
-  API.
-* Added support for unique constraints. The unique constraint is created with a
-  label and one or more properties.
-* Implemented support for importing CSV files (`mg_import_csv`). The importer
-  is compatible with the Neo4j batch CSV importer.
-* Snapshot and write-ahead log format changed (backward compatible with v0.50).
-* Vertices looked up by their openCypher ID (`MATCH (n) WHERE ID(n) = ...`)
-  will now find the node in O(logn) instead of O(n).
-* Improved planning of BFS expansion, a faster, specific approach is now
-  favored instead of a ScanAll+Filter operation.
-* Added syntax for limiting memory of `CALL`.
-* Exposed server name that should be used for Bolt handshake as flag
-  (`--bolt-server-name-for-init`).
-* Added several more functions to the query module C API.
-* Implemented a storage locking mechanism that prevents the user from
-  concurrently starting two Memgraph instances with the same data directory.
-
-### Bug Fixes and Other Changes
-
-* [Enterprise Ed.] Fixed a bug that crashed the database when granting
-  privileges to a user.
-* [Enterprise Ed.] Improved Louvain algorithm for community detection.
-* Type of variable expansion is now printed in `EXPLAIN` (e.g. ExpandVariable,
-  STShortestPath, BFSExpand, WeightedShortestPath).
-* Correctly display `CALL` in `EXPLAIN` output.
-* Correctly delimit arguments when printing the signature of a query module.
-* Fixed a planning issue when `CALL` preceded filtering.
-* Fixed spelling mistakes in the storage durability module.
-* Fixed storage GC indices/constraints subtle race condition.
-* Reduced memory allocations in storage API and indices.
-* Memgraph version is now outputted to `stdout` when Memgraph is started.
-* Improved RPM packaging.
-* Reduced number of errors reported in production log when loading query
-  modules.
-* Removed `early access` wording from the Community Offering license.
-
-## v0.50.0
-
-### Breaking Changes
-
-* [Enterprise Ed.] Remove support for Kafka streams.
-* Snapshot and write-ahead log format changed (not backward compatible).
-* Removed support for unique constraints.
-* Label indices aren't created automatically, create them explicitly instead.
-* Renamed several database flags. Please see the configuration file for a list of current flags.
-
-### Major Features and Improvements
-
-* [Enterprise Ed.] Add support for auth module.
-* [Enterprise Ed.] LDAP support migrated to auth module.
-* Implemented new graph storage engine.
-* Add support for disabling properties on edges.
-* Add support for existence constraints.
-* Add support for custom openCypher procedures using a C API.
-* Support loading query modules implementing read-only procedures.
-* Add `CALL <procedure> YIELD <result>` syntax for invoking loaded procedures.
-* Add `CREATE INDEX ON :Label` for creating label indices.
-* Add `DROP INDEX ON :Label` for dropping label indices.
-* Add `DUMP DATABASE` clause to openCypher.
-* Add functions for treating character strings as byte strings.
-
-### Bug Fixes and Other Changes
-
-* Fix several memory management bugs.
-* Reduce memory usage in query execution.
-* Fix bug that crashes the database when `EXPLAIN` is used.
-
-## v0.15.0
-
-### Breaking Changes
-
-* Snapshot and write-ahead log format changed (not backward compatible).
-* `indexInfo()` function replaced with `SHOW INDEX INFO` syntax.
-* Removed support for unique index. Use unique constraints instead.
-* `CREATE UNIQUE INDEX ON :label (property)` replaced with `CREATE CONSTRAINT ON (n:label) ASSERT n.property IS UNIQUE`.
-* Changed semantics for `COUNTER` openCypher function.
-
-### Major Features and Improvements
-
-* [Enterprise Ed.] Add new privilege, `STATS` for accessing storage info.
-* [Enterprise Ed.] LDAP authentication and authorization support.
-* [Enterprise Ed.] Add audit logging feature.
-* Add multiple properties unique constraint which replace unique indices.
-* Add `SHOW STORAGE INFO` feature.
-* Add `PROFILE` clause to openCypher.
-* Add `CREATE CONSTRAINT` clause to openCypher.
-* Add `DROP CONSTRAINT` clause to openCypher.
-* Add `SHOW CONSTRAINT INFO` feature.
-* Add `uniformSample` function to openCypher.
-* Add regex matching to openCypher.
-
-### Bug Fixes and Other Changes
-
-* Fix bug in explicit transaction handling.
-* Fix bug in edge filtering by edge type and destination.
-* Fix bug in query comment parsing.
-* Fix bug in query symbol table.
-* Fix OpenSSL memory leaks.
-* Make authentication case insensitive.
-* Remove `COALESCE` function.
-* Add movie tutorial.
-* Add backpacking tutorial.
-
-## v0.14.0
-
-### Breaking Changes
-
-* Write-ahead log format changed (not backward compatible).
-
-### Major Features and Improvements
-
-* [Enterprise Ed.] Reduce memory usage in distributed usage.
-* Add `DROP INDEX` feature.
-* Improve SSL error messages.
-
-### Bug Fixes and Other Changes
-
-* [Enterprise Ed.] Fix issues with reading and writing in a distributed query.
-* Correctly handle an edge case with unique constraint checks.
-* Fix a minor issue with `mg_import_csv`.
-* Fix an issue with `EXPLAIN`.
-
-## v0.13.0
-
-### Breaking Changes
-
-* Write-ahead log format changed (not backward compatible).
-* Snapshot format changed (not backward compatible).
-
-### Major Features and Improvements
-
-* [Enterprise Ed.] Authentication and authorization support.
-* [Enterprise Ed.] Kafka integration.
-* [Enterprise Ed.] Support dynamic worker addition in distributed.
-* Reduce memory usage and improve overall performance.
-* Add `CREATE UNIQUE INDEX` clause to openCypher.
-* Add `EXPLAIN` clause to openCypher.
-* Add `inDegree` and `outDegree` functions to openCypher.
-* Improve BFS performance when both endpoints are known.
-* Add new `node-label`, `relationship-type` and `quote` options to
-  `mg_import_csv` tool.
-* Reduce memory usage of `mg_import_csv`.
-
-### Bug Fixes and Other Changes
-
-* [Enterprise Ed.] Fix an edge case in distributed index creation.
-* [Enterprise Ed.] Fix issues with Cartesian in distributed queries.
-* Correctly handle large messages in Bolt protocol.
-* Fix issues when handling explicitly started transactions in queries.
-* Allow openCypher keywords to be used as variable names.
-* Revise and make user visible error messages consistent.
-* Improve aborting time consuming execution.
-
 ## v0.12.0
 
 ### Breaking Changes
@@ -329,7 +21,7 @@
 * [Enterprise Ed.] Improve Cartesian support in distributed queries.
 * [Enterprise Ed.] Improve distributed execution of BFS.
 * [Enterprise Ed.] Dynamic graph partitioner added.
-* Static nodes/edges id generators exposed through the Id Cypher function.
+* Static vertices/edges id generators exposed through the Id Cypher function.
 * Properties on disk added.
 * Telemetry added.
 * SSL support added.
@@ -391,7 +83,7 @@
 
 * CASE construct (without aggregations).
 * Named path support added.
-* Maps can now be stored as node/edge properties.
+* Maps can now be stored as vertex/edge properties.
 * Map indexing supported.
 * `rand` function added.
 * `assert` function added.

CMakeLists.txt

@@ -1,6 +1,6 @@
 # MemGraph CMake configuration
 
-cmake_minimum_required(VERSION 3.8)
+cmake_minimum_required(VERSION 3.1)
 
 # !! IMPORTANT !! run ./project_root/init.sh before cmake command
 # to download dependencies
@@ -31,128 +31,18 @@ find_program(CLANGXX_FOUND clang++)
 if (CLANG_FOUND AND CLANGXX_FOUND)
   set(CMAKE_C_COMPILER ${CLANG_FOUND})
   set(CMAKE_CXX_COMPILER ${CLANGXX_FOUND})
-else()
-  message(FATAL_ERROR "Couldn't find clang and/or clang++!")
 endif()
 
-option(BUILD_FOR_DOCKER "Build Memgraph binary for docker." OFF)
-message(STATUS "BUILD_FOR_DOCKER: ${BUILD_FOR_DOCKER}")
+# Get current commit hash.
+execute_process(
+    OUTPUT_VARIABLE COMMIT_HASH
+    COMMAND git rev-parse --short HEAD
+)
+string(STRIP ${COMMIT_HASH} COMMIT_HASH)
 
 # -----------------------------------------------------------------------------
 
-project(memgraph)
-
-# For more information about how to release a new version of Memgraph, see
-# `release/README.md`.
-
-# Option that is used to specify which version of Memgraph should be built. The
-# default is `ON` which causes the build system to build Memgraph Enterprise.
-# Memgraph Community is built if explicitly set to `OFF`.
-option(MG_ENTERPRISE "Build Memgraph Enterprise Edition" ON)
-
-# Set the current version here to override the automatic version detection. The
-# version must be specified as `X.Y.Z`. Primarily used when building new patch
-# versions.
-set(MEMGRAPH_OVERRIDE_VERSION "")
-
-# Custom suffix that this version should have. The suffix can be any arbitrary
-# string. Primarily used when building a version for a specific customer.
-set(MEMGRAPH_OVERRIDE_VERSION_SUFFIX "")
-
-# Variables used to generate the versions.
-if (MG_ENTERPRISE)
-  set(get_version_enterprise "--enterprise")
-else()
-  set(get_version_enterprise "")
-endif()
-set(get_version_script "${CMAKE_SOURCE_DIR}/release/get_version.py")
-
-# Get version that should be used in the binary.
-execute_process(
-    OUTPUT_VARIABLE MEMGRAPH_VERSION
-    RESULT_VARIABLE MEMGRAPH_VERSION_RESULT
-    COMMAND "${get_version_script}" ${get_version_enterprise}
-                "${MEMGRAPH_OVERRIDE_VERSION}"
-                "${MEMGRAPH_OVERRIDE_VERSION_SUFFIX}"
-                "--memgraph-root-dir"
-                "${CMAKE_SOURCE_DIR}"
-)
-if(MEMGRAPH_VERSION_RESULT AND NOT MEMGRAPH_VERSION_RESULT EQUAL 0)
-    message(FATAL_ERROR "Unable to get Memgraph version.")
-else()
-    MESSAGE(STATUS "Memgraph version: ${MEMGRAPH_VERSION}")
-endif()
-
-# Get version that should be used in the DEB package.
-execute_process(
-    OUTPUT_VARIABLE MEMGRAPH_VERSION_DEB
-    RESULT_VARIABLE MEMGRAPH_VERSION_DEB_RESULT
-    COMMAND "${get_version_script}" ${get_version_enterprise}
-                --variant deb
-                "${MEMGRAPH_OVERRIDE_VERSION}"
-                "${MEMGRAPH_OVERRIDE_VERSION_SUFFIX}"
-                "--memgraph-root-dir"
-                "${CMAKE_SOURCE_DIR}"
-)
-if(MEMGRAPH_VERSION_DEB_RESULT AND NOT MEMGRAPH_VERSION_DEB_RESULT EQUAL 0)
-    message(FATAL_ERROR "Unable to get Memgraph DEB version.")
-else()
-    MESSAGE(STATUS "Memgraph DEB version: ${MEMGRAPH_VERSION_DEB}")
-endif()
-
-# Get version that should be used in the RPM package.
-execute_process(
-    OUTPUT_VARIABLE MEMGRAPH_VERSION_RPM
-    RESULT_VARIABLE MEMGRAPH_VERSION_RPM_RESULT
-    COMMAND "${get_version_script}" ${get_version_enterprise}
-                --variant rpm
-                "${MEMGRAPH_OVERRIDE_VERSION}"
-                "${MEMGRAPH_OVERRIDE_VERSION_SUFFIX}"
-                "--memgraph-root-dir"
-                "${CMAKE_SOURCE_DIR}"
-)
-if(MEMGRAPH_VERSION_RPM_RESULT AND NOT MEMGRAPH_VERSION_RPM_RESULT EQUAL 0)
-    message(FATAL_ERROR "Unable to get Memgraph RPM version.")
-else()
-    MESSAGE(STATUS "Memgraph RPM version: ${MEMGRAPH_VERSION_RPM}")
-endif()
-
-# We want the above variables to be updated each time something is committed to
-# the repository. That is why we include a dependency on the current git HEAD
-# to trigger a new CMake run when the git repository state changes. This is a
-# hack, as CMake doesn't have a mechanism to regenerate variables when
-# something changes (only files can be regenerated).
-# https://cmake.org/pipermail/cmake/2018-October/068389.html
-#
-# The hack in the above link is nearly correct but it has a fatal flaw. The
-# `CMAKE_CONFIGURE_DEPENDS` isn't a `GLOBAL` property, it is instead a
-# `DIRECTORY` property and as such must be set in the `DIRECTORY` scope.
-# https://cmake.org/cmake/help/v3.14/manual/cmake-properties.7.html
-#
-# Unlike the above mentioned hack, we don't use the `.git/index` file. That
-# file changes on every `git add` (even on `git status`) so it triggers
-# unnecessary recalculations of the release version. The release version only
-# changes on every `git commit` or `git checkout`. That is why we watch the
-# following files for changes:
-#   - `.git/HEAD` -> changes each time a `git checkout` is issued
-#   - `.git/refs/heads/...` -> the value in `.git/HEAD` is a branch name (when
-#     you are on a branch) and you have to monitor the file of the specific
-#     branch to detect when a `git commit` was issued
-# More details about the contents of the `.git` directory and the specific
-# files used can be seen here:
-# https://git-scm.com/book/en/v2/Git-Internals-Git-References
-set(git_directory "${CMAKE_SOURCE_DIR}/.git")
-if (EXISTS "${git_directory}")
-  set_property(DIRECTORY APPEND PROPERTY
-      CMAKE_CONFIGURE_DEPENDS "${git_directory}/HEAD")
-  file(STRINGS "${git_directory}/HEAD" git_head_data)
-  if (git_head_data MATCHES "^ref: ")
-    string(SUBSTRING "${git_head_data}" 5 -1 git_head_ref)
-    set_property(DIRECTORY APPEND PROPERTY
-        CMAKE_CONFIGURE_DEPENDS "${git_directory}/${git_head_ref}")
-  endif()
-endif()
-
+project(memgraph VERSION 0.12.0)
 # -----------------------------------------------------------------------------
 
 # setup CMake module path, defines path for include() and find_package()
@@ -172,27 +62,21 @@ add_custom_target(clean_all
 
 # build flags -----------------------------------------------------------------
 
-# Export the compile commands so that we can use clang-tidy. Additional benefit
-# is easier debugging of compilation and linker flags.
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-# c99-designator is disabled because of required mixture of designated and
-# non-designated initializers in Python Query Module code (`py_module.cpp`).
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall \
-    -Werror=switch -Werror=switch-bool -Werror=return-type \
-    -Werror=return-stack-address \
-    -Wno-c99-designator")
+# TODO: set here 17 once it will be available in the cmake version (3.8)
+# set(CMAKE_CXX_STANDARD 17)
+# set(CMAKE_CXX_STANDARD_REQUIRED ON)
+# For now, explicitly set -std= flag for C++17.
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++1z -Wall \
+    -Werror=switch -Werror=switch-bool -Werror=return-type")
 
 # Don't omit frame pointer in RelWithDebInfo, for additional callchain debug.
 set(CMAKE_CXX_FLAGS_RELWITHDEBINFO
     "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -fno-omit-frame-pointer")
 
 # Statically link libgcc and libstdc++, the GCC allows this according to:
-# https://gcc.gnu.org/onlinedocs/gcc-10.2.0/libstdc++/manual/manual/license.html
 # https://www.gnu.org/licenses/gcc-exception-faq.html
-# Last checked for gcc-10.2 which we are using on the build machines.
+# Last checked for gcc-7.3, we are using gcc-6.3 on build machines (license is
+# valid there also).
 # ** If we change versions, recheck this! **
 # ** Static linking is allowed only for executables! **
 set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-libstdc++")
@@ -218,6 +102,13 @@ else()
     set(CMAKE_CXX_FLAGS_DEBUG "-g")
 endif()
 
+# ndebug
+option(NDEBUG "No debug" OFF)
+message(STATUS "NDEBUG: ${NDEBUG} (be careful CMAKE_BUILD_TYPE can also \
+append this flag)")
+if(NDEBUG)
+    add_definitions( -DNDEBUG )
+endif()
 # -----------------------------------------------------------------------------
 
 # default build type is debug
@@ -231,6 +122,11 @@ message(STATUS "CMake build type: ${CMAKE_BUILD_TYPE}")
 
 # threading
 find_package(Threads REQUIRED)
+
+# optional Ltalloc
+option(USE_LTALLOC "Use Ltalloc instead of default allocator (default OFF). \
+Set this to ON to link with Ltalloc." OFF)
+
 # optional readline
 option(USE_READLINE "Use GNU Readline library if available (default ON). \
 Set this to OFF to prevent linking with Readline even if it is available." ON)
@@ -241,16 +137,63 @@ if (USE_READLINE)
   endif()
 endif()
 
+# OpenSSL
+find_package(OpenSSL REQUIRED)
+
 set(libs_dir ${CMAKE_SOURCE_DIR}/libs)
 add_subdirectory(libs EXCLUDE_FROM_ALL)
 
+include_directories(SYSTEM ${GFLAGS_INCLUDE_DIR})
+include_directories(SYSTEM ${GLOG_INCLUDE_DIR})
+include_directories(SYSTEM ${FMT_INCLUDE_DIR})
+include_directories(SYSTEM ${ANTLR4_INCLUDE_DIR})
+include_directories(SYSTEM ${BZIP2_INCLUDE_DIR})
+include_directories(SYSTEM ${ZLIB_INCLUDE_DIR})
+include_directories(SYSTEM ${ROCKSDB_INCLUDE_DIR})
+include_directories(SYSTEM ${CAPNP_INCLUDE_DIR})
+# -----------------------------------------------------------------------------
+
+# openCypher parser -----------------------------------------------------------
+set(opencypher_frontend ${CMAKE_SOURCE_DIR}/src/query/frontend/opencypher)
+set(opencypher_generated ${opencypher_frontend}/generated)
+set(opencypher_grammar ${opencypher_frontend}/grammar/Cypher.g4)
+
+# enumerate all files that are generated from antlr
+set(antlr_opencypher_generated_src
+   ${opencypher_generated}/CypherLexer.cpp
+   ${opencypher_generated}/CypherParser.cpp
+   ${opencypher_generated}/CypherBaseVisitor.cpp
+   ${opencypher_generated}/CypherVisitor.cpp
+)
+
+# Provide a command to generate sources if missing. If this were a
+# custom_target, it would always run and we don't want that.
+add_custom_command(OUTPUT ${antlr_opencypher_generated_src}
+  COMMAND
+  ${CMAKE_COMMAND} -E make_directory ${opencypher_generated}
+  COMMAND
+  java -jar ${CMAKE_SOURCE_DIR}/libs/antlr-4.6-complete.jar -Dlanguage=Cpp -visitor -o ${opencypher_generated} -package antlropencypher ${opencypher_grammar}
+  WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
+  DEPENDS ${opencypher_grammar})
+
+# add custom target for generation
+add_custom_target(generate_opencypher_parser
+  DEPENDS ${antlr_opencypher_generated_src})
+
+add_library(antlr_opencypher_parser_lib STATIC ${antlr_opencypher_generated_src})
+target_link_libraries(antlr_opencypher_parser_lib antlr4)
+# -----------------------------------------------------------------------------
+
 # Optional subproject configuration -------------------------------------------
+option(POC "Build proof of concept binaries" OFF)
+option(EXPERIMENTAL "Build experimental binaries" OFF)
+option(CUSTOMERS "Build customer binaries" OFF)
 option(TEST_COVERAGE "Generate coverage reports from running memgraph" OFF)
 option(TOOLS "Build tools binaries" ON)
-option(QUERY_MODULES "Build query modules containing custom procedures" ON)
 option(ASAN "Build with Address Sanitizer. To get a reasonable performance option should be used only in Release or RelWithDebInfo build " OFF)
 option(TSAN "Build with Thread Sanitizer. To get a reasonable performance option should be used only in Release or RelWithDebInfo build " OFF)
 option(UBSAN "Build with Undefined Behaviour Sanitizer" OFF)
+option(THIN_LTO "Build with link time optimization" OFF)
 
 if (TEST_COVERAGE)
   string(TOLOWER ${CMAKE_BUILD_TYPE} lower_build_type)
@@ -261,10 +204,6 @@ if (TEST_COVERAGE)
   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-instr-generate -fcoverage-mapping")
 endif()
 
-if (MG_ENTERPRISE)
-  add_definitions(-DMG_ENTERPRISE)
-endif()
-
 if (ASAN)
   # Enable Addres sanitizer and get nicer stack traces in error messages.
   # NOTE: AddressSanitizer uses llvm-symbolizer binary from the Clang
@@ -312,19 +251,30 @@ if (UBSAN)
   # runtime library and c++ standard libraries are present.
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined -fno-omit-frame-pointer -fno-sanitize=vptr")
   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=undefined -fno-sanitize=vptr")
-  # Run program with environment variable UBSAN_OPTIONS=print_stacktrace=1.
-  # Make sure llvm-symbolizer binary is in path.
-  # To make the program abort on undefined behavior, use UBSAN_OPTIONS=halt_on_error=1.
+  # Run program with environment variable UBSAN_OPTIONS=print_stacktrace=1
+  # Make sure llvm-symbolizer binary is in path
 endif()
 
-set(MG_PYTHON_VERSION "" CACHE STRING "Specify the exact python version used by the query modules")
+if (THIN_LTO)
+  set(CMAKE_CXX_FLAGS"${CMAKE_CXX_FLAGS} -flto=thin")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -flto=thin")
+endif()
 
 # Add subprojects
 include_directories(src)
 add_subdirectory(src)
 
-# Release configuration
-add_subdirectory(release)
+if(POC)
+  add_subdirectory(poc)
+endif()
+
+if(EXPERIMENTAL)
+  add_subdirectory(experimental)
+endif()
+
+if(CUSTOMERS)
+  add_subdirectory(customers)
+endif()
 
 enable_testing()
 add_subdirectory(tests)
@@ -333,6 +283,58 @@ if(TOOLS)
   add_subdirectory(tools)
 endif()
 
-if(QUERY_MODULES)
-  add_subdirectory(query_modules)
-endif()
+# -----------------------------------------------------------------------------
+
+# ---- Setup CPack --------
+# General setup
+set(CPACK_PACKAGE_NAME memgraph)
+set(CPACK_PACKAGE_VENDOR "Memgraph Ltd.")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY
+    "High performance, in-memory, transactional graph database")
+set(CPACK_PACKAGE_VERSION_MAJOR ${memgraph_VERSION_MAJOR})
+set(CPACK_PACKAGE_VERSION_MINOR ${memgraph_VERSION_MINOR})
+set(CPACK_PACKAGE_VERSION_PATCH ${memgraph_VERSION_PATCH})
+set(CPACK_PACKAGE_VERSION_TWEAK ${memgraph_VERSION_TWEAK})
+set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${memgraph_VERSION}-${COMMIT_HASH}${CPACK_SYSTEM_NAME})
+
+# DEB specific
+# Instead of using "name <email>" format, we use "email (name)" to prevent
+# errors due to full stop, '.' at the end of "Ltd". (See: RFC 822)
+set(CPACK_DEBIAN_PACKAGE_MAINTAINER "tech@memgraph.com (Memgraph Ltd.)")
+set(CPACK_DEBIAN_PACKAGE_SECTION non-free/database)
+set(CPACK_DEBIAN_PACKAGE_HOMEPAGE https://memgraph.com)
+set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA
+    "${CMAKE_SOURCE_DIR}/release/debian/conffiles;"
+    "${CMAKE_SOURCE_DIR}/release/debian/copyright;"
+    "${CMAKE_SOURCE_DIR}/release/debian/prerm;"
+    "${CMAKE_SOURCE_DIR}/release/debian/postrm;"
+    "${CMAKE_SOURCE_DIR}/release/debian/postinst;")
+set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
+# Description formatting is important, summary must be followed with a newline and 1 space.
+set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}
+ Contains Memgraph, the graph database. It aims to deliver developers the
+ speed, simplicity and scale required to build the next generation of
+ applications driver by real-time connected data.")
+# Add `openssl` package to dependencies list. Used to generate SSL certificates.
+set(CPACK_DEBIAN_PACKAGE_DEPENDS "openssl (>= 1.1.0)")
+
+# RPM specific
+set(CPACK_RPM_PACKAGE_URL https://memgraph.com)
+set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION
+  /var /var/lib /var/log /etc/logrotate.d
+  /lib /lib/systemd /lib/systemd/system /lib/systemd/system/memgraph.service)
+set(CPACK_RPM_PACKAGE_REQUIRES_PRE "shadow-utils")
+# NOTE: user specfile has a bug in cmake 3.7.2, this needs to be patched
+# manually in: ~/cmake/share/cmake-3.7/Modules/CPackRPM.cmake line 2273
+# Or newer cmake version used
+set(CPACK_RPM_USER_BINARY_SPECFILE "${CMAKE_SOURCE_DIR}/release/rpm/memgraph.spec.in")
+# Description formatting is important, no line must be greater than 80 characters.
+set(CPACK_RPM_PACKAGE_DESCRIPTION "Contains Memgraph, the graph database.
+It aims to deliver developers the speed, simplicity and scale required to build
+the next generation of applications driver by real-time connected data.")
+# Add `openssl` package to dependencies list. Used to generate SSL certificates.
+set(CPACK_RPM_PACKAGE_REQUIRES "openssl >= 1.0.0")
+
+# All variables must be set before including.
+include(CPack)
+# ---- End Setup CPack ----

CODEOWNERS

@@ -1,4 +0,0 @@
-/docs/ @gitbuda
-/src/communication/ @antonio2368
-/src/query/ @the-joksim
-/src/storage/ @antonio2368

Doxyfile

@@ -51,7 +51,7 @@ PROJECT_BRIEF          = "The World's Most Powerful Graph Database"
 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
 # the logo to the output directory.
 
-PROJECT_LOGO           = docs/doxygen/memgraph_logo.png
+PROJECT_LOGO           = Doxylogo.png
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
 # into which the generated documentation will be written. If a relative path is
@@ -839,6 +839,7 @@ EXCLUDE_PATTERNS      += */Testing/*
 EXCLUDE_PATTERNS      += */tests/*
 EXCLUDE_PATTERNS      += */dist/*
 EXCLUDE_PATTERNS      += */tools/*
+EXCLUDE_PATTERNS      += */customers/*
 
 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
 # (namespaces, classes, functions, etc.) that should be excluded from the

README.md

@@ -1,21 +1,24 @@
-# Memgraph
+# memgraph
 
 Memgraph is an ACID compliant high performance transactional distributed
 in-memory graph database featuring runtime native query compiling, lock free
 data structures, multi-version concurrency control and asynchronous IO.
 
-## Development Documentation
+## dependencies
 
-Please continue in
-[Notion](https://www.notion.so/memgraph/memgraph-0428591638604c8385550e214ea9f3e6).
+Memgraph can be compiled using any modern c++ compiler. It mostly relies on
+the standard template library, however, some things do require external
+libraries.
 
-## User Documentation
+Some code contains linux-specific libraries and the build is only supported
+on a 64 bit linux kernel.
 
-Memgraph user documentation is maintained within
-[docs](https://github.com/memgraph/docs) repository. The documentation is also
-available on [GitBook](https://docs.memgraph.com).
-
-## Licences
-
-* [Community](release/LICENSE_COMMUNITY.md)
-* [Enterprise](release/LICENSE_ENTERPRISE.md)
+* linux
+* clang 3.8 (good c++11 support, especially lock free atomics)
+* antlr (compiler frontend)
+* cppitertools
+* fmt format
+* google benchmark
+* google test
+* glog
+* gflags

apollo_archives.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+import json
+import os
+import re
+import subprocess
+import sys
+
+# paths
+SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
+BUILD_OUTPUT_DIR = os.path.normpath(os.path.join(SCRIPT_DIR, "build_release", "output"))
+
+# helpers
+def run_cmd(cmd, cwd):
+    return subprocess.run(cmd, cwd=cwd, check=True,
+        stdout=subprocess.PIPE).stdout.decode("utf-8")
+
+# check project
+if re.search(r"release", os.environ.get("PROJECT", "")) is None:
+    print(json.dumps([]))
+    sys.exit(0)
+
+# generate archive
+deb_name = run_cmd(["find", ".", "-maxdepth", "1", "-type", "f",
+        "-name", "memgraph*.deb"], BUILD_OUTPUT_DIR).split("\n")[0][2:]
+arch = run_cmd(["dpkg", "--print-architecture"], BUILD_OUTPUT_DIR).split("\n")[0]
+version = deb_name.split("-")[1]
+# generate Debian package file name as expected by Debian Policy
+standard_deb_name = "memgraph_{}-1_{}.deb".format(version, arch)
+
+archive_path = os.path.relpath(os.path.join(BUILD_OUTPUT_DIR,
+        deb_name), SCRIPT_DIR)
+
+archives = [{
+    "name": "Release (deb package)",
+    "archive": archive_path,
+    "filename": standard_deb_name,
+}]
+
+print(json.dumps(archives, indent=4, sort_keys=True))

apollo_archives.yaml

@@ -0,0 +1,19 @@
+- name: Binaries
+  archive:
+    - build_debug/memgraph
+    - build_release/memgraph
+    - build_release/tools/src/mg_import_csv
+    - config
+  filename: binaries.tar.gz
+
+- name: Doxygen documentation
+  cd: docs/doxygen/html
+  archive:
+    - .
+  filename: documentation.tar.gz
+  host: true
+
+- name: Release (user docs)
+  project: ^NEVER$ # TODO (mferencevic): replace with 'release' once user documentation creation is fixed (couscous -> pandoc)
+  archive: docs/user_technical/docs.tar.gz
+  filename: release_user_docs.tar.gz

apollo_build.yaml

@@ -0,0 +1,85 @@
+- name: Diff build
+  project: ^mg-master-diff$
+  commands: |
+    # Copy untouched repository to parent folder.
+    cd ..
+    cp -r memgraph parent
+    cd memgraph
+
+    # Initialize and create documentation.
+    TIMEOUT=1200 ./init
+    doxygen Doxyfile
+
+    # Remove default build directory.
+    rm -r build
+
+    # Build debug binaries.
+    mkdir build_debug
+    cd build_debug
+    cmake ..
+    TIMEOUT=1200 make -j$THREADS
+
+    # Build coverage binaries.
+    cd ..
+    mkdir build_coverage
+    cd build_coverage
+    cmake -DTEST_COVERAGE=ON ..
+    TIMEOUT=1200 make -j$THREADS memgraph__unit
+
+    # Build release binaries.
+    cd ..
+    mkdir build_release
+    cd build_release
+    cmake -DCMAKE_BUILD_TYPE=release ..
+    TIMEOUT=1200 make -j$THREADS memgraph tools memgraph__macro_benchmark memgraph__stress memgraph__manual__card_fraud_generate_snapshot
+
+    # Checkout to parent commit and initialize.
+    cd ../../parent
+    git checkout HEAD~1
+    TIMEOUT=1200 ./init
+
+    # Build parent release binaries.
+    mkdir build_release
+    cd build_release
+    cmake -DCMAKE_BUILD_TYPE=release ..
+    TIMEOUT=1200 make -j$THREADS memgraph memgraph__macro_benchmark
+
+
+# release build is the default one
+- name: Release build
+  commands: |
+    TIMEOUT=1200 ./init
+    doxygen Doxyfile
+
+    # Remove default build directory.
+    rm -r build
+
+    # Build debug binaries.
+    mkdir build_debug
+    cd build_debug
+    cmake ..
+    TIMEOUT=1200 make -j$THREADS
+
+    # Build coverage binaries.
+    cd ..
+    mkdir build_coverage
+    cd build_coverage
+    cmake -DTEST_COVERAGE=ON ..
+    TIMEOUT=1200 make -j$THREADS memgraph__unit
+
+    # Build release binaries.
+    cd ..
+    mkdir build_release
+    cd build_release
+    cmake -DCMAKE_BUILD_TYPE=Release -DUSE_READLINE=OFF ..
+    TIMEOUT=1200 make -j$THREADS
+
+    # Create Debian package.
+    mkdir output
+    cd output
+    cpack -G DEB --config ../CPackConfig.cmake
+
+    # Create user technical documentation for community site.
+    cd ../../docs/user_technical
+    # TODO (mferencevic): uncomment this once couscous is replaced with pandoc
+    #./bundle_community

cmake/FindSeccomp.cmake

@@ -1,90 +0,0 @@
-#.rst:
-# FindSeccomp
-# -----------
-#
-# Try to locate the libseccomp library.
-# If found, this will define the following variables:
-#
-# ``Seccomp_FOUND``
-#     True if the seccomp library is available
-# ``Seccomp_INCLUDE_DIRS``
-#     The seccomp include directories
-# ``Seccomp_LIBRARIES``
-#     The seccomp libraries for linking
-#
-# If ``Seccomp_FOUND`` is TRUE, it will also define the following
-# imported target:
-#
-# ``Seccomp::Seccomp``
-#     The Seccomp library
-#
-# Since 5.44.0.
-
-#=============================================================================
-# Copyright (c) 2017 Martin Flöser <mgraesslin@kde.org>
-# Copyright (c) 2017 David Kahles <david.kahles96@gmail.com>
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# 1. Redistributions of source code must retain the copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the copyright
-#    notice, this list of conditions and the following disclaimer in the
-#    documentation and/or other materials provided with the distribution.
-# 3. The name of the author may not be used to endorse or promote products
-#    derived from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#=============================================================================
-
-find_package(PkgConfig QUIET)
-pkg_check_modules(PKG_Libseccomp QUIET libseccomp)
-
-find_path(Seccomp_INCLUDE_DIRS
-    NAMES
-        seccomp.h
-    HINTS
-        ${PKG_Libseccomp_INCLUDE_DIRS}
-)
-find_library(Seccomp_LIBRARIES
-    NAMES
-        seccomp
-    HINTS
-        ${PKG_Libseccomp_LIBRARY_DIRS}
-)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Seccomp
-    FOUND_VAR
-        Seccomp_FOUND
-    REQUIRED_VARS
-        Seccomp_LIBRARIES
-        Seccomp_INCLUDE_DIRS
-)
-
-if (Seccomp_FOUND AND NOT TARGET Seccomp::Seccomp)
-    add_library(Seccomp::Seccomp UNKNOWN IMPORTED)
-    set_target_properties(Seccomp::Seccomp PROPERTIES
-        IMPORTED_LOCATION "${Seccomp_LIBRARIES}"
-        INTERFACE_INCLUDE_DIRECTORIES "${Seccomp_INCLUDE_DIRS}"
-    )
-endif()
-
-mark_as_advanced(Seccomp_LIBRARIES Seccomp_INCLUDE_DIRS)
-
-include(FeatureSummary)
-set_package_properties(Seccomp PROPERTIES
-    URL "https://github.com/seccomp/libseccomp"
-    DESCRIPTION "The enhanced seccomp library."
-)

config/benchmarking.conf

@@ -0,0 +1,19 @@
+# MEMGRAPH DEFAULT BENCHMARKING CONFIG
+
+# NOTE: all paths are relative to the run folder
+# (where the executable is run)
+
+# no durability
+--durability-enabled=false
+--snapshot-on-exit=false
+--db-recover-on-startup=false
+
+# no GC
+--gc-cycle-sec=-1
+--skiplist_gc_interval=-1
+
+# no query execution time limit
+--query_execution_time_sec=-1
+
+# number of workers
+--num-workers=1

config/community.conf

@@ -0,0 +1,111 @@
+# Default Memgraph Configuration
+#
+# This is the default configuration for memgraph. Settings from this file will
+# be overridden by a configuration file in '$HOME/.memgraph/config', so you can
+# keep this file intact. Additional configuration can be specified in a file
+# pointed to by 'MEMGRAPH_CONFIG' environment variable or by passing arguments
+# on the command line.
+#
+# Each configuration setting is of the form: '--setting-name=value'.
+
+## Database
+
+# IP address the server should listen on.
+--interface=0.0.0.0
+
+# Port the server should listen on.
+--port=7687
+
+# Path to a SSL certificate file that should be used.
+--cert-file=/etc/memgraph/ssl/cert.pem
+
+# Path to a SSL key file that should be used.
+--key-file=/etc/memgraph/ssl/key.pem
+
+# Number of workers used by the Memgraph server. By default, this will be the
+# number of processing units available on the machine.
+# --num-workers=8
+
+# Interval, in seconds, when the garbage collection (GC) should run. GC is used
+# for releasing memory that is no longer needed. For example, deleted graph
+# elements which cannot be seen by any running or new transactions. If set to
+# -1 the GC will never run (use with caution, memory will never get released).
+--gc-cycle-sec=30
+
+# If Memgraph detects there is less available RAM than the given number in MB,
+# it will log a warning.
+--memory-warning-threshold=1024
+
+# The telemetry collects data about the machine that is executing the database
+# (CPU, Memory, OS and Kernel Information) and data about the database runtime
+# (CPU usage, Memory usage, Vertices and Edges count). It is used to provide a
+# better product, easy to disable and does not collect any sensitive data.
+--telemetry-enabled=true
+
+# Memgraph offers an option to store a certain amount of data on a disk. More
+# precisely, the user can pass a list of properties they wish to keep stored on
+# a disk. The property names have to be separated with a comma. An example
+# would be --properties-on-disk=biography,summary.
+#--properties-on-disk=
+
+## Query
+#
+# Various settings related to openCypher query execution.
+
+# Maximum allowed query execution time, in seconds. Any queries exceeding this
+# limit will be aborted. Setting to -1 removes the limit.
+--query-execution-time-sec=30
+
+# Cache generated query execution plans. This speeds up planning repeated
+# queries which produce multiple complex execution plans. The downside is that
+# some executions may use inferior plans if the database state changed. To
+# disable caching, set to false.
+#--query-plan-cache=false
+
+# Time to live for cached query plans, in seconds. This tries to minimize the
+# downside of caching by evicting old plans after the given time.
+#--query-plan-cache-ttl=60
+
+## Durability
+#
+# Memgraph can store database state to persistent storage. Two mechanisms
+# are used: snapshots store the total current database state while write-ahead
+# logs store small changes incrementally. They are used in tandem to provide
+# fast and storage-efficient persistence. Some aspects of snapshot taking
+# are configurable, while write-ahead logging is pre-configured for optimal
+# performance.
+--durability-enabled=true
+
+# Path to the directory where snapshots and write-ahead log files will be stored.
+--durability-directory=/var/lib/memgraph/durability
+
+# Recover the database on startup.
+--db-recover-on-startup=true
+
+# Interval of taking snapshots, in seconds. If set to -1, the snapshot feature
+# will be turned off.
+--snapshot-cycle-sec=300
+
+# Create a snapshot when closing Memgraph.
+--snapshot-on-exit=true
+
+# Maximum number of kept snapshots. Old snapshots will be deleted to make room
+# for new ones. If set to -1, the number of kept snapshots is unlimited.
+--snapshot-max-retained=3
+
+## Logging
+
+# Path to where the log should be stored.
+--log-file=/var/log/memgraph/memgraph.log
+
+# If true, log messages will go to stderr in addition to logfiles.
+#--also-log-to-stderr=true
+
+## Additional Configuration Inclusion
+
+# Include additional configuration from this file. Settings with the same name
+# will override previously read values. Note, that reading the configuration,
+# which called '--flag-file' will continue after inclusion. Therefore, settings
+# after '--flag-file' may override the included ones.
+#--flag-file=another.conf
+

config/durability_stress.conf

@@ -0,0 +1,15 @@
+# MEMGRAPH DEFAULT DURABILITY STRESS TESTING CONFIG
+
+# NOTE: all paths are relative to the run folder
+# (where the executable is run)
+
+# enable durability
+--durability-enabled=true
+--snapshot-cycle-sec=5
+--snapshot-on-exit=false
+--snapshot-max-retained=2
+
+--db-recover-on-startup=true
+
+# increase query timeout (10 min)
+--query-execution-time-sec=600

config/flags.yaml

@@ -1,95 +0,0 @@
-header: >-
-  Memgraph Configuration
-
-  This is the main configuration file for Memgraph. You can modify this file to
-  suit your specific needs. Additional configuration can be specified by
-  including another configuration file, in a file pointed to by the
-  'MEMGRAPH_CONFIG' environment variable or by passing arguments on the command
-  line.
-
-  Each configuration setting is in the form: '--setting-name=value'.
-
-footer: >-
-  Additional Configuration Inclusion
-
-  You can include additional configuration files from this file. Additional
-  files are processed after this file. Settings that are set in the additional
-  files will override previously set values. Additional configuration files are
-  specified with the '--flag-file' flag.
-
-  Example:
-
-  --flag-file=another.conf
-
-modifications:
-
-  # Each modification should consist of the following parameters:
-  #   * name: the name of the flag that should be modified (with underscores)
-  #           [string]
-  #   * value: the value that should be set instead of the binary provided
-  #            default value [string]
-  #   * override: set to `true` to uncomment the config option by default
-  #               [boolean]
-
-  - name: "data_directory"
-    value: "/var/lib/memgraph"
-    override: true
-
-  - name: "log_file"
-    value: "/var/log/memgraph/memgraph.log"
-    override: true
-
-  - name: "log_level"
-    value: "WARNING"
-    override: true
-
-  - name: "bolt_num_workers"
-    value: ""
-    override: false
-
-  - name: "storage_properties_on_edges"
-    value: "true"
-    override: true
-
-  - name: "storage_recover_on_startup"
-    value: "true"
-    override: true
-
-  - name: "storage_snapshot_interval_sec"
-    value: "300"
-    override: true
-
-  - name: "storage_snapshot_on_exit"
-    value: "true"
-    override: true
-
-  - name: "storage_snapshot_retention_count"
-    value: "3"
-    override: true
-
-  - name: "storage_wal_enabled"
-    value: "true"
-    override: true
-
-  - name: "telemetry_enabled"
-    value: "true"
-    override: true
-
-  - name: "query_modules_directory"
-    value: "/usr/lib/memgraph/query_modules"
-    override: true
-
-  - name: "auth_module_executable"
-    value: "/usr/lib/memgraph/auth_module/example.py"
-    override: false
-
-  - name: "memory_limit"
-    value: "0"
-    override: true 
-
-undocumented:
-  - "flag_file"
-  - "also_log_to_stderr"
-  - "help"
-  - "help_xml"
-  - "version"

config/generate.py

@@ -1,124 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import copy
-import os
-import subprocess
-import sys
-import textwrap
-
-import xml.etree.ElementTree as ET
-
-import yaml
-
-
-SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
-CONFIG_FILE = os.path.join(SCRIPT_DIR, "flags.yaml")
-WIDTH = 80
-
-
-def wrap_text(s, initial_indent="# "):
-    return "\n#\n".join(
-        map(lambda x: textwrap.fill(x, WIDTH, initial_indent=initial_indent,
-                                    subsequent_indent="# "), s.split("\n")))
-
-
-def extract_flags(binary_path):
-    ret = {}
-    data = subprocess.run([binary_path, "--help-xml"],
-                          stdout=subprocess.PIPE).stdout.decode("utf-8")
-    root = ET.fromstring(data)
-    for child in root:
-        if child.tag == "usage" and child.text.lower().count("warning"):
-            raise Exception("You should set the usage message!")
-        if child.tag == "flag":
-            flag = {}
-            for elem in child:
-                flag[elem.tag] = elem.text if elem.text is not None else ""
-            flag["override"] = False
-            ret[flag["name"]] = flag
-    return ret
-
-
-def apply_config_to_flags(config, flags):
-    flags = copy.deepcopy(flags)
-    for name in config["undocumented"]:
-        flags.pop(name)
-    for modification in config["modifications"]:
-        name = modification["name"]
-        if name not in flags:
-            print("WARNING: Flag '" + name + "' missing from binary!",
-                  file=sys.stderr)
-            continue
-        flags[name]["default"] = modification["value"]
-        flags[name]["override"] = modification["override"]
-    return flags
-
-
-def extract_sections(flags):
-    sections = []
-    other = []
-    current_section = ""
-    current_flags = []
-    for name in sorted(flags.keys()):
-        section = name.split("_")[0]
-        if section == current_section:
-            current_flags.append(name)
-        else:
-            if len(current_flags) < 2:
-                other.extend(current_flags)
-            else:
-                sections.append((current_section, current_flags))
-            current_section = section
-            current_flags = [name]
-    if len(current_flags) < 2:
-        other.extend(current_flags)
-    else:
-        sections.append((current_section, current_flags))
-    sections.append(("other", other))
-    assert set(sum(map(lambda x: x[1], sections), [])) == set(flags.keys()), \
-        "The section extraction algorithm lost some flags!"
-    return sections
-
-
-def generate_config_file(sections, flags):
-    ret = wrap_text(config["header"]) + "\n\n\n"
-    for section, section_flags in sections:
-        ret += wrap_text(section.capitalize(), initial_indent="## ") + "\n\n"
-        for name in section_flags:
-            flag = flags[name]
-            helpstr = flag["meaning"] + " [" + flag["type"] + "]"
-            ret += wrap_text(helpstr) + "\n"
-            prefix = "# " if not flag["override"] else ""
-            ret += prefix + "--" + flag["name"].replace("_", "-") + \
-                "=" + flag["default"] + "\n\n"
-        ret += "\n"
-    ret += wrap_text(config["footer"])
-    return ret.strip() + "\n"
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("memgraph_binary",
-                        help="path to Memgraph binary")
-    parser.add_argument("output_file",
-                        help="path where to store the generated Memgraph "
-                        "configuration file")
-    parser.add_argument("--config-file", default=CONFIG_FILE,
-                        help="path to generator configuration file")
-
-    args = parser.parse_args()
-    flags = extract_flags(args.memgraph_binary)
-
-    with open(args.config_file) as f:
-        config = yaml.safe_load(f)
-
-    flags = apply_config_to_flags(config, flags)
-    sections = extract_sections(flags)
-    data = generate_config_file(sections, flags)
-
-    dirname = os.path.dirname(args.output_file)
-    if dirname and not os.path.exists(dirname):
-        os.makedirs(dirname)
-
-    with open(args.output_file, "w") as f:
-        f.write(data)

config/stress.conf

@@ -0,0 +1,15 @@
+# MEMGRAPH DEFAULT STRESS TESTING CONFIG
+
+# NOTE: all paths are relative to the run folder
+# (where the executable is run)
+
+# enable durability
+--durability-enabled=true
+--snapshot-cycle-sec=600
+--snapshot-on-exit=true
+--snapshot-max-retained=1
+
+--db-recover-on-startup=false
+
+# increase query timeout (10 min)
+--query-execution-time-sec=600

config/testing.conf

@@ -0,0 +1,9 @@
+# MEMGRAPH DEFAULT TESTING CONFIG
+
+# NOTE: all paths are relative to the run folder
+# (where the executable is run)
+
+# no durability
+--durability-enabled=false
+--snapshot-on-exit=false
+--db-recover-on-startup=false

customers/CMakeLists.txt

@@ -0,0 +1,2 @@
+project(mg_customers)
+add_subdirectory(otto)

customers/elliott/README_internal.md

@@ -0,0 +1,70 @@
+DISCLAIMER: this is just an initial test, graph might not resemble
+the graph in the use case at all and the data might be completely
+irrelevant.
+
+We tried generating a few sample graphs from the vague description
+given in the use case doc. Then we tried writing queries that would
+solve the problem of updating nodes when a leaf value changes,
+assuming all the internal nodes compute only the sum function.
+
+We start by creating an index on `id` property to improve initial lookup
+performance:
+
+    CREATE INDEX ON :Leaf(id)
+
+Set values of all leafs to 1:
+
+    MATCH (u:Leaf) SET u.value = 1
+
+Now we initialize the values of all other nodes in the graph:
+
+    MATCH (u) WHERE NOT u:Leaf SET u.value = 0
+
+    MATCH (u) WITH u
+    ORDER BY u.topological_index DESC
+    MATCH (u)-->(v) SET u.value = u.value + v.value
+
+Change the value of a leaf:
+
+    MATCH (u:Leaf {id: "18"}) SET u.value = 10
+
+We have to reset all the updated nodes to a neutral element:
+
+    MATCH (u:Leaf {id: "18"})<-[* bfs]-(v)
+    WHERE NOT v:Leaf SET v.value = 0
+
+Finally, we recalculate their values in topological order:
+
+    MATCH (u:Leaf {id: "18"})<-[* bfs]-(v)
+    WITH v ORDER BY v.topological_index DESC
+    MATCH (v)-->(w) SET v.value = v.value + w.value
+
+There are a few assumptions made worth pointing out.
+
+* We are able to efficiently maintain topological order
+  of vertices in the graph.
+
+* It is possible to accumulate the value of the function.  Formally: 
+  $$f(x_1, x_2, ..., x_n) = g(...(g(g(x_1, x_2), x_3), ...), x_n)$$
+
+* There is a neutral element for the operation. However, this
+  assumption can be dropped by introducing an artificial neutral element.
+
+Number of operations required is proportional to the sum of degrees of affected
+nodes.
+
+We generated graph with $10^5$ nodes ($20\ 000$ nodes in each layer),  varied the
+degree distribution in node layers and measured time for the query to execute:
+
+| # |  Root-Category-Group degree | Group-CustomGroup-Leaf degree |   Time    |
+|:-:|:---------------------------:|:-----------------------------:|:---------:|
+| 1 |            [1, 10]          |           [20, 40]            |   ~1.1s   |
+| 2 |            [1, 10]          |          [50, 100]            |   ~2.5s   |
+| 3 |           [10, 50]          |          [50, 100]            |   ~3.3s   |
+
+Due to the structure of the graph, update of a leaf required update of almost
+all the nodes in the graph so we don't show times required for initial graph
+update and update after leaf change separately.
+
+However, there is not enough info on the use case to make the test more
+sophisticated.

customers/elliott/README_public.md

@@ -0,0 +1,71 @@
+---
+title: "Elliott Management"
+subtitle: "Proof of Concept Report"
+header-title: "Elliott Management POC"
+date: 2017-10-28
+copyright: "©2017 Memgraph Ltd. All rights reserved."
+titlepage: true
+titlepage-color: FFFFFF
+titlepage-text-color: 101010
+titlepage-rule-color: 101010
+titlepage-rule-height: 1
+...
+
+# Introduction
+
+We tried generating a few sample graphs from the description given at
+the in-person meetings.  Then, we tried writing queries that would solve
+the problem of updating nodes when a leaf value changes, assuming all the
+internal nodes compute only the sum function.
+
+# Technical details
+
+We started by creating an index on `id` property to improve initial lookup
+performance:
+
+    CREATE INDEX ON :Leaf(id)
+
+Afther that, we set values of all leafs to 1:
+
+    MATCH (u:Leaf) SET u.value = 1
+
+We then initialized the values of all other nodes in the graph:
+
+    MATCH (u) WHERE NOT u:Leaf SET u.value = 0
+
+    MATCH (u) WITH u
+    ORDER BY u.topological_index DESC
+    MATCH (u)-->(v) SET u.value = u.value + v.value
+
+Leaf value change and update of affected values in the graph can
+be done using three queries. To change the value of a leaf:
+
+    MATCH (u:Leaf {id: "18"}) SET u.value = 10
+
+Then we had to reset all the affected nodes to the neutral element:
+
+    MATCH (u:Leaf {id: "18"})<-[* bfs]-(v)
+    WHERE NOT v:Leaf SET v.value = 0
+
+Finally, we recalculated their values in topological order:
+
+    MATCH (u:Leaf {id: "18"})<-[* bfs]-(v)
+    WITH v ORDER BY v.topological_index DESC
+    MATCH (v)-->(w) SET v.value = v.value + w.value
+
+There are a few assumptions necessary for the approach above to work.
+
+* We are able to maintain topological order of vertices during graph
+  structure changes.  
+
+* It is possible to accumulate the value of the function.  Formally: 
+  $$f(x_1, x_2, ..., x_n) = g(...(g(g(x_1, x_2), x_3), ...), x_n)$$
+
+* There is a neutral element for the operation. However, this
+  assumption can be dropped by introducing an artificial neutral element.
+
+Above assumptions could be changed, relaxed or dropped, depending on the
+specifics of the use case.
+
+Number of operations required is proportional to the sum of degrees of affected
+nodes. 

customers/elliott/commands.txt

@@ -0,0 +1,12 @@
+CREATE INDEX ON :Leaf(id);
+MATCH (u:Leaf) SET u.value = 1;
+MATCH (u) WHERE NOT u:Leaf SET u.value = 0;
+MATCH (u) WITH u 
+ORDER BY u.topological_index DESC
+MATCH (u)-->(v) SET u.value = u.value + v.value;
+MATCH (u:Leaf {id: "85000"}) SET u.value = 10;
+MATCH (u:Leaf {id: "85000"})<-[* bfs]-(v) 
+WHERE NOT v:Leaf SET v.value = 0;
+MATCH (u:Leaf {id: "85000"})<-[* bfs]-(v)
+WITH v ORDER BY v.topological_index DESC
+MATCH (v)-->(w) SET v.value = v.value + w.value;

customers/elliott/generate_dag

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Generates a DAG from JSON spec in [config] and outputs nodes to
+[filename]_nodes, and edges to [filename]_edges in format convertible
+to Memgraph snapshot.
+
+Here's an example JSON spec:
+
+    {
+        "layers": [
+            {
+                "name": "A",
+                "sublayers": 1,
+                "degree_lo": 1,
+                "degree_hi": 3,
+                "nodes": 4
+            },
+            {
+                "name": "B",
+                "sublayers": 3,
+                "degree_lo": 2,
+                "degree_hi": 3,
+                "nodes": 10
+            },
+            {
+                "name": "C",
+                "sublayers": 1,
+                "degree_lo": 1,
+                "degree_hi": 1,
+                "nodes": 5
+            }
+        ]
+    }
+
+Nodes from each layer will be randomly divided into sublayers.  A node can
+only have edges pointing to nodes in lower sublayers of the same layer, or
+to nodes from the layer directly below it. Out-degree is chosen uniformly
+random from [degree_lo, degree_hi] interval."""
+
+import argparse
+from itertools import accumulate
+import json
+import random
+
+
+def _split_into_sum(n, k):
+    assert 1 <= n, "n should be at least 1"
+    assert k <= n, "k shouldn't be greater than n"
+    xs = [0] + sorted(random.sample(range(1, n), k-1)) + [n]
+    return [b - a for a, b in zip(xs, xs[1:])]
+
+
+def generate_dag(graph_config, seed=None):
+    random.seed(seed)
+
+    nodes = []
+    edges = []
+
+    layer_lo = 1
+    for layer in graph_config:
+        sublayers = _split_into_sum(layer['nodes'], layer['sublayers'])
+        sub_range = accumulate([layer_lo] + sublayers)
+        layer['sublayer_range'] = list(sub_range)
+        nodes.extend([
+            (u, layer['name'])
+            for u in range(layer_lo, layer_lo + layer['nodes'])
+        ])
+        layer_lo += layer['nodes']
+
+    edges = []
+
+    for layer, next_layer in zip(graph_config, graph_config[1:]):
+        degree_lo = layer['degree_lo']
+        degree_hi = layer['degree_hi']
+
+        sub_range = layer['sublayer_range']
+        sub_range_next = next_layer['sublayer_range']
+
+        layer_lo = sub_range[0]
+        next_layer_hi = sub_range_next[-1]
+
+        for sub_lo, sub_hi in zip(sub_range, sub_range[1:]):
+            for u in range(sub_lo, sub_hi):
+                num_edges = random.randint(degree_lo, degree_hi)
+                for _ in range(num_edges):
+                    v = random.randint(sub_hi, next_layer_hi - 1)
+                    edges.append((u, v))
+
+        for sub_lo, sub_hi in zip(sub_range_next, sub_range_next[1:]):
+            for u in range(sub_lo, sub_hi):
+                v = random.randint(layer_lo, sub_lo - 1)
+                edges.append((v, u))
+
+    return nodes, edges
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description=__doc__)
+    parser.add_argument('config', type=str, help='graph config JSON file')
+    parser.add_argument('filename', type=str,
+                        help='nodes will be stored to filename_nodes, '
+                        'edges to filename_edges')
+    parser.add_argument('--seed', type=int,
+                        help='seed for the random generator (default = '
+                        'current system time)')
+    args = parser.parse_args()
+
+    with open(args.config, 'r') as f:
+        graph_config = json.loads(f.read())['layers']
+
+    nodes, edges = generate_dag(graph_config, seed=args.seed)
+
+    #  print nodes into CSV file
+    with open('{}_nodes'.format(args.filename), 'w') as out:
+        out.write('nodeId:ID(Node),name,topological_index:Int,:LABEL\n')
+        for node_id, layer in nodes:
+            out.write('{0},{1}{0},{0},{1}\n'.format(node_id, layer))
+
+    # print edges into CSV file
+    with open('{}_edges'.format(args.filename), 'w') as out:
+        out.write(':START_ID(Node),:END_ID(Node),:TYPE\n')
+        for u, v in edges:
+            out.write('{},{},child\n'.format(u, v))

customers/elliott/graph1.json

@@ -0,0 +1,39 @@
+{
+    "layers": [
+        { 
+            "name": "Root",
+            "sublayers": 1,
+            "degree_lo": 1,
+            "degree_hi": 10,
+            "nodes": 20000
+        },
+        { 
+            "name": "Category",
+            "sublayers": 5,
+            "degree_lo": 1,
+            "degree_hi": 10,
+            "nodes": 20000
+        },
+        {   
+            "name": "Group",
+            "sublayers": 1,
+            "degree_lo": 20,
+            "degree_hi": 40,
+            "nodes": 20000
+        },
+        {
+            "name": "CustomGroup",
+            "sublayers": 15,
+            "degree_lo": 20,
+            "degree_hi": 40,
+            "nodes": 20000
+        },
+        { 
+            "name": "Leaf",
+            "sublayers": 1,
+            "degree_lo": 1,
+            "degree_hi": 1,
+            "nodes": 20000
+        }
+    ]
+}

customers/elliott/graph2.json

@@ -0,0 +1,39 @@
+{
+    "layers": [
+        { 
+            "name": "Root",
+            "sublayers": 1,
+            "degree_lo": 1,
+            "degree_hi": 10,
+            "nodes": 20000
+        },
+        { 
+            "name": "Category",
+            "sublayers": 5,
+            "degree_lo": 1,
+            "degree_hi": 10,
+            "nodes": 20000
+        },
+        {   
+            "name": "Group",
+            "sublayers": 1,
+            "degree_lo": 50,
+            "degree_hi": 100,
+            "nodes": 20000
+        },
+        {
+            "name": "CustomGroup",
+            "sublayers": 15,
+            "degree_lo": 50,
+            "degree_hi": 100,
+            "nodes": 20000
+        },
+        { 
+            "name": "Leaf",
+            "sublayers": 1,
+            "degree_lo": 50,
+            "degree_hi": 100,
+            "nodes": 20000
+        }
+    ]
+}

customers/elliott/graph3.json

@@ -0,0 +1,39 @@
+{
+    "layers": [
+        { 
+            "name": "Root",
+            "sublayers": 1,
+            "degree_lo": 10,
+            "degree_hi": 50,
+            "nodes": 20000
+        },
+        { 
+            "name": "Category",
+            "sublayers": 5,
+            "degree_lo": 10,
+            "degree_hi": 50,
+            "nodes": 20000
+        },
+        {   
+            "name": "Group",
+            "sublayers": 1,
+            "degree_lo": 50,
+            "degree_hi": 100,
+            "nodes": 20000
+        },
+        {
+            "name": "CustomGroup",
+            "sublayers": 15,
+            "degree_lo": 50,
+            "degree_hi": 100,
+            "nodes": 20000
+        },
+        { 
+            "name": "Leaf",
+            "sublayers": 1,
+            "degree_lo": 50,
+            "degree_hi": 100,
+            "nodes": 20000
+        }
+    ]
+}

customers/otto/CMakeLists.txt

@@ -0,0 +1,3 @@
+set(exec_name customers_otto_parallel_connected_components)
+add_executable(${exec_name} parallel_connected_components.cpp)
+target_link_libraries(${exec_name} memgraph_lib)

customers/otto/connected_components_test.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+This script attempts to evaluate the feasibility of using Memgraph for
+Otto group's usecase. The usecase is finding connected componentes in
+a large, very sparse graph (cca 220M nodes, 250M edges), based on a dynamic
+inclusion / exclusion of edges (w.r.t variable parameters and the source node
+type).
+
+This implementation defines a random graph with the given number of nodes
+and edges and looks for connected components using breadth-first expansion.
+Edges are included / excluded based on a simple expression, only demonstrating
+possible usage.
+"""
+
+from argparse import ArgumentParser
+import logging
+from time import time
+from collections import defaultdict
+from math import log2
+from random import randint
+
+from neo4j.v1 import GraphDatabase
+
+log = logging.getLogger(__name__)
+
+
+def generate_graph(sess, node_count, edge_count):
+    # An index that will speed-up edge creation.
+    sess.run("CREATE INDEX ON :Node(id)").consume()
+
+    # Create the given number of nodes with a randomly selected type from:
+    # [0.5, 1.5, 2.5].
+    sess.run(("UNWIND range(0, {} - 1) AS id CREATE "
+              "(:Node {{id: id, type: 0.5 + tointeger(rand() * 3)}})").format(
+                 node_count)).consume()
+
+    # Create the given number of edges, each with a 'value' property of
+    # a random [0, 3.0) float. Each edge connects two random nodes, so the
+    # expected node degree is (edge_count * 2 / node_count). Generate edges
+    # so the connectivity is non-uniform (to produce connected components of
+    # various sizes).
+    sess.run(("UNWIND range(0, {0} - 1) AS id WITH id "
+              "MATCH (from:Node {{id: tointeger(rand() * {1})}}), "
+              "(to:Node {{id: tointeger(rand() * {1} * id / {0})}}) "
+              "CREATE (from)-[:Edge {{value: 3 * rand()}}]->(to)").format(
+                 edge_count, node_count)).consume()
+
+
+def get_connected_ids(sess, node_id):
+    # Matches a node with the given ID and returns the IDs of all the nodes
+    # it is connected to. Note that within the BFS lambda expression there
+    # is an expression used to filter out edges expanded over.
+    return sess.run((
+        "MATCH (from:Node {{id: {}}})-"
+        "[*bfs (e, n | abs(from.type - e.value) < 0.80)]-(d) "
+        "RETURN count(*) AS c").format(node_id)).data()[0]['c']
+
+
+def parse_args():
+    parser = ArgumentParser(description=__doc__)
+    parser.add_argument('--endpoint', type=str, default='localhost:7687',
+                        help='Memgraph instance endpoint. ')
+    parser.add_argument('--node-count', type=int, default=1000,
+                        help='The number of nodes in the graph')
+    parser.add_argument('--edge-count', type=int, default=1000,
+                        help='The number of edges in the graph')
+    parser.add_argument('--sample-count', type=int, default=None,
+                        help='The number of samples to take')
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    logging.basicConfig(level=logging.INFO)
+    log.info("Memgraph - Otto test database generator")
+    logging.getLogger("neo4j").setLevel(logging.WARNING)
+
+    driver = GraphDatabase.driver(
+        'bolt://' + args.endpoint,
+        auth=("ignored", "ignored"),
+        encrypted=False)
+    sess = driver.session()
+
+    sess.run("MATCH (n) DETACH DELETE n").consume()
+
+    log.info("Generating graph with %s nodes and %s edges...",
+             args.node_count, args.edge_count)
+    generate_graph(sess, args.node_count, args.edge_count)
+
+    # Track which vertices have been found as part of a component.
+    start_time = time()
+    max_query_time = 0
+    log.info("Looking for connected components...")
+    # Histogram of log2 sizes of connected components found.
+    histogram = defaultdict(int)
+    sample_count = args.sample_count if args.sample_count else args.node_count
+    for i in range(sample_count):
+        node_id = randint(0, args.node_count - 1)
+        query_start_time = time()
+        log2_size = int(log2(1 + get_connected_ids(sess, node_id)))
+        max_query_time = max(max_query_time, time() - query_start_time)
+        histogram[log2_size] += 1
+    elapsed = time() - start_time
+    log.info("Connected components found in %.2f sec (avg %.2fms, max %.2fms)",
+             elapsed, elapsed / sample_count * 1000, max_query_time * 1000)
+    log.info("Component size histogram (count | range)")
+    for log2_size, count in sorted(histogram.items()):
+        log.info("\t%5d | %d - %d", count, 2 ** log2_size,
+                 2 ** (log2_size + 1) - 1)
+
+    sess.close()
+    driver.close()
+
+
+if __name__ == '__main__':
+    main()

customers/otto/parallel_connected_components.cpp

@@ -0,0 +1,207 @@
+#include <algorithm>
+#include <limits>
+#include <mutex>
+#include <random>
+#include <set>
+#include <stack>
+#include <thread>
+
+#include "gflags/gflags.h"
+#include "glog/logging.h"
+
+#include "data_structures/union_find.hpp"
+#include "database/graph_db.hpp"
+#include "database/graph_db_accessor.hpp"
+#include "storage/property_value.hpp"
+#include "threading/sync/spinlock.hpp"
+#include "utils/bound.hpp"
+#include "utils/timer.hpp"
+
+DEFINE_int32(thread_count, 1, "Number of threads");
+DEFINE_int32(vertex_count, 1000, "Number of vertices");
+DEFINE_int32(edge_count, 1000, "Number of edges");
+DECLARE_int32(gc_cycle_sec);
+
+static const std::string kLabel{"kLabel"};
+static const std::string kProperty{"kProperty"};
+
+void GenerateGraph(database::GraphDb &db) {
+  {
+    database::GraphDbAccessor dba{db};
+    dba.BuildIndex(dba.Label(kLabel), dba.Property(kProperty));
+    dba.Commit();
+  }
+
+  // Randomize the sequence of IDs of created vertices and edges to simulate
+  // real-world lack of locality.
+  auto make_id_vector = [](size_t size) {
+    gid::Generator generator{0};
+    std::vector<gid::Gid> ids(size);
+    for (size_t i = 0; i < size; ++i)
+      ids[i] = generator.Next(std::experimental::nullopt);
+    std::random_shuffle(ids.begin(), ids.end());
+    return ids;
+  };
+
+  std::vector<VertexAccessor> vertices;
+  vertices.reserve(FLAGS_vertex_count);
+  {
+    CHECK(FLAGS_vertex_count % FLAGS_thread_count == 0)
+        << "Thread count must be a factor of vertex count";
+    LOG(INFO) << "Generating " << FLAGS_vertex_count << " vertices...";
+    utils::Timer timer;
+    auto vertex_ids = make_id_vector(FLAGS_vertex_count);
+
+    std::vector<std::thread> threads;
+    SpinLock vertices_lock;
+    for (int i = 0; i < FLAGS_thread_count; ++i) {
+      threads.emplace_back([&db, &vertex_ids, &vertices, &vertices_lock, i]() {
+        database::GraphDbAccessor dba{db};
+        auto label = dba.Label(kLabel);
+        auto property = dba.Property(kProperty);
+        auto batch_size = FLAGS_vertex_count / FLAGS_thread_count;
+        for (int j = i * batch_size; j < (i + 1) * batch_size; ++j) {
+          auto vertex = dba.InsertVertex(vertex_ids[j]);
+          vertex.add_label(label);
+          vertex.PropsSet(property, static_cast<int64_t>(vertex_ids[j]));
+          vertices_lock.lock();
+          vertices.emplace_back(vertex);
+          vertices_lock.unlock();
+        }
+        dba.Commit();
+      });
+    }
+    for (auto &t : threads) t.join();
+    LOG(INFO) << "Generated " << FLAGS_vertex_count << " vertices in "
+              << timer.Elapsed().count() << " seconds.";
+  }
+  {
+    database::GraphDbAccessor dba{db};
+    for (int i = 0; i < FLAGS_vertex_count; ++i)
+      vertices[i] = *dba.Transfer(vertices[i]);
+
+    LOG(INFO) << "Generating " << FLAGS_edge_count << " edges...";
+    auto edge_ids = make_id_vector(FLAGS_edge_count);
+    std::mt19937 pseudo_rand_gen{std::random_device{}()};
+    std::uniform_int_distribution<> rand_dist{0, FLAGS_vertex_count - 1};
+    auto edge_type = dba.EdgeType("edge");
+    utils::Timer timer;
+    for (int i = 0; i < FLAGS_edge_count; ++i)
+      dba.InsertEdge(vertices[rand_dist(pseudo_rand_gen)],
+                     vertices[rand_dist(pseudo_rand_gen)], edge_type,
+                     edge_ids[i]);
+    dba.Commit();
+    LOG(INFO) << "Generated " << FLAGS_edge_count << " edges in "
+              << timer.Elapsed().count() << " seconds.";
+  }
+}
+
+auto EdgeIteration(database::GraphDb &db) {
+  database::GraphDbAccessor dba{db};
+  int64_t sum{0};
+  for (auto edge : dba.Edges(false)) sum += edge.from().gid() + edge.to().gid();
+  return sum;
+}
+
+auto VertexIteration(database::GraphDb &db) {
+  database::GraphDbAccessor dba{db};
+  int64_t sum{0};
+  for (auto v : dba.Vertices(false))
+    for (auto e : v.out()) sum += e.gid() + e.to().gid();
+  return sum;
+}
+
+auto ConnectedComponentsEdges(database::GraphDb &db) {
+  UnionFind<int64_t> connectivity{FLAGS_vertex_count};
+  database::GraphDbAccessor dba{db};
+  for (auto edge : dba.Edges(false))
+    connectivity.Connect(edge.from().gid(), edge.to().gid());
+  return connectivity.Size();
+}
+
+auto ConnectedComponentsVertices(database::GraphDb &db) {
+  UnionFind<int64_t> connectivity{FLAGS_vertex_count};
+  database::GraphDbAccessor dba{db};
+  for (auto from : dba.Vertices(false)) {
+    for (auto out_edge : from.out())
+      connectivity.Connect(from.gid(), out_edge.to().gid());
+  }
+  return connectivity.Size();
+}
+
+auto ConnectedComponentsVerticesParallel(database::GraphDb &db) {
+  UnionFind<int64_t> connectivity{FLAGS_vertex_count};
+  SpinLock connectivity_lock;
+
+  // Define bounds of vertex IDs for each thread to use.
+  std::vector<PropertyValue> bounds;
+  for (int64_t i = 0; i < FLAGS_thread_count; ++i)
+    bounds.emplace_back(i * FLAGS_vertex_count / FLAGS_thread_count);
+  bounds.emplace_back(std::numeric_limits<int64_t>::max());
+
+  std::vector<std::thread> threads;
+  for (int i = 0; i < FLAGS_thread_count; ++i) {
+    threads.emplace_back(
+        [&connectivity, &connectivity_lock, &bounds, &db, i]() {
+          database::GraphDbAccessor dba{db};
+          for (auto from :
+               dba.Vertices(dba.Label(kLabel), dba.Property(kProperty),
+                            utils::MakeBoundInclusive(bounds[i]),
+                            utils::MakeBoundExclusive(bounds[i + 1]), false)) {
+            for (auto out_edge : from.out()) {
+              std::lock_guard<SpinLock> lock{connectivity_lock};
+              connectivity.Connect(from.gid(), out_edge.to().gid());
+            }
+          }
+        });
+  }
+  for (auto &t : threads) t.join();
+  return connectivity.Size();
+}
+
+auto Expansion(database::GraphDb &db) {
+  std::vector<int> component_ids(FLAGS_vertex_count, -1);
+  int next_component_id{0};
+  std::stack<VertexAccessor> expansion_stack;
+  database::GraphDbAccessor dba{db};
+  for (auto v : dba.Vertices(false)) {
+    if (component_ids[v.gid()] != -1) continue;
+    auto component_id = next_component_id++;
+    expansion_stack.push(v);
+    while (!expansion_stack.empty()) {
+      auto next_v = expansion_stack.top();
+      expansion_stack.pop();
+      if (component_ids[next_v.gid()] != -1) continue;
+      component_ids[next_v.gid()] = component_id;
+      for (auto e : next_v.out()) expansion_stack.push(e.to());
+      for (auto e : next_v.in()) expansion_stack.push(e.from());
+    }
+  }
+
+  return next_component_id;
+}
+
+int main(int argc, char **argv) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  google::InitGoogleLogging(argv[0]);
+  FLAGS_gc_cycle_sec = -1;
+
+  database::SingleNode db;
+  GenerateGraph(db);
+  auto timed_call = [&db](auto callable, const std::string &descr) {
+    LOG(INFO) << "Running " << descr << "...";
+    utils::Timer timer;
+    auto result = callable(db);
+    LOG(INFO) << "\tDone in " << timer.Elapsed().count()
+              << " seconds, result: " << result;
+  };
+  timed_call(EdgeIteration, "Edge iteration");
+  timed_call(VertexIteration, "Vertex iteration");
+  timed_call(ConnectedComponentsEdges, "Connected components - Edges");
+  timed_call(ConnectedComponentsVertices, "Connected components - Vertices");
+  timed_call(ConnectedComponentsVerticesParallel,
+             "Parallel connected components - Vertices");
+  timed_call(Expansion, "Expansion");
+
+  return 0;
+}

customers/ravelin/fraud_detection.oc

@@ -0,0 +1,5 @@
+WITH tointeger(rand() * 40000000) AS from_id
+MATCH (from:Node {id : from_id}) WITH from
+MATCH path = (from)-[*bfs..50 (e, n | degree(n) < 50)]->(to) WITH path LIMIT 10000 WHERE to.fraudulent
+RETURN path, size(path)
+

customers/ravelin/snapshot_gen_config.json

@@ -0,0 +1,31 @@
+{
+   "indexes":[
+      "Node.id"
+   ],
+   "nodes":[
+      {
+         "count":40000000,
+         "labels":[
+            "Node"
+         ],
+         "properties":{
+            "id":{
+               "type":"counter",
+               "param":"Node.id"
+            },
+            "fraudulent":{
+               "type":"bernoulli",
+               "param":0.0005
+            }
+         }
+      }
+   ],
+   "edges":[
+      {
+         "count":80000000,
+         "from":"Node",
+         "to":"Node",
+         "type":"Edge"
+      }
+   ]
+}

customers/strata2018/card_fraud_config.json

@@ -0,0 +1,20 @@
+{
+  "indexes" : ["Card.id", "Pos.id", "Transaction.fraud_reported"],
+  "nodes" : [
+    {
+      "count_per_worker" : 1250000,
+      "label" : "Card"
+    },
+    {
+      "count_per_worker" : 1250000,
+      "label" : "Pos"
+    },
+    {
+      "count_per_worker" : 2500000,
+      "label" : "Transaction"
+    }
+  ],
+  "compromised_pos_probability" : 0.2,
+  "fraud_reported_probability" : 0.1,
+  "hop_probability" : 0.1
+}

docs/.gitignore

@@ -1,2 +1,6 @@
 doxygen/html/
 doxygen/latex/
+user_technical/.bundle_community/
+user_technical/.couscous/
+user_technical/couscous.phar
+user_technical/docs.tar.gz

docs/dev/cpp-code-conventions.md

@@ -0,0 +1,193 @@
+# C++ Code Conventions
+
+This chapter describes code conventions which should be followed when writing
+C++ code.
+
+## Code Style
+
+Memgraph uses the Google Style Guide for C++ in most of its code. You should
+follow them whenever writing new code. The style guide can be found
+[here](https://google.github.io/styleguide/cppguide.html).
+
+### Additional Style Conventions
+
+Code style conventions which are left undefined by Google are specified here.
+
+#### Template parameter naming
+
+Template parameter names should start with capital letter 'T' followed by a
+short descriptive name. For example:
+
+```cpp
+template <typename TKey, typename TValue>
+class KeyValueStore
+```
+
+## Code Formatting
+
+You should install `clang-format` and run it on code you change or add. The
+root of Memgraph's project contains the `.clang-format` file, which specifies
+how formatting should behave. Running `clang-format -style=file` in the
+project's root will read the file and behave as expected. For ease of use, you
+should integrate formatting with your favourite editor.
+
+The code formatting isn't enforced, because sometimes manual formatting may
+produce better results. Though, running `clang-format` is strongly encouraged.
+
+## Documentation
+
+Besides following the comment guidelines from [Google Style
+Guide](https://google.github.io/styleguide/cppguide.html#Comments), your
+documentation of the public API should be
+[Doxygen](https://github.com/doxygen/doxygen) compatible. For private parts of
+the code or for comments accompanying the implementation, you are free to
+break doxygen compatibility. In both cases, you should write your
+documentation as full sentences, correctly written in English.
+
+## Doxygen
+
+To start a Doxygen compatible documentation string, you should open your
+comment with either a JavaDoc style block comment (`/**`) or a line comment
+containing 3 slashes (`///`). Take a look at the 2 examples below.
+
+### Block Comment
+
+```cpp
+/**
+ * One sentence, brief description.
+ *
+ * Long form description.
+ */
+```
+
+### Line Comment
+
+```cpp
+///
+/// One sentence, brief description.
+///
+/// Long form description.
+///
+```
+
+If you only have a brief description, you may collapse the documentation into
+a single line.
+
+### Block Comment
+
+```cpp
+/** Brief description. */
+```
+
+### Line Comment
+
+```cpp
+/// Brief description.
+```
+
+Whichever style you choose, keep it consistent across the whole file.
+
+Doxygen supports various commands in comments, such as `@file` and `@param`.
+These help Doxygen to render specified things differently or to track them for
+cross referencing. If you want to learn more, take a look at these two links:
+
+  * http://www.stack.nl/~dimitri/doxygen/manual/docblocks.html
+  * http://www.stack.nl/~dimitri/doxygen/manual/commands.html
+
+## Examples
+
+Below are a few examples of documentation from the codebase.
+
+### Function
+
+```cpp
+/**
+ * Removes whitespace characters from the start and from the end of a string.
+ *
+ * @param s String that is going to be trimmed.
+ *
+ * @return Trimmed string.
+ */
+inline std::string Trim(const std::string &s);
+```
+
+### Class
+
+```cpp
+/** Base class for logical operators.
+ *
+ *  Each operator describes an operation, which is to be performed on the
+ *  database. Operators are iterated over using a @c Cursor. Various operators
+ *  can serve as inputs to others and thus a sequence of operations is formed.
+ */
+class LogicalOperator
+    : public ::utils::Visitable<HierarchicalLogicalOperatorVisitor> {
+ public:
+  /** Constructs a @c Cursor which is used to run this operator.
+   *
+   *  @param GraphDbAccessor Used to perform operations on the database.
+   */
+  virtual std::unique_ptr<Cursor> MakeCursor(GraphDbAccessor &db) const = 0;
+
+  /** Return @c Symbol vector where the results will be stored.
+   *
+   *  Currently, outputs symbols are only generated in @c Produce operator.
+   *  @c Skip, @c Limit and @c OrderBy propagate the symbols from @c Produce (if
+   *  it exists as input operator). In the future, we may want this method to
+   *  return the symbols that will be set in this operator.
+   *
+   *  @param SymbolTable used to find symbols for expressions.
+   *  @return std::vector<Symbol> used for results.
+   */
+  virtual std::vector<Symbol> OutputSymbols(const SymbolTable &) const {
+    return std::vector<Symbol>();
+  }
+
+  virtual ~LogicalOperator() {}
+};
+```
+
+### File Header
+
+```cpp
+/// @file visitor.hpp
+///
+/// This file contains the generic implementation of visitor pattern.
+///
+/// There are 2 approaches to the pattern:
+///
+///   * classic visitor pattern using @c Accept and @c Visit methods, and
+///   * hierarchical visitor which also uses @c PreVisit and @c PostVisit
+///   methods.
+///
+/// Classic Visitor
+/// ===============
+///
+/// Explanation on the classic visitor pattern can be found from many
+/// sources, but here is the link to hopefully most easily accessible
+/// information: https://en.wikipedia.org/wiki/Visitor_pattern
+///
+/// The idea behind the generic implementation of classic visitor pattern is to
+/// allow returning any type via @c Accept and @c Visit methods. Traversing the
+/// class hierarchy is relegated to the visitor classes. Therefore, visitor
+/// should call @c Accept on children when visiting their parents. To implement
+/// such a visitor refer to @c Visitor and @c Visitable classes.
+///
+/// Hierarchical Visitor
+/// ====================
+///
+/// Unlike the classic visitor, the intent of this design is to allow the
+/// visited structure itself to control the traversal. This way the internal
+/// children structure of classes can remain private. On the other hand,
+/// visitors may want to differentiate visiting composite types from leaf types.
+/// Composite types are those which contain visitable children, unlike the leaf
+/// nodes. Differentiation is accomplished by providing @c PreVisit and @c
+/// PostVisit methods, which should be called inside @c Accept of composite
+/// types. Regular @c Visit is only called inside @c Accept of leaf types.
+/// To implement such a visitor refer to @c CompositeVisitor, @c LeafVisitor and
+/// @c Visitable classes.
+///
+/// Implementation of hierarchical visiting is modelled after:
+/// http://wiki.c2.com/?HierarchicalVisitorPattern
+```
+

docs/dev/memgraph/diagram/dependencies.dot

@@ -0,0 +1,288 @@
+// dot -Tpng dependencies.dot -o /path/to/output.png
+
+// TODO (buda): Put PropertyValueStore to storage namespace
+
+digraph {
+  // At the beginning of each block there is a default style for that block
+  label="Memgraph Dependencies Diagram"; fontname="Roboto Bold"; fontcolor=black;
+    fontsize=26; labelloc=top; labeljust=right;
+  compound=true; // If true, allow edges between clusters
+  rankdir=TB; // Alternatives: LR
+  node [shape=record fontname="Roboto", fontsize=12, fontcolor=white];
+  edge [color="#B5AFB7"];
+
+  // -- Legend --
+  // dir=both arrowtail=diamond arrowhead=vee -> group ownership
+  // dir=both arrowtail=none, arrowhead=vee -> ownership; stack or uptr
+
+  subgraph cluster_tcp_end_client_communication {
+    label="TCP End Client Communication"; fontsize=14;
+    node [style=filled, color="#DD2222" fillcolor="#DD2222"];
+
+    // Owned elements
+    "communication::Server";
+    "io::network::Socket";
+
+    // Intracluster connections
+    "communication::Server" -> "io::network::Socket"
+      [label="socket_" dir=both arrowtail=none arrowhead=vee];
+  }
+
+  subgraph cluster_bolt_server {
+    label="Bolt Server"; fontsize=14;
+    node [style=filled, color="#62A2CA" fillcolor="#62A2CA"];
+
+    // Owned elements
+    "communication::bolt::SessionData";
+    "communication::bolt::Session";
+    "communication::bolt::Encoder";
+    "communication::bolt::Decoder";
+
+    // Intracluster connections
+    "communication::bolt::Session" -> "communication::bolt::Encoder"
+      [label="encoder_", dir=both arrowtail=none, arrowhead=vee];
+    "communication::bolt::Session" -> "communication::bolt::Decoder"
+      [label="decoder_", dir=both arrowtail=none, arrowhead=vee];
+  }
+
+  subgraph cluster_opencypher_engine {
+    label="openCypher Engine"; fontsize=14;
+    node [style=filled, color="#68BDF6" fillcolor="#68BDF6"];
+
+    // Owned Elements
+    "query::Interpreter";
+    "query::AstTreeStorage";
+    "query::TypedValue"
+    "query::Path";
+    "query::Simbol";
+    "query::Context";
+    "query::ExpressionEvaluator";
+    "query::Frame";
+    "query::SymbolTable";
+    "query::plan::LogicalOperator";
+    "query::plan::Cursor";
+    "query::plan::CostEstimator";
+
+    // Intracluster connections
+    "query::Interpreter" -> "query::AstTreeStorage"
+      [label="ast_cache" dir=both arrowtail=diamond arrowhead=vee];
+    "query::TypedValue" -> "query::Path";
+    "query::plan::Cursor" -> "query::Frame";
+    "query::plan::Cursor" -> "query::Context";
+    "query::plan::LogicalOperator" -> "query::Symbol";
+    "query::plan::LogicalOperator" -> "query::SymbolTable";
+    "query::plan::LogicalOperator" -> "query::plan::Cursor";
+  }
+
+
+  subgraph cluster_storage {
+    label="Storage" fontsize=14;
+    node [style=filled, color="#FB6E00" fillcolor="#FB6E00"];
+
+    // Owned Elements
+    "database::GraphDb";
+    "database::GraphDbAccessor";
+    "storage::Record";
+    "storage::Vertex";
+    "storage::Edge";
+    "storage::RecordAccessor";
+    "storage::VertexAccessor";
+    "storage::EdgeAccessor";
+    "storage::Common";
+    "storage::Label";
+    "storage::EdgeType";
+    "storage::Property";
+    "storage::compression";
+    "storage::SingleNodeConcurrentIdMapper";
+    "storage::Location";
+    "storage::StorageTypesLocation";
+    "PropertyValueStore";
+    "storage::RecordLock";
+    "mvcc::Version";
+    "mvcc::Record";
+    "mvcc::VersionList";
+
+    // Intracluster connections
+    "storage::VertexAccessor" -> "storage::RecordAccessor"
+      [arrowhead=onormal];
+    "storage::EdgeAccessor" -> "storage::RecordAccessor"
+      [arrowhead=onormal];
+    "storage::RecordAccessor" -> "database::GraphDbAccessor"
+      [style=dashed arrowhead=vee];
+    "storage::Vertex" -> "mvcc::Record"
+      [arrowhead=onormal];
+    "storage::Edge" -> "mvcc::Record"
+      [arrowhead=onormal];
+    "storage::Edge" -> "PropertyValueStore"
+      [arrowhead=vee];
+    "storage::Vertex" -> "PropertyValueStore"
+      [arrowhead=vee];
+    "storage::Edge" -> "mvcc::VersionList"
+      [label="from,to" arrowhead=vee style=dashed];
+    "storage::VertexAccessor" -> "storage::Vertex"
+      [arrowhead=vee];
+    "storage::EdgeAccessor" -> "storage::Edge"
+      [arrowhead=vee];
+    "storage::SingleNodeConcurrentIdMapper" -> "storage::StorageTypesLocation"
+      [arrowhead=vee];
+    "storage::StorageTypesLocation" -> "storage::Location"
+      [arrowhead=vee];
+    "storage::Storage" -> "storage::StorageTypesLocation"
+      [arrowhead=vee];
+    "storage::Property" -> "storage::Common"
+      [arrowhead=onormal];
+    "storage::Label" -> "storage::Common"
+      [arrowhead=onormal];
+    "storage::EdgeType" -> "storage::Common"
+      [arrowhead=onormal];
+    "storage::Property" -> "storage::Location"
+      [arrowhead=vee];
+    "PropertyValueStore" -> "storage::Property"
+      [arrowhead=vee];
+    "PropertyValueStore" -> "storage::Location"
+      [arrowhead=vee];
+    "database::GraphDbAccessor" -> "database::GraphDb"
+      [arrowhead=vee];
+    "database::GraphDbAccessor" -> "tx::TransactionId"
+      [arrowhead=vee];
+    "mvcc::VersionList" -> "storge::RecordLock"
+      [label="lock" arrowhead=vee];
+    "mvcc::VersionList" -> "mvcc::Record"
+      [label="head" arrowhead=vee];
+    "mvcc::Record" -> "mvcc::Version"
+      [arrowhead=onormal];
+
+    // Explicit positioning
+    {rank=same;
+        "database::GraphDbAccessor";
+        "storage::VertexAccessor";
+        "storage::EdgeAccessor";}
+    {rank=same;
+        "storage::Common";
+        "storage::compression";}
+  }
+
+  subgraph cluster_properties_on_disk {
+    label="Properties on Disk" fontsize=14;
+    node [style=filled, color="#102647" fillcolor="#102647"];
+
+    // Owned Elements
+    "storage::KVStore";
+    "rocksdb";
+
+    // Intracluster connections
+    "storage::KVStore" -> "rocksdb";
+  }
+
+  subgraph cluster_distributed {
+    label="Distributed" fontsize=14;
+    node [style=filled, color="#FFC500" fillcolor="#FFC500"];
+
+    // Owned Elements
+    "distributed::DataManager";
+    "distributed::DataRpcClients";
+
+    // Intracluster connections
+    "distributed::DataManager" -> "distributed::DataRpcClients"
+      [arrowhead=vee];
+    "storage::RecordAccessor" -> "distributed::DataManager"
+      [style=dashed arrowhead=vee];
+  }
+
+  subgraph cluster_dynamic_partitioning {
+    label="Dynamic Partitioning" fontsize=14;
+    node [style=filled, color="#720096" fillcolor="#720096"];
+
+    // Owned Elements
+    "DynamicPartitioner";
+  }
+
+  subgraph cluster_security {
+    label="Security" fontsize=14;
+    node [style=filled, color="#857F87" fillcolor="#857F87"];
+
+    // Owned Elements
+    "Communication Encryption";
+    "Data Encryption";
+    "Access Control";
+    "Audit Logging";
+  }
+
+  subgraph cluster_web_dashboard {
+    label="Dashaboard" fontsize=14;
+    node [style=filled, color="#FF0092" fillcolor="#FF0092"];
+
+    // Owned Elements
+    "Memgraph Ops / Memgraph Cockpit";
+  }
+
+  subgraph cluster_rpc {
+    label="RPC" fontsize=14;
+    node [style=filled, color="#857F87" fillcolor="#857F87"];
+
+    // Owned Elements
+    "communication::rpc::Server";
+    "communication::rpc::Client";
+  }
+
+  subgraph cluster_ingestion {
+    label="Ingestion" fontsize=14;
+    node [style=filled, color="#0B6D88" fillcolor="#0B6D88"];
+
+    // Owned Elements
+    "Extract";
+    "Transform";
+    "Load";
+    "Amazon S3";
+    "Kafka";
+
+    // Intracluster connections
+    "Extract" -> "Amazon S3";
+    "Extract" -> "Kafka";
+
+    // Explicit positioning
+    {rank=same;"Extract";"Transform";"Load";}
+  }
+
+  // -- Intercluster connections --
+  // cluster_tcp_end_client_communication -- cluster_bolt_server
+  "communication::Server" -> "communication::bolt::SessionData" [color=black];
+  "communication::Server" -> "communication::bolt::Session" [color=black];
+  // cluster_bolt_server -> cluster_storage
+  "communication::bolt::SessionData" -> "database::GraphDb" [color=red];
+  "communication::bolt::Session" -> "database::GraphDbAccessor" [color=red];
+  // cluster_bolt_server -> cluster_opencypher_engine
+  "communication::bolt::SessionData" -> "query::Interpreter" [color=red];
+  // cluster_opencypher_engine -- cluster_storage
+  "query::Interpreter" -> "database::GraphDbAccessor" [color=black];
+  "query::Interpreter" -> "storage::VertexAccessor" [color=black];
+  "query::Interpreter" -> "storage::EdgeAccessor" [color=black];
+  "query::TypedValue" -> "storage::VertexAccessor" [color=black];
+  "query::TypedValue" -> "storage::EdgeAccessor" [color=black];
+  "query::Path" -> "storage::VertexAccessor"
+    [label="vertices" dir=both arrowtail=diamond arrowhead=vee color=black];
+  "query::Path" -> "storage::EdgeAccessor"
+    [label="edges" dir=both arrowtail=diamond arrowhead=vee color=black];
+  "query::plan::LogicalOperator" -> "database::GraphDbAccessor"
+    [color=black arrowhead=vee];
+  // cluster_distributed -- cluster_storage
+  "distributed::DataManager" -> "database::GraphDb"
+    [arrowhead=vee style=dashed color=red];
+  "distributed::DataManager" -> "tx::TransactionId"
+    [label="ves_caches_key" dir=both arrowhead=none arrowtail=diamond
+     color=red];
+  "distributed::DataManager" -> "storage::Vertex"
+    [label="vertices_caches" dir=both arrowhead=none arrowtail=diamond
+     color=red];
+  "distributed::DataManager" -> "storage::Edge"
+    [label="edges_caches" dir=both arrowhead=none arrowtail=diamond
+     color=red];
+  // cluster_storage -- cluster_properties_on_disk
+  "PropertyValueStore" -> "storage::KVStore"
+    [label="static" arrowhead=vee color=black];
+  // cluster_dynamic_partitioning -- cluster_storage
+  "database::GraphDb" -> "DynamicPartitioner"
+    [arrowhead=vee color=red];
+  "DynamicPartitioner" -> "database::GraphDbAccessor"
+    [arrowhead=vee color=black];
+}

docs/dev/memgraph/distributed/addressing.md

@@ -0,0 +1,43 @@
+# Distributed addressing
+
+In distributed Memgraph a single graph element must be owned by exactly
+one worker. It is possible that multiple workers have cached copies of
+a single graph element (which is inevitable), but there is only one
+owner.
+
+The owner of a graph element can change. This is not yet implemented,
+but is intended. Graph partitioning is intended to be dynamic.
+
+Graph elements refer to other graph elements that are possibly on some
+other worker. Even though each graph element is identified with a unique
+ID, that ID does not contain the information about where that element
+currently resides (which worker is the owner).
+
+Thus we introduce the concept of a global address. It indicates both
+which graph element is referred to (it's global ID), and where it
+resides. Semantically it's a pair of two elements, but for efficiency
+it's stored in 64 bits.
+
+The global address is efficient for usage in a cluster: it indicates
+where something can be found. However, finding a graph element based on
+it's ID is still not a free operation (in the current implementation
+it's a skiplist lookup). So, whenever possible, it's better to use local
+addresses (pointers).
+
+Succinctly, the requirements for addressing are:
+- global addressing containing location info
+- fast local addressing
+- storage of both types in the same location efficiently
+- translation between the two
+
+The `storage::Address` class handles the enumerated storage
+requirements. It stores either a local or global address in the size of
+a local pointer (typically 8 bytes).
+
+Conversion between the two is done in multiple places. The general
+approach is to use local addresses (when possible) only for local
+in-memory handling. All the communication and persistence uses global
+addresses. Also, when receiving address from another worker, attempt to
+localize addresses as soon as possible, so that least code has to worry
+about potential inefficiency of using a global address for a local graph
+element.

docs/dev/memgraph/distributed/durability.md

@@ -0,0 +1,50 @@
+# Distributed durability
+
+Durability in distributed is slightly different then in single-node as
+the state itself is shared between multiple workers and none of those
+states are independent.
+
+Note that recovering from persistent storage must result in a stable
+database state. This means that across the cluster the state
+modification of every transaction that was running is either recovered
+fully or not at all. Also, if transaction A committed before transaction B,
+then if B is recovered so must A.
+
+## Snapshots
+
+It is possibly avoidable but highly desirable that the database can be
+recovered from snapshot only, without relying on WAL files. For this to
+be possible in distributed, it must be ensured that the same
+transactions are recovered on all the workers (including master) in the
+cluster. Since the snapshot does not contain information about which
+state change happened in which transaction, the only way to achieve this
+is to have synchronized snapshots. This means that the process of
+creating a snapshot, which is in itself transactional (it happens within
+a transaction and thus observes some consistent database state), must
+happen in the same transaction. This is achieved by the master starting
+a snapshot generating transaction and triggering the process on all
+workers in the cluster.
+
+## WAL
+
+Unlike the snapshot, write-ahead logs contain the information on which
+transaction made which state change. This makes it possible to include
+or exclude transactions during the recovery process. What is necessary
+however is a global consensus on which of the transactions should be
+recovered and which not, to ensure recovery into a consistent state.
+
+It would be possible to achieve this with some kind of synchronized
+recovery process, but it would impose constraints on cluster startup and
+would not be trivial.
+
+A simpler alternative is that the consensus is achieved beforehand,
+while the database (to be recovered) is still operational. What is
+necessary is to keep track of which transactions are guaranteed to
+have been flushed to the WAL files on all the workers in the cluster. It
+makes sense to keep this record on the master, so a mechanism is
+introduced which periodically pings all the workers, telling them to
+flush their WALs, and writes some sort of a log indicating that this has
+been confirmed. The downside of this is a periodic broadcast must be
+done, and that potentially slightly less data can be recovered in the
+case of a crash then if using a post-crash consensus. It is however much
+simpler to implement.

docs/dev/memgraph/distributed/dynamic_graph_partitioning.md

@@ -0,0 +1,48 @@
+## Dynamic Graph Partitioning
+Memgraph supports dynamic graph partitioning similar to the Spinner algorithm, 
+mentioned in this paper: [https://arxiv.org/pdf/1404.3861.pdf].
+
+Dgp is useful because it tries to group `local` date on the same worker, i.e. 
+it tries to keep closely connected data on one worker. It tries to avoid jumps 
+across workers when querying/traversing the distributed graph.
+
+### Our implementation
+It works independently on each worker but it is always running the migration 
+on only one worker at the same time. It achieves that by sharing a token 
+between workers, and the token ownership is transferred to the next worker 
+when the current worker finishes its migration step. 
+
+The reason that we want workers to work in  disjoint time slots is it avoid 
+serialization errors caused by creating/removing edges of vertices during 
+migrations, which might cause an update of some vertex from two or more 
+different transactions.
+
+### Migrations
+For each vertex and workerid (label in the context of Dgp algorithm) we define  
+a score function. Score function takes into account labels of surrounding 
+endpoints of vertex edges (in/out) and the capacity of the worker with said 
+label. Score function loosely looks like this 
+```
+locality(v, l) = 
+count endpoints of edges of vertex `v` with label `l` / degree of `v`
+
+capacity(l) = 
+number of vertices on worker `l` divided by the worker capacity 
+(usually equal to the average number of vertices per worker)
+
+score(v, l) = locality(v, l) - capacity(l)
+```
+We also define two flags alongside ```dynamic_graph_partitioner_enabled```, 
+   ```dgp_improvement_threshold``` and ```dgp_max_batch_size```.
+
+These two flags are used during the migration phase.
+When deciding if we need to migrate some vertex `v` from worker `l1` to worker 
+`l2` we examine the difference in scores, i.e.
+if score(v, l1) - dgp_improvement_threshold / 100 < score(v, l2) then we 
+migrate the vertex. 
+
+Max batch size flag limits the number of vertices we can transfer in one batch 
+(one migration step). 
+Setting this value to a too large value will probably cause
+a lot of interference with client queries, and having it a small value
+will slow down convergence of the algorithm.

docs/dev/memgraph/distributed/general_concepts.md

@@ -0,0 +1,54 @@
+# Memgraph distributed
+
+This chapter describes some of the concepts used in distributed
+Memgraph. By "distributed" here we mean the sharding of a single graph
+onto multiple processing units (servers).
+
+## Conceptual organization
+
+There is a single master and multiple workers. The master contains all
+the global sources of truth (transaction engine,
+[label|edge-type|property] to name mappings). Also, in the current
+organization it is the only one that contains a Bolt server (for
+communication with the end client) and an interpretation engine. Workers
+contain the data and means of subquery interpretation (query plans
+recieved from the master) and means of communication with the master and
+other workers.
+
+In many query plans the load on the master is much larger then the load
+on the workers. For that reason it might be beneficial to make the
+master contain less data (or none at all), and/or having multiple
+interpretation masters.
+
+## Logic organization
+
+Both the distributed and the single node Memgraph use the same codebase.
+In cases where the behavior in single-node differs from that in
+distributed, some kind of dynamic behavior change is implemented (either
+through inheritance or conditional logic).
+
+### GraphDb
+
+The `database::GraphDb` is an "umbrella" object for parts of the
+database such as storage, garbage collection, transaction engine etc.
+There is a class heirarchy of `GraphDb` implementations, as well as a
+base interface object. There are subclasses for single-node, master and
+worker deplotyments. Which implementation is used depends on the
+configuration processed in the `main` entry point of memgraph.
+
+The `GraphDb` interface exposes getters to base classes of
+other similar heirarchies (for example to `tx::Engine`). In that way
+much of the code that uses those objects (for example query plan
+interpretation) is agnostic to the type of deployment.
+
+### RecordAccessors
+
+The functionality of `RecordAccessors` and it's subclasses is already
+documented. It's important to note that the same implementation of
+accessors is used in all deployments, with internal changes of behavior
+depending on the locality of the graph element (vertex or edge) the
+accessor represents. For example, if the graph element is local, an
+update operation on an accessor will make the necessary MVCC ops, update
+local data, indexes, the write-ahead log etc. However, if the accessor
+represents a remote graph element, an update will trigger an RPC message
+to the owner about the update and a change in the local cache.

docs/dev/memgraph/distributed/updates.md

@@ -0,0 +1,103 @@
+# Distributed updates
+
+Operations that modify the graph state are somewhat more complex in the
+distributed system, as opposed to a single-node Memgraph deployment. The
+complexity arises from two factors.
+
+First, the data being modified is not necessarily owned by the worker
+performing the modification. This situation is completely valid workers
+execute parts of the query plan and parts must be executed by the
+master.
+
+Second, there are less guarantees regarding multi-threaded access. In
+single-node Memgraph it was guaranteed that only one transaction will be
+performing database work in a single transaction. This implied that
+per-version storage could be thread-unsafe. In distributed Memgraph it
+is possible that multiple threads could be performing work in the same
+transaction as a consequence of the query being executed at the same
+time on multiple workers and those executions interacting with the
+globally partitioned database state.
+
+## Deferred state modification
+
+Making the per-version data storage thread-safe would most likely have a
+performance impact very undesirable in a transactional database intended
+for high throughput.
+
+An alternative is that state modification over unsafe structures is not
+performed immediately when requested, but postponed until it is safe to
+do (there is is a guarantee of no concurrent access).
+
+Since local query plan execution is done the same way on local data as
+it is in single-node Memgraph, it is not possible to deffer that part of
+the modification story. What can be deferred are modifications requested
+by other workers. Since local query plan execution still is
+single-threaded, this approach is safe.
+
+At the same time those workers requesting the remote update can update
+local copies (caches) of the not-owned data since that cache is only
+being used by the single, local-execution thread.
+
+### Visibility
+
+Since updates are deferred the question arises: when do the updates
+become visible? The above described process offers the following
+visibility guarantees:
+- updates done on the local state are visible to the owner
+- updates done on the local state are NOT visible to anyone else during
+  the same (transaction + command)
+- updates done on remote state are deferred on the owner and not
+  visible to the owner until applied
+- updates done on the remote state are applied immediately to the local
+  caches and thus visible locally
+
+This implies an inconsistent view of the database state. In a concurrent
+execution of a single query this can hardly be avoided and is accepted
+as such. It does not change the Cypher query execution semantic in any
+of the well-defined scenarios. It possibly changes some of the behaviors
+in which the semantic is not well defined even in single-node execution.
+
+### Synchronization, update application
+
+In many queries it is mandatory to observe the latest global graph state
+(typically when returning it to the client). That means that before that
+happens all the deferred updates need to be applied, and all the caches
+to remote data invalidated. Exactly this happens when executing queries
+that modify the graph state. At some point a global synchronization
+point is reached. First it is waited that all workers finish the
+execution of query plan parts performing state modifications. After that
+all the workers are told to apply the deferred updates they received to
+their graph state. Since there is no concurrent query plan execution,
+this is safe. Once that is done all the local caches are cleared and the
+requested data can be returned to the client.
+
+### Command advancement
+
+In complex queries where a read part follows a state modification part
+the synchronization process after the state modification part is
+followed by command advancement, like in single-node execution.
+
+## Creation
+
+Graph element creation is not deferred. This is practical because the
+response to a creation is the global ID of the newly created element. At
+the same time it is safe because no other worker (including the owner)
+will be using the newly added graph element.
+
+## Updating
+
+Updating is deferred, as described. Note that this also means that
+record locking conflicts are deferred and serialization errors
+(including lock timeouts) are postponed until the deferred update
+application phase. In certain scenarios it might be beneficial to force
+these errors to happen earlier, when the deferred update request is
+processed.
+
+## Deletion
+
+Deletion is also deferred. Deleting an edge implies a modification of
+it's endpoint vertices, which must be deferred as those data structures
+are not thread-safe. Deleting a vertex is either with detaching, in
+which case an arbitrary number of updates are implied in the vertex's
+neighborhood, or without detaching which relies on checking the current
+state of the graph which is generally impossible in distributed.

docs/dev/memgraph/durability/snapshots.md

@@ -0,0 +1,22 @@
+# Snapshots
+
+A "snapshot" is a record of the current database state stored in permanent
+storage. Note that the term "snapshot" is used also in the context of
+the transaction engine to denote a set of running transactions.
+
+A snapshot is written to the file by Memgraph periodically if so
+configured. The snapshot creation  process is done within a transaction created
+specifically for that purpose. The transaction is needed to ensure that
+the stored state is internally consistent.
+
+The database state can be recovered from the snapshot during startup, if
+so configured. This recovery works in conjunction with write-ahead log
+recovery.
+
+A single snapshot contains all the data needed to recover a database. In
+that sense snapshots are independent of each other and old snapshots can
+be deleted once the new ones are safely stored, if it is not necessary
+to revert the database to some older state.
+
+The exact format of the snapshot file is defined inline in the snapshot
+creation code.

docs/dev/memgraph/durability/wal.md

@@ -0,0 +1,47 @@
+# Write-ahead logging
+
+Typically WAL denotes the process of writing a "log" of database
+operations (state changes) to persistent storage before committing the
+transaction, thus ensuring that the state can be recovered (in the case
+of a crash) for all the transactions which the database committed.
+
+The WAL is a fine-grained durability format. It's purpose is to store
+database changes fast. It's primary purpose is not to provide
+space-efficient storage, nor to support fast recovery. For that reason
+it's often used in combination with a different persistence mechanism
+(in Memgraph's case the "snapshot") that has complementary
+characteristics.
+
+### Guarantees
+
+Ensuring that the log is written before the transaction is committed can
+slow down the database. For that reason this guarantee is most often
+configurable in databases. In Memgraph it is at the moment not
+guaranteed, nor configurable. The WAL is flushed to the disk
+periodically and transactions do not wait for this to complete.
+
+### Format
+
+The WAL file contains a series of DB state changes called `StateDelta`s.
+Each of them describes what the state change is and in which transaction
+it happened. Also some kinds of meta-information needed to ensure proper
+state recovery are recorded (transaction beginnings and commits/abort).
+
+The following is guaranteed w.r.t. `StateDelta` ordering in
+a single WAL file:
+- For two ops in the same transaction, if op A happened before B in the
+  database, that ordering is preserved in the log.
+- Transaction begin/commit/abort messages also appear in exactly the
+  same order as they were executed in the transactional engine.
+
+### Recovery
+
+The database can recover from the WAL on startup. This works in
+conjunction with snapshot recovery. The database attempts to recover from
+the latest snapshot and then apply as much as possible from the WAL
+files. Only those transactions that were not recovered from the snapshot
+are recovered from the WAL, for speed efficiency. It is possible (but
+inefficient) to recover the database from WAL only, provided all the WAL
+files created from DB start are available. It is not possible to recover
+partial database state (i.e. from some suffix of WAL files, without the
+preceding snapshot).

docs/dev/memgraph/storage/accessors.md

@@ -0,0 +1,110 @@
+# DatabaseAccessor
+
+A `DatabaseAccessor` actually wraps a transactional access to database
+data, for a single transaction. In that sense the naming is bad. It
+encapsulates references to the database and the transaction object.
+
+It contains logic for working with database content (graph element
+data) in the context of a single transaction. All CRUD operations are
+performed within a single transaction (as Memgraph is a transactional
+database), and therefore iteration over data, finding a specific graph
+element etc are all functionalities of a `GraphDbAccessor`.
+
+In single-node Memgraph the database accessor also defined the lifetime
+of a transaction. Even though a `Transaction` object was owned by the
+transactional engine, it was `GraphDbAccessor`'s lifetime that object
+was bound to (the transaction was implicitly aborted in
+`GraphDbAccessor`'s destructor, if it was not explicitly ended before
+that).
+
+# RecordAccessor
+
+It is important to understand data organization and access in the
+storage layer. This discussion pertains to vertices and edges as graph
+elements that the end client works with.
+
+Memgraph uses MVCC (documented on it's own page). This means that for
+each graph element there could be different versions visible to
+different currently executing transactions. When we talk about a
+`Vertex` or `Edge` as a data structure we typically mean one of those
+versions. In code this semantic is implemented so that both those classes
+inherit `mvcc::Record`, which in turn inherits `mvcc::Version`.
+
+Handling MVCC and visibility is not in itself trivial. Next to that,
+there is other book-keeping to be performed when working with data. For
+that reason, Memgraph uses "accessors" to define an API of working with
+data in a safe way. Most of the code in Memgraph (for example the
+interpretation code) should work with accessors. There is a
+`RecordAccessor` as a base class for `VertexAccessor` and
+`EdgeAccessor`. Following is an enumeration of their purpose.
+
+### Data access
+
+The client interacts with Memgraph using the Cypher query language. That
+language has certain semantics which imply that multiple versions of the
+data need to be visible during the execution of a single query. For
+example: expansion over the graph is always done over the graph state as
+it was at the beginning of the transaction.
+
+The `RecordAccessor` exposes functions to switch between the old and the new
+versions of the same graph element (intelligently named `SwitchOld` and
+`SwitchNew`) within a single transaction. In that way the client code
+(mostly the interpreter) can avoid dealing with the underlying MVCC
+version concepts.
+
+### Updates
+
+Data updates are also done through accessors. Meaning: there are methods
+on the accessors that modify data, the client code should almost never
+interact directly with `Vertex` or `Edge` objects.
+
+The accessor layer takes care of creating version in the MVCC layer and
+performing updates on appropriate versions.
+
+Next, for many kinds of updates it is necessary to update the relevant
+indexes. There are implicit indexes for vertex labels, as
+well as user-created indexes for (label, property) pairs. The accessor
+layer takes care of updating the indexes when these values are changed.
+
+Each update also triggers a log statement in the write-ahead log. This
+is also handled by the accessor layer.
+
+### Distributed
+
+In distributed Memgraph accessors also contain a lot of the remote graph
+element handling logic. More info on that is available in the
+documentation for distributed.
+
+### Deferred MVCC data lookup for Edges
+
+Vertices and edges are versioned using MVCC. This means that for each
+transaction an MVCC lookup needs to be done to determine which version
+is visible to that transaction. This tends to slow things down due to
+cache invalidations (version lists and versions are stored in arbitrary
+locations on the heap).
+
+However, for edges, only the properties are mutable. The edge endpoints
+and type are fixed once the edge is created. For that reason both edge
+endpoints and type are available in vertex data, so that when expanding
+it is not mandatory to do MVCC lookups of versioned, mutable data. This
+logic is implemented in `RecordAccessor` and `EdgeAccessor`.
+
+### Exposure
+
+The original idea and implementation of graph element accessors was that
+they'd prevent client code from ever interacting with raw `Vertex` or
+`Edge` data. This however turned out to be impractical when implementing
+distributed Memgraph and the raw data members have since been exposed
+(through getters to old and new version pointers). However, refrain from
+working with that data directly whenever possible! Always consider the
+accessors to be the first go-to for interacting with data, especially
+when in the context of a transaction.
+
+# Skiplist accessor
+
+The term "accessor" is also used in the context of a skiplist. Every
+operation on a skiplist must be performed within on an
+accessor. The skiplist ensures that there will be no physical deletions
+of an object during the lifetime of an accessor. This mechanism is used
+to ensure deletion correctness in a highly concurrent container.
+We only mention that here to avoid confusion regarding terminology.

docs/dev/memgraph/storage/property-storage.md

@@ -0,0 +1,131 @@
+# Property storage
+
+Although the reader is probably familiar with properties in *Memgraph*, let's
+briefly recap. 
+
+Both vertices and edges can store an arbitrary number of properties. Properties
+are, in essence, ordered pairs of property names and property values. Each
+property name within a single graph element (edge/node) can store a single
+property value. Property names are represented as strings, while property values
+must be one of the following types:
+
+ Type      | Description
+-----------|------------
+ `Null`    | Denotes that the property has no value. This is the same as if the property does not exist.
+ `String`  | A character string, i.e. text.
+ `Boolean` | A boolean value, either `true` or `false`.
+ `Integer` | An integer number.
+ `Float`   | A floating-point number, i.e. a real number.
+ `List`    | A list containing any number of property values of any supported type. It can be used to store multiple values under a single property name.
+ `Map`     | A mapping of string keys to values of any supported type.
+
+Property values are modeled in a class conveniently called `PropertyValue`.
+
+## Mapping between property names and property keys.
+
+Although users think of property names in terms of descriptive strings 
+(e.g. "location" or "department"), *Memgraph* internally converts those names
+into property keys which are, essentially, unsigned 16-bit integers.
+
+Property keys are modelled by a not-so-conveniently named class called
+`Property` which can be found in `storage/types.hpp`. The actual conversion
+between property names and property keys is done within the `ConcurrentIdMapper`
+but the internals of that implementation are out of scope for understanding
+property storage.
+
+## PropertyValueStore
+
+Both `Edge` and `Vertex` objects contain an instance of `PropertyValueStore`
+object which is responsible for storing properties of a corresponding graph
+element.
+
+An interface of `PropertyValueStore` is as follows:
+
+ Method    | Description
+-----------|------------
+ `at`      | Returns the `PropertyValue` for a given `Property` (key).
+ `set`     | Stores a given `PropertyValue` under a given `Property` (key).
+ `erase`   | Deletes a given `Property` (key) alongside its corresponding `PropertyValue`.
+ `clear`   | Clears the storage.
+ `iterator`| Provides an extension of `std::input_iterator` that iterates over storage.
+
+## Storage location
+
+By default, *Memgraph* is an in-memory database and all properties are therefore
+stored in working memory unless specified otherwise by the user. User has an
+option to specify via the command line which properties they wish to be stored
+on disk.
+
+Storage location of each property is encapsulated within a `Property` object
+which is ensured by the `ConcurrentIdMapper`. More precisely, the unsigned 16-bit
+property key has the following format:
+
+```
+|---location--|------id------|
+|-Memory|Disk-|-----2^15-----|
+``` 
+
+In other words, the most significant bit determines the location where the
+property will be stored. 
+
+### In-memory storage
+
+The underlying implementation of in-memory storage for the time being is
+`std::vector<std::pair<Property, PropertyValue>>`. Implementations of`at`, `set`
+and `erase` are linear in time. This implementation is arguably more efficient
+than `std::map` or `std::unordered_map` when the average number of properties of
+a record is relatively small (up to 10) which seems to be the case.
+
+### On-disk storage
+
+#### KVStore
+
+Disk storage is modeled by an abstraction of key-value storage as implemented in
+`storage/kvstore.hpp'. An interface of this abstraction is as follows:
+
+ Method         | Description
+----------------|------------
+ `Put`          | Stores the given value under the given key.
+ `Get`          | Obtains the given value stored under the given key.
+ `Delete`       | Deletes a given (key, value) pair from storage..
+ `DeletePrefix` | Deletes all (key, value) pairs where key begins with a given prefix.
+ `Size`         | Returns the size of the storage or, optionally, the number of stored pairs that begin with a given prefix.
+ `iterator`     | Provides an extension of `std::input_iterator` that iterates over storage.
+
+Keys and values in this context are of type `std::string`.
+
+The actual underlying implementation of this abstraction uses
+[RocksDB]{https://rocksdb.org} &mdash; a persistent key-value store for fast
+storage.
+
+It is worthy to note that the custom iterator implementation allows the user
+to iterate over a given prefix. Otherwise, the implementation follows familiar
+c++ constructs and can be used as follows:
+
+```
+KVStore storage = ...;
+for (auto it = storage.begin(); it != storage.end(); ++it) {}
+for (auto kv : storage) {}
+for (auto it = storage.begin("prefix"); it != storage.end("prefix"); ++it) {}
+```
+
+Note that it is not possible to scan over multiple prefixes. For instance, one
+might assume that you can scan over all keys that fall in a certain
+lexicographical range. Unfortunately, that is not the case and running the
+following code will result in an infinite loop with a touch of undefined
+behavior.
+
+```
+KVStore storage = ...;
+for (auto it = storage.begin("alpha"); it != storage.end("omega"); ++it) {}
+```
+
+#### Data organization on disk
+
+Each `PropertyValueStore` instance can access a static `KVStore` object that can
+store `(key, value)` pairs on disk. The key of each property on disk consists of
+two parts &mdash; a unique identifier (unsigned 64-bit integer) of the current
+record version (see mvcc docummentation for further clarification) and a 
+property key as described above. The actual value of the property is serialized
+into a bytestring using bolt `BaseEncoder`. Similarly, deserialization is
+performed by bolt `Decoder`.

docs/dev/quick-start.md

@@ -0,0 +1,78 @@
+# Quick Start
+
+A short chapter on downloading the Memgraph source, compiling and running.
+
+## Obtaining the Source Code
+
+Memgraph uses `git` for source version control. You will need to install `git`
+on your machine before you can download the source code.
+
+On Debian systems, you can do it inside a terminal with the following
+command:
+
+    sudo apt-get install git
+
+On ArchLinux or Gentoo, you probably already know what to do.
+
+After installing `git`, you are now ready to fetch your own copy of Memgraph
+source code. Run the following command:
+
+    git clone https://phabricator.memgraph.io/diffusion/MG/memgraph.git
+
+The above will create a `memgraph` directory and put all source code there.
+
+## Compiling Memgraph
+
+With the source code, you are now ready to compile Memgraph. Well... Not
+quite. You'll need to download Memgraph's dependencies first.
+
+In your terminal, position yourself in the obtained memgraph directory.
+
+    cd memgraph
+
+### Installing Dependencies
+
+On Debian systems, all of the dependencies should be setup by running the
+`init` script:
+
+    ./init -s
+
+Currently, other systems aren't supported in the `init` script. But you can
+issue the needed steps manually. First run the `init` script.
+
+    ./init
+
+The script will output the required packages, which you should be able to
+install via your favorite package manager. For example, `pacman` on ArchLinux.
+After installing the packages, issue the following commands:
+
+    mkdir -p build
+    ./libs/setups.sh
+
+### Compiling
+
+With all of the dependencies installed, you need to configure the build
+system. To do that, execute the following:
+
+    cd build
+    cmake ..
+
+If everything went OK, you can now, finally, compile Memgraph.
+
+    make -j$(nproc)
+
+### Running
+
+After the compilation verify that Memgraph works:
+
+    ./memgraph --version
+
+To make extra sure, run the unit tests:
+
+    ctest -R unit -j$(nproc)
+
+## Problems
+
+If you have any trouble running the above commands, contact your nearest
+developer who successfully built Memgraph. Ask for help and insist on getting
+this document updated with correct steps!

docs/dev/toolchain-bootstrap.md

@@ -0,0 +1,152 @@
+# Bootstrapping Compilation Toolchain for Memgraph
+
+Requirements:
+
+  * libstdc++ shipped with gcc-6.3 or gcc-6.4
+  * cmake >= 3.1, Debian Stretch uses cmake-3.7.2
+  * clang-3.9
+
+## Installing gcc-6.4
+
+gcc-6.3 has a bug, so use the 6.4 version which is just a bugfix release.
+
+Requirements on CentOS 7:
+
+  * wget
+  * make
+  * gcc (bootstrap)
+  * gcc-c++ (bootstrap)
+  * gmp-devel (bootstrap)
+  * mpfr-devel (bootstrap)
+  * libmpc-devel (bootstrap)
+  * zip
+  * perl
+  * dejagnu (testing)
+  * expect (testing)
+  * tcl (testing)
+
+```
+wget ftp://ftp.mpi-sb.mpg.de/pub/gnu/mirror/gcc.gnu.org/pub/gcc/releases/gcc-6.4.0/gcc-6.4.0.tar.gz
+tar xf gcc-6.4.0.tar.gz
+cd gcc-6.4.0
+mkdir build
+cd build
+../configure --disable-multilib --prefix=<install-dst>
+make
+# Testing
+make -k check
+make install
+```
+
+*Do not put gcc + libs on PATH* (unless you know what you are doing).
+
+## Installing cmake-3.7.2
+
+Requirements on CentOS 7:
+
+  * wget
+  * make
+  * gcc
+  * gcc-c++
+  * ncurses-devel (optional, for ccmake)
+
+```
+wget https://cmake.org/files/v3.7/cmake-3.7.2.tar.gz
+tar xf cmake-3.7.2.tar.gz
+cd cmake-3.7.2.tar.gz
+./bootstrap --prefix<install-dst>
+make
+make install
+```
+
+Put cmake on PATH (if appropriate)
+
+**Fix the bug in CpackRPM**
+
+`"<path-to-cmake>/share/cmake-3.7/Modules/CPackRPM.cmake" line 2273 of 2442`
+
+The line
+
+```
+set(RPMBUILD_FLAGS "-bb")
+```
+needs to be before
+
+```
+if(CPACK_RPM_GENERATE_USER_BINARY_SPECFILE_TEMPLATE OR NOT CPACK_RPM_USER_BINARY_SPECFILE)
+```
+
+It was probably accidentally placed after, and is fixed in later cmake
+releases.
+
+## Installing clang-3.9
+
+Requirements on CentOS 7:
+
+  * wget
+  * make
+  * cmake
+
+```
+wget http://releases.llvm.org/3.9.1/llvm-3.9.1.src.tar.xz
+tar xf llvm-3.9.1.src.tar.xz
+mv llvm-3.9.1.src llvm
+
+wget http://releases.llvm.org/3.9.1/cfe-3.9.1.src.tar.xz
+tar xf cfe-3.9.1.src.tar.xz
+mv cfe-3.9.1.src llvm/tools/clang
+
+cd llvm
+mkdir build
+cd build
+cmake -DCMAKE_BUILD_TYPE="Release" -DGCC_INSTALL_PREFIX=<gcc-dir> \
+-DCMAKE_C_COMPILER=<gcc> -DCMAKE_CXX_COMPILER=<g++> \
+-DCMAKE_CXX_LINK_FLAGS="-L<gcc-dir>/lib64 -Wl,-rpath,<gcc-dir>/lib64" \
+-DCMAKE_INSTALL_PREFIX=<install-dst> ..
+make
+# Testing
+make check-clang
+make install
+```
+
+Put clang on PATH (if appropriate)
+
+## Memgraph
+
+Requirements on CentOS 7:
+
+  * libuuid-devel (antlr4)
+  * java-1.8.0-openjdk (antlr4)
+  * boost-static (too low version --- compile manually)
+  * rpm-build (RPM)
+  * python3 (tests, ...)
+  * which (required for rocksdb)
+  * sbcl (lisp C++ preprocessing)
+
+### Boost 1.62
+
+```
+wget https://netix.dl.sourceforge.net/project/boost/boost/1.62.0/boost_1_62_0.tar.gz
+tar xf boost_1_62_0.tar.gz
+cd boost_1_62_0
+./bootstrap.sh --with-toolset=clang --with-libraries=iostreams,serialization --prefix=<install-dst>
+./b2
+# Default installs to /usr/local/
+./b2 install
+```
+
+### Building Memgraph
+
+clang is *required* to be findable by cmake, i.e. it should be on PATH.
+cmake isn't required to be on the path, since you run it manually, so can use
+the full path to executable in order to run it. Obviously, it is convenient to
+put cmake also on PATH.
+
+Building is done as explained in [Quick Start](quick-start.md), but each
+`make` invocation needs to be prepended with:
+
+`LD_RUN_PATH=<gcc-dir>/lib64 make ...`
+
+### RPM
+
+Name format: `memgraph-<version>-<pkg-version>.<arch>.rpm`

docs/dev/workflow.md

@@ -0,0 +1,177 @@
+# Memgraph Workflow
+
+This chapter describes the usual workflow for working on Memgraph.
+
+## Git
+
+Memgraph uses [git](https://git-scm.com/) for source version control. If you
+obtained the source, you probably already have it installed. Before you can
+track new changes, you need to setup some basic information.
+
+First, tell git your name:
+
+    git config --global user.name "FirstName LastName"
+
+Then, set your Memgraph email:
+
+    git config --global user.email "my.email@memgraph.com"
+
+Finally, make git aware of your favourite editor:
+
+    git config --global core.editor "vim"
+
+## Phabricator
+
+All of the code in Memgraph needs to go through code review before it can be
+accepted in the codebase. This is done through
+[Phabricator](https://phacility.com/phabricator/). The command line tool for
+interfacing with Phabricator is
+[arcanist](https://phacility.com/phabricator/arcanist/). You should already
+have it installed if you followed the steps in [Quick Start](quick-start.md).
+
+The only required setup is to go in the root of Memgraph's project and run:
+
+    arc install-certificate
+
+## Working on Your Feature Branch
+
+Git has a concept of source code *branches*. The `master` branch contains all
+of the changes which were reviewed and accepted in Memgraph's code base. The
+`master` branch is selected by default.
+
+### Creating a Branch
+
+When working on a new feature or fixing a bug, you should create a new branch
+out of the `master` branch. For example, let's say you are adding static type
+checking to the query language compiler. You would create a branch called
+`mg_query_static_typing` with the following command:
+
+    git branch mg_query_static_typing
+
+To switch to that branch, type:
+
+    git checkout mg_query_static_typing
+
+Since doing these two steps will happen often, you can use a shortcut command:
+
+    git checkout -b mg_query_static_typing
+
+Note that a branch is created from the currently selected branch. So, if you
+wish to create another branch from `master` you need to switch to `master`
+first.
+
+The usual convention for naming your branches is `mg_<feature_name>`, you may
+switch underscores ('\_') for hyphens ('-').
+
+Do take care not to mix the case of your branch names! Certain operating
+systems (like Windows) don't distinguish the casing in git branches. This may
+cause hard to track down issues when trying to switch branches. Therefore, you
+should always name your branches with lowercase letters.
+
+### Making and Committing Changes
+
+When you have a branch for your new addition, you can now actually start
+implementing it. After some amount of time, you may have created new files,
+modified others and maybe even deleted unused files. You need to tell git to
+track those changes. This is accomplished with `git add` and `git rm`
+commands.
+
+    git add path-to-new-file path-to-modified-file
+    git rm path-to-deleted-file
+
+To check that everything is correctly tracked, you may use the `git status`
+command. It will also print the name of the currently selected branch.
+
+If everything seems OK, you should commit these changes to git.
+
+    git commit
+
+You will be presented with an editor where you need to type the commit
+message. Writing a good commit message is an art in itself. You should take a
+look at the links below. We try to follow these conventions as much as
+possible.
+
+  * [How to Write a Git Commit Message](http://chris.beams.io/posts/git-commit/)
+  * [A Note About Git Commit Messages](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)
+  * [stopwritingramblingcommitmessages](http://stopwritingramblingcommitmessages.com/)
+
+### Sending Changes on a Review
+
+After finishing your work on your feature branch, you will want to send it on
+code review. This is done through Arcanist. To do that, run the following
+command:
+
+    arc diff
+
+You will, once again, be presented with an editor where you need to describe
+your whole work. `arc` will by default fill that description with your commit
+messages. The title and summary of your work should also follow the
+conventions of git messages as described above. If you followed the
+guidelines, the message filled by `arc` should be fine.
+
+In addition to the message, you need to fill the `Reviewers:` line with
+usernames of people who should do the code review.
+
+You changes will be visible on Phabricator as a so called "diff". You can find
+the default view of active diffs
+[here](https://phabricator.memgraph.io/differential/)
+
+### Updating Changes Based on Review
+
+When you get comments in the code review, you will want to make additional
+modifications to your work. The same workflow as before applies: [Making and
+Committing Changes](#making-and-committing-changes)
+
+After making those changes, send them back on code review:
+
+    arc diff
+
+
+### Updating From New Master
+
+Let's say that, while you were working, someone else added some new features
+to the codebase that you would like to use in your current work. To obtain
+those changes you should update your `master` branch:
+
+    git checkout master
+    git pull origin master
+
+Now, these changes are on `master`, but you want them in your local branch. To
+do that, use `git rebase`:
+
+    git checkout mg_query_static_typing
+    git rebase master
+
+During `git rebase`, you may get reports that some files have conflicting
+changes. If you need help resolving them, don't be afraid to ask around! After
+you've resolved them, mark them as done with `git add` command. You may
+then continue with `git rebase --continue`.
+
+After the `git rebase` is done, you will now have new changes from `master` on
+your feature branch as if you just created and started working on that branch.
+You may continue with the usual workflow of [Making and Committing
+Changes](#making-and-committing-changes) and [Sending Changes on a
+Review](#sending-changes-on-a-review).
+
+### Sending Your Changes on Master Branch
+
+When your changes pass the code review, you are ready to integrate them in the
+`master` branch. To do that, run the following command:
+
+    arc land
+
+Arcanist will take care of obtaining the latest changes from `master` and
+merging your changes on top. If the `land` was successful, Arcanist will
+delete your local branch and you will be back on `master`. Continuing from the
+examples above, the deleted branch would be `mg_query_static_typing`.
+
+This marks the completion of your changes, and you are ready to work on
+something else.
+
+### Note For People Familiar With Git
+
+Since Arcanist takes care of merging your git commits and pushing them on
+`master`, you should *never* have to call `git merge` and `git push`. If you
+find yourself typing those commands, check that you are doing the right thing.
+The most common mistake is to use `git merge` instead of `git rebase` for the
+case described in [Updating From New Master](#updating-from-new-master).

docs/doxygen/README.md

@@ -1,6 +1,7 @@
 # Memgraph Code Documentation
 
-IMPORTANT: Auto-generated (run doxygen Doxyfile in the project root).
+IMPORTANT: auto-generated (run doxygen Doxyfile in the project root)
 
-* HTML - Open docs/doxygen/html/index.html.
-* Latex - Run make inside docs/doxygen/latex.
+* HTML - just open docs/doxygen/html/index.html
+
+* Latex - run make inside docs/doxygen/latex

docs/feature_specs/kafka/extractor.md

@@ -0,0 +1,20 @@
+# Kafka - data extractor
+
+The data extractor is responsible for loading data from Kafka.  In order to do
+so, it needs to know the URI of the Kafka leader broker.  Once the extractor
+connects to Kafka, it starts importing data.
+
+Data extractor depends on [cppkafka](https://github.com/mfontanini/cppkafka)
+which makes message consumption just a few API calls, as seen
+[here](https://github.com/mfontanini/cppkafka/wiki/Consuming-messages).
+
+There are also other metadata that can be passed to data extractor that are
+defined with our [extension](opencypher.md) of openCypher.
+
+A full list of configurable metadata can be found
+[here](https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md).
+
+Memgraph supports customizing the following:
+
+  * `metadata.broker.list` which is a required parameter, set by `KAFKA 'URI'`
+  * `queue.buffering.max.ms` set by `BATCH INTERVAL`

docs/feature_specs/kafka/opencypher.md

@@ -0,0 +1,52 @@
+# Kafka - openCypher clause
+
+One must be able to specify the following when importing data from Kafka:
+* Kafka URI
+* Transform [script](transform.md) URI
+
+
+Kafka endpoint is the URI of the leader broker and it is required for data
+[extractor](extractor.md).
+
+Minimum required syntax looks like:
+```opencypher
+CREATE STREAM kafka_stream AS LOAD DATA KAFKA '127.0.0.1/topic' WITH TRANSFORM
+'127.0.0.1/transform.py';
+```
+
+The `CREATE STREAM` clause happens in a transaction.
+
+The full openCypher clause for creating a stream is:
+```opencypher
+CREATE STREAM stream_name AS
+  LOAD DATA KAFKA 'URI'
+  WITH TRANSFORM 'URI'
+  [BATCH INTERVAL milliseconds]
+```
+
+The `WITH TRANSFORM` parameter should contain a URI of the transform script.
+
+The `BATCH_INTERVAL` parameter defines the time interval in milliseconds
+that defines the time between two successive stream importing operations.
+
+The `DROP` clause deletes a stream:
+```opencypher
+DROP STREAM stream_name;
+```
+
+The `SHOW` clause enables you to see all configured streams:
+```opencypher
+SHOW STREAMS;
+```
+
+You can also start/stop streams with the `START` and `STOP` clauses:
+```opencypher
+START STREAM stream_name [LIMIT count BATCHES];
+STOP STREAM stream_name;
+```
+
+There are also convenience clauses to start and stop all streams:
+```opencypher
+START ALL STREAMS;
+STOP ALL STREAMS;
+```

docs/feature_specs/kafka/transform.md

@@ -0,0 +1,52 @@
+# Kafka - data transform
+
+The transform script is a user defined script written in Python.  The script
+should be aware of the data format in the Kafka message.
+
+Each Kafka message is byte length encoded, which means that the first eight
+bytes of each message contain the length of the message.
+
+More on the message format can be seen
+[here](https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol#AGuideToTheKafkaProtocol-Messagesets).
+
+
+The script will be embedded in our C++ codebase using pythons
+[embedding](https://docs.python.org/3.5/extending/embedding.html) feature.
+
+A sample code for a streaming transform script could look like this:
+
+```python
+import struct
+import sys
+
+def get_records():
+    while True:
+        message_len = sys.stdin.read(8)
+        if len(message_len) == 8:
+            message_len = struct.unpack("L", message_len)[0]
+            record = sys.stdin.read(message_len)
+            yield record
+        else:
+            assert len(message_len) == 0, message_len
+            return
+
+def create_vertex(fields):
+  return "CREATE (n:Node {{id: {}}})".format(fields[1])
+
+
+def create_edge(fields):
+  return "MATCH (n:Node {{id: {}}}) "\
+         "MATCH ((m:Node {{id : {}}})) "\
+         "CREATE (n)-[e:Edge{{value: {}}}]->(m) "\
+         .format(fields[1], fields[2], fields[3])
+
+for record in get_records():
+  fields = record.split("\t")
+  if fields[0] == "v":
+    return create_vertex(fields):
+  else:
+    return create_edge(fields)
+```
+
+The script should output openCypher query strings based on the type of the
+records.

docs/user_technical/README.md

@@ -0,0 +1,23 @@
+# Technical Documentation
+
+## About Memgraph
+
+Memgraph is an ACID compliant high performance transactional in-memory graph
+database management system featuring highly concurrent
+data structures, multi-version concurrency control and asynchronous IO.
+
+[//]: # (When adding a new documentation file, please add it to the list)
+
+## Contents
+
+  * [About Memgraph](#about-memgraph)
+  * [Quick Start](quick-start.md)
+  * [Examples](examples.md)
+  * [Drivers](drivers.md)
+  * [Data Storage](storage.md)
+  * [openCypher Query Language](open-cypher.md)
+  * [Import Tools](import-tools.md)
+  * [Concepts](concepts.md)
+  * [Upcoming Features](upcoming-features.md)
+
+[//]: # (Nothing should go below the contents section)

docs/user_technical/bundle_community

@@ -0,0 +1,58 @@
+#!/bin/bash
+
+working_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+build_dir=.bundle_community
+
+# curl and php are required
+if ! which php >/dev/null; then
+    echo "php is required!"
+    exit 1
+fi
+
+cd ${working_dir}
+generator="couscous.phar"
+
+# download the generator if it's not already downloaded
+if [ ! -f ${generator} ]; then
+    curl -OS http://couscous.io/${generator}
+fi
+
+# create build directory
+if [ -d $build_dir ]; then
+    rm -rf $build_dir
+fi
+mkdir $build_dir
+
+# copy all files to build directory
+cp couscous.yml *.md $generator $build_dir
+
+# go to build directory
+cd $build_dir
+
+# modify config file
+cat >> couscous.yml <<EOF
+template:
+    directory: .
+EOF
+
+# create template file
+echo "{{ content|raw }}" > default.twig
+
+# generate the site
+php ${generator} generate
+
+# create contents file
+cd .couscous/generated
+tail -n +$( grep -n "Contents" index.html | cut -d ':' -f 1 ) index.html | \
+    grep href | grep .html | \
+    sed -r 's/^[^"]+"//' | sed -r 's/.html">/ /' | sed -r 's/<.+//' > .contents
+rm index.html
+
+# create archive
+target=docs.tar.gz
+if [ -f $target ]; then
+    rm $target
+fi
+tar -czf $working_dir/$target .contents *.html
+
+echo "Created archive: $working_dir/$target"

docs/user_technical/concepts.md

@@ -0,0 +1,72 @@
+## Concepts
+
+### Weighted Shortest Path
+
+Weighted shortest path problem is the problem of finding a path between two
+nodes in a graph such that the sum of the weights of edges connecting nodes on
+the path is minimized.
+More about the *weighted shortest path* problem can be found
+[here](https://en.wikipedia.org/wiki/Shortest_path_problem).
+
+## Implementation
+
+Our implementation of the *weighted shortest path* algorithm uses a modified
+version of Dijkstra's algorithm that can handle length restriction. The length
+restriction parameter is optional, and when it's not set it could increase the
+complexity of the algorithm.
+
+A sample query that finds a shortest path between two nodes can look like this:
+
+```opencypher
+MATCH (a {id: 723})-[edge_list *wShortest 10 (e, n | e.weight) total_weight]-(b {id: 882}) RETURN *
+```
+
+This query has an upper bound length restriction set to `10`. This means that no
+path that traverses more than `10` edges will be considered as a valid result.
+
+
+#### Upper Bound Implications
+
+Since the upper bound parameter is optional, we can have different results based
+on this parameter.
+
+Lets take a look at the following graph and queries.
+
+```
+      5            5
+      /-----[1]-----\
+     /               \
+    /                 \      2
+  [0]                 [4]---------[5]
+    \                 /
+     \               /
+      \--[2]---[3]--/
+      3      3     3
+```
+
+```opencypher
+MATCH (a {id: 0})-[edge_list *wShortest 3 (e, n | e.weight) total_weight]-(b {id: 5}) RETURN *
+```
+
+```opencypher
+MATCH (a {id: 0})-[edge_list *wShortest   (e, n | e.weight) total_weight]-(b {id: 5}) RETURN *
+```
+
+The first query will try to find the weighted shortest path between nodes `0`
+and `5` with the restriction on the path length set to `3`, and the second query
+will try to find the weighted shortest path with no restriction on the path
+length.
+
+The expected result for the first query is `0 -> 1 -> 4 -> 5` with total cost of
+`12`, while the expected result for the second query is `0 -> 2 -> 3 -> 4 -> 5`
+with total cost of `11`. Obviously, the second query can find the true shortest
+path because it has no restrictions on the length.
+
+To handle cases when the length restriction is set, *weighted shortest path*
+algorithm uses both vertex and distance as the state. This causes the search
+space to increase by the factor of the given upper bound. On the other hand, not
+setting the upper bound parameter, the search space might contain the whole
+graph.
+
+Because of this, one should always try to narrow down the upper bound limit to
+be as precise as possible in order to have a more performant query.

docs/user_technical/couscous.yml

@@ -0,0 +1,2 @@
+title: Memgraph
+subTitle: Technical Documentation

docs/user_technical/distributed.md

@@ -0,0 +1,4 @@
+## Dynamic Graph Partitioner
+
+Memgraph supports dynamic graph partitioning which improves performance on badly partitioned dataset over workers dynamically. To enable it, use the
+```--dynamic_graph_partitioner_enabled``` flag.

docs/user_technical/drivers.md

@@ -0,0 +1,191 @@
+## Bolt Drivers
+
+### Python Driver Example
+
+Neo4j officially supports Python for interacting with an openCypher and Bolt
+compliant database. For details consult the
+[official documentation](http://neo4j.com/docs/api/python-driver) and the
+[GitHub project](https://github.com/neo4j/neo4j-python-driver).  Following is
+a basic usage example:
+
+```python
+from neo4j.v1 import GraphDatabase, basic_auth
+
+# Initialize and configure the driver.
+#   * provide the correct URL where Memgraph is reachable;
+#   * use an empty user name and password.
+driver = GraphDatabase.driver("bolt://localhost:7687",
+                              auth=basic_auth("", ""))
+
+# Start a session in which queries are executed.
+session = driver.session()
+
+# Execute openCypher queries.
+# After each query, call either `consume()` or `data()`
+session.run('CREATE (alice:Person {name: "Alice", age: 22})').consume()
+
+# Get all the vertices from the database (potentially multiple rows).
+vertices = session.run('MATCH (n) RETURN n').data()
+# Assuming we started with an empty database, we should have Alice
+# as the only row in the results.
+only_row = vertices.pop()
+alice = only_row["n"]
+
+# Print out what we retrieved.
+print("Found a vertex with labels '{}', name '{}' and age {}".format(
+  alice['name'], alice.labels, alice['age'])
+
+# Remove all the data from the database.
+session.run('MATCH (n) DETACH DELETE n').consume()
+
+# Close the session and the driver.
+session.close()
+driver.close()
+```
+
+### Java Driver Example
+
+The details about Java driver can be found
+[on GitHub](https://github.com/neo4j/neo4j-java-driver).
+
+The example below is equivalent to Python example. Major difference is that
+`Config` object has to be created before the driver construction.
+
+```java
+import org.neo4j.driver.v1.*;
+import org.neo4j.driver.v1.types.*;
+import static org.neo4j.driver.v1.Values.parameters;
+import java.util.*;
+
+public class JavaQuickStart {
+    public static void main(String[] args) {
+        // Initialize driver.
+        Config config = Config.build().toConfig();
+        Driver driver = GraphDatabase.driver("bolt://localhost:7687",
+                                             AuthTokens.basic("",""),
+                                             config);
+        // Execute basic queries.
+        try (Session session = driver.session()) {
+            StatementResult rs1 = session.run("MATCH (n) DETACH DELETE n");
+            StatementResult rs2 = session.run(
+                "CREATE (alice: Person {name: 'Alice', age: 22})");
+            StatementResult rs3 = session.run( "MATCH (n) RETURN n");
+            List<Record> records = rs3.list();
+            Record record = records.get(0);
+            Node node = record.get("n").asNode();
+            System.out.println(node.get("name").asString());
+        } catch (Exception e) {
+            System.out.println(e);
+            System.exit(1);
+        }
+        // Cleanup.
+        driver.close();
+    }
+}
+```
+
+### Javascript Driver Example
+
+The details about Javascript driver can be found
+[on GitHub](https://github.com/neo4j/neo4j-javascript-driver).
+
+The Javascript example below is equivalent to Python and Java examples.
+
+Here is an example related to `Node.js`. Memgraph doesn't have integrated
+support for `WebSocket` which is required during the execution in any web
+browser. If you want to run `openCypher` queries from a web browser,
+[websockify](https://github.com/novnc/websockify) has to be up and running.
+Requests from web browsers are wrapped into `WebSocket` messages, and a proxy
+is needed to handle the overhead. The proxy has to be configured to point out
+to Memgraph's Bolt port and web browser driver has to send requests to the
+proxy port.
+
+```javascript
+var neo4j = require('neo4j-driver').v1;
+var driver = neo4j.driver("bolt://localhost:7687",
+                          neo4j.auth.basic("neo4j", "1234"));
+var session = driver.session();
+
+function die() {
+  session.close();
+  driver.close();
+}
+
+function run_query(query, callback) {
+  var run = session.run(query, {});
+  run.then(callback).catch(function (error) {
+    console.log(error);
+    die();
+  });
+}
+
+run_query("MATCH (n) DETACH DELETE n", function (result) {
+  console.log("Database cleared.");
+  run_query("CREATE (alice: Person {name: 'Alice', age: 22})", function (result) {
+    console.log("Record created.");
+    run_query("MATCH (n) RETURN n", function (result) {
+      console.log("Record matched.");
+      var alice = result.records[0].get("n");
+      console.log(alice.labels[0]);
+      console.log(alice.properties["name"]);
+      session.close();
+      driver.close();
+    });
+  });
+});
+```
+
+### C# Driver Example
+
+The C# driver is hosted
+[on GitHub](https://github.com/neo4j/neo4j-dotnet-driver). The example below
+performs the same work as all of the previous examples.
+
+```csh
+using System;
+using System.Linq;
+using Neo4j.Driver.V1;
+
+public class Basic {
+  public static void Main(string[] args) {
+    // Initialize the driver.
+    var config = Config.DefaultConfig;
+    using(var driver = GraphDatabase.Driver("bolt://localhost:7687", AuthTokens.None, config))
+      using(var session = driver.Session())
+      {
+        // Run basic queries.
+        session.Run("MATCH (n) DETACH DELETE n").Consume();
+        session.Run("CREATE (alice:Person {name: \"Alice\", age: 22})").Consume();
+        var result = session.Run("MATCH (n) RETURN n").First();
+        var alice = (INode) result["n"];
+        Console.WriteLine(alice["name"]);
+        Console.WriteLine(string.Join(", ", alice.Labels));
+        Console.WriteLine(alice["age"]);
+      }
+    Console.WriteLine("All ok!");
+  }
+}
+```
+
+### Secure Sockets Layer (SSL)
+
+Secure connections are supported and enabled by default. The server initially
+ships with a self-signed testing certificate. The certificate can be replaced
+by editing the following parameters in `/etc/memgraph/memgraph.conf`:
+```
+--cert-file=/path/to/ssl/certificate.pem
+--key-file=/path/to/ssl/privatekey.pem
+```
+To disable SSL support and use insecure connections to the database you should
+set both parameters (`--cert-file` and `--key-file`) to empty values.
+
+### Limitations
+
+Memgraph is currently in early stage, and has a number of limitations we plan
+to remove in future versions.
+
+#### Multiple Users & Authorization
+
+Memgraph is currently single-user only. There is no way to control user
+privileges. The default user has read and write privileges over the whole
+database.

docs/user_technical/examples.md

@@ -0,0 +1,520 @@
+## Examples
+
+This chapter shows you how to use Memgraph on real-world data and how to get
+interesting and useful information out of it.
+
+### TED Talks Example
+
+[TED](https://www.ted.com/) is a nonprofit organization devoted to spreading
+ideas, usually in the form of short, powerful talks.
+Today, TED talks are influential videos from expert speakers on almost all
+topics — from science to business to global issues.
+Here we present a small dataset which consists of 97 talks. We'll show you how
+to model this data as a graph and demonstrate a few example queries.
+
+#### Data Model
+Each TED talk has a main speaker, so we
+identify two types of nodes — `Talk` and `Speaker`. Also, we will add
+an edge of type `Gave` pointing to a `Talk` from its main `Speaker`.
+Each speaker has a name so we can add property `name` to `Speaker` node.
+Likewise, we'll add properties `name`, `title` and `description` to node
+`Talk`. Furthermore, each talk is given in a specific TED event, so we can
+create node `Event` with property `name` and relationship `InEvent` between
+talk and event.
+
+Talks are tagged with keywords to facilitate searching, hence we
+add node `Tag` with property `name` and relationship `HasTag` between talk and
+tag. Moreover, users give ratings to each talk by selecting up to three
+predefined string values. Therefore we add node `Rating` with these values as
+property `name` and relationship`HasRating` with property `user_count` between
+talk and rating nodes.
+
+#### Example Queries
+
+We have prepared a database snapshot for this example, so you can easily import
+it when starting Memgraph using the `--durability-directory` option.
+
+```bash
+/usr/lib/memgraph/memgraph --durability-directory /usr/share/memgraph/examples/TEDTalk \
+  --durability-enabled=false --snapshot-on-exit=false
+```
+
+When using Memgraph installed from DEB or RPM package, you may need to stop
+the currently running Memgraph server before you can import the example. Use
+the following command:
+
+```bash
+systemctl stop memgraph
+```
+
+When using Docker, you can import the example with the following command:
+
+```bash
+docker run -p 7687:7687 \
+  -v mg_lib:/var/lib/memgraph -v mg_log:/var/log/memgraph -v mg_etc:/etc/memgraph \
+  memgraph --durability-directory /usr/share/memgraph/examples/TEDTalk \
+  --durability-enabled=false --snapshot-on-exit=false
+```
+
+Now you're ready to try out some of the following queries.
+
+NOTE: If you modify the dataset, the changes will stay only during this run of
+Memgraph.
+
+1) Find all talks given by specific speaker:
+
+```opencypher
+MATCH (n:Speaker {name: "Hans Rosling"})-[:Gave]->(m:Talk)
+RETURN m.title;
+```
+
+2) Find the top 20 speakers with most talks given:
+
+```opencypher
+MATCH (n:Speaker)-[:Gave]->(m)
+RETURN n.name, COUNT(m) AS TalksGiven
+ORDER BY TalksGiven DESC LIMIT 20;
+```
+
+3) Find talks related by tag to specific talk and count them:
+
+```opencypher
+MATCH (n:Talk {name: "Michael Green: Why we should build wooden skyscrapers"})
+      -[:HasTag]->(t:Tag)<-[:HasTag]-(m:Talk)
+WITH * ORDER BY m.name
+RETURN t.name, COLLECT(m.name), COUNT(m) AS TalksCount
+ORDER BY TalksCount DESC;
+```
+
+4) Find 20 most frequently used tags:
+
+```opencypher
+MATCH (t:Tag)<-[:HasTag]-(n:Talk)
+RETURN t.name AS Tag, COUNT(n) AS TalksCount
+ORDER BY TalksCount DESC, Tag LIMIT 20;
+```
+
+5) Find 20 talks most rated as "Funny". If you want to query by other ratings,
+possible values are: Obnoxious, Jaw-dropping, OK, Persuasive, Beautiful,
+Confusing, Longwinded, Unconvincing, Fascinating, Ingenious, Courageous, Funny,
+Informative and Inspiring.
+
+```opencypher
+MATCH (r:Rating{name:"Funny"})<-[e:HasRating]-(m:Talk)
+RETURN m.name, e.user_count ORDER BY e.user_count DESC LIMIT 20;
+```
+
+6) Find inspiring talks and their speakers from the field of technology:
+
+```opencypher
+MATCH (n:Talk)-[:HasTag]->(m:Tag {name: "technology"})
+MATCH (n)-[r:HasRating]->(p:Rating {name: "Inspiring"})
+MATCH (n)<-[:Gave]-(s:Speaker)
+WHERE r.user_count > 1000
+RETURN n.title, s.name, r.user_count ORDER BY r.user_count DESC;
+```
+
+7) Now let's see one real-world example &mdash; how to make a real-time
+recommendation. If you've just watched a talk from a certain
+speaker (e.g. Hans Rosling) you might be interested in finding more talks from
+the same speaker on a similar topic:
+
+```opencypher
+MATCH (n:Speaker {name: "Hans Rosling"})-[:Gave]->(m:Talk)
+MATCH (t:Talk {title: "New insights on poverty"})-[:HasTag]->(tag:Tag)<-[:HasTag]-(m)
+WITH * ORDER BY tag.name
+RETURN m.title as Title, COLLECT(tag.name), COUNT(tag) as TagCount
+ORDER BY TagCount DESC, Title;
+```
+
+The following few queries are focused on extracting information about
+TED events.
+
+8) Find how many talks were given per event:
+
+```opencypher
+MATCH (n:Event)<-[:InEvent]-(t:Talk)
+RETURN n.name as Event, COUNT(t) AS TalksCount
+ORDER BY TalksCount DESC, Event
+LIMIT 20;
+```
+
+9) Find the most popular tags in the specific event:
+
+```opencypher
+MATCH (n:Event {name:"TED2006"})<-[:InEvent]-(t:Talk)-[:HasTag]->(tag:Tag)
+RETURN tag.name as Tag, COUNT(t) AS TalksCount
+ORDER BY TalksCount DESC, Tag
+LIMIT 20;
+```
+
+10) Discover which speakers participated in more than 2 events:
+
+```opencypher
+MATCH (n:Speaker)-[:Gave]->(t:Talk)-[:InEvent]->(e:Event)
+WITH n, COUNT(e) AS EventsCount WHERE EventsCount > 2
+RETURN n.name as Speaker, EventsCount
+ORDER BY EventsCount DESC, Speaker;
+```
+
+11) For each speaker search for other speakers that participated in same
+events:
+
+```opencypher
+MATCH (n:Speaker)-[:Gave]->()-[:InEvent]->(e:Event)<-[:InEvent]-()<-[:Gave]-(m:Speaker)
+WHERE n.name != m.name
+WITH DISTINCT n, m ORDER BY m.name
+RETURN n.name AS Speaker, COLLECT(m.name) AS Others
+ORDER BY Speaker;
+```
+
+### Football Example
+
+[Football](https://en.wikipedia.org/wiki/Association_football)
+(soccer for the heathens) is a team sport played between two teams of eleven
+players with a spherical ball. The game is played on a rectangular pitch with
+a goal at each and. The object of the game is to score by moving the ball
+beyond the goal line into the opposing goal. The game is played by more than
+250 million players in over 200 countries, making it the world's most
+popular sport.
+
+In this example, we will present a graph model of a reasonably sized dataset
+of football matches across world's most popular leagues.
+
+#### Data Model
+
+In essence, we are trying to model a set of football matches. All information
+about a single match is going to be contained in three nodes and two edges.
+Two of the nodes will represent the teams that have played the match, while the
+third node will represent the game itself. Both edges are directed from the
+team nodes to the game node and are labeled as `:Played`.
+
+Let us consider a real life example of this model&mdash;Arsene Wenger's 1000th.
+game in charge of Arsenal. This was a regular fixture of a 2013/2014
+English Premier League, yet it was written in the stars that this historic
+moment would be a big London derby against Chelsea on Stanford Bridge. The
+sketch below shows how this game is being modeled in our database.
+
+```
++---------------+                                            +-----------------------------+
+|n: Team        |                                            |w: Game                      |
+|               |-[:Played {side: "home", outcome: "won"}]-->|                             |
+|name: "Chelsea"|                                            |HT_home_score: 4             |
++---------------+                                            |HT_away_score: 0             |
+                                                             |HT_result: "H"               |
+                                                             |FT_home_score: 6             |
+                                                             |FT_away_score: 0             |
+                                                             |FT_result: "H"               |
++---------------+                                            |date: "2014-03-22"           |
+|m: Team        |                                            |league: "ENG-Premier League" |
+|               |-[:Played {side: "away", outcome: "lost"}]->|season: 2013                 |
+|name: "Arsenal"|                                            |referee: "Andre Marriner"    |
++---------------+                                            +-----------------------------+
+```
+
+#### Example Queries
+
+We have prepared a database snapshot for this example, so you can easily import
+it when starting Memgraph using the `--durability-directory` option.
+
+```bash
+/usr/lib/memgraph/memgraph --durability-directory /usr/share/memgraph/examples/football \
+  --durability-enabled=false --snapshot-on-exit=false
+```
+
+When using Docker, you can import the example with the following command:
+
+```bash
+docker run -p 7687:7687 \
+  -v mg_lib:/var/lib/memgraph -v mg_log:/var/log/memgraph -v mg_etc:/etc/memgraph \
+  memgraph --durability-directory /usr/share/memgraph/examples/football \
+  --durability-enabled=false --snapshot-on-exit=false
+```
+
+Now you're ready to try out some of the following queries.
+
+NOTE: If you modify the dataset, the changes will stay only during this run of
+Memgraph.
+
+1) You might wonder, what leagues are supported?
+
+```opencypher
+MATCH (n:Game)
+RETURN DISTINCT n.league AS League
+ORDER BY League;
+```
+
+2) We have stored a certain number of seasons for each league. What is the
+oldest/newest season we have included?
+
+```opencypher
+MATCH (n:Game)
+RETURN DISTINCT n.league AS League, MIN(n.season) AS Oldest, MAX(n.season) AS Newest
+ORDER BY League;
+```
+
+3) You have already seen one game between Chelsea and Arsenal, let's list all of
+them in chronological order.
+
+```opencypher
+MATCH (n:Team {name: "Chelsea"})-[e:Played]->(w:Game)<-[f:Played]-(m:Team {name: "Arsenal"})
+RETURN w.date AS Date, e.side AS Chelsea, f.side AS Arsenal,
+       w.FT_home_score AS home_score, w.FT_away_score AS away_score
+ORDER BY Date;
+```
+
+4) How about filtering games in which Chelsea won?
+
+```opencypher
+MATCH (n:Team {name: "Chelsea"})-[e:Played {outcome: "won"}]->
+      (w:Game)<-[f:Played]-(m:Team {name: "Arsenal"})
+RETURN w.date AS Date, e.side AS Chelsea, f.side AS Arsenal,
+       w.FT_home_score AS home_score, w.FT_away_score AS away_score
+ORDER BY Date;
+```
+
+5) Home field advantage is a thing in football. Let's list the number of home
+defeats for each Premier League team in the 2016/2017 season.
+
+```opencypher
+MATCH (n:Team)-[:Played {side: "home", outcome: "lost"}]->
+      (w:Game {league: "ENG-Premier League", season: 2016})
+RETURN n.name AS Team, count(w) AS home_defeats
+ORDER BY home_defeats, Team;
+```
+
+6) At the end of the season the team with the most points wins the league. For
+each victory, a team is awarded 3 points and for each draw it is awarded
+1 point. Let's find out how many points did reigning champions (Chelsea) have
+at the end of 2016/2017 season.
+
+```opencypher
+MATCH (n:Team {name: "Chelsea"})-[:Played {outcome: "drew"}]->(w:Game {season: 2016})
+WITH n, COUNT(w) AS draw_points
+MATCH (n)-[:Played {outcome: "won"}]->(w:Game {season: 2016})
+RETURN draw_points + 3 * COUNT(w) AS total_points;
+```
+
+7) In fact, why not retrieve the whole table?
+
+```opencypher
+MATCH (n)-[:Played {outcome: "drew"}]->(w:Game {league: "ENG-Premier League", season: 2016})
+WITH n, COUNT(w) AS draw_points
+MATCH (n)-[:Played {outcome: "won"}]->(w:Game {league: "ENG-Premier League", season: 2016})
+RETURN n.name AS Team, draw_points + 3 * COUNT(w) AS total_points
+ORDER BY total_points DESC;
+```
+
+8) People have always debated which of the major leagues is the most exciting.
+One basic metric is the average number of goals per game. Let's see the results
+at the end of the 2016/2017 season. WARNING: This might shock you.
+
+```opencypher
+MATCH (w:Game {season: 2016})
+RETURN w.league, AVG(w.FT_home_score) + AVG(w.FT_away_score) AS avg_goals_per_game
+ORDER BY avg_goals_per_game DESC;
+```
+
+9) Another metric might be the number of comebacks&mdash;games where one side
+was winning at half time but were overthrown by the other side by the end
+of the match. Let's count such occurrences during all supported seasons across
+all supported leagues.
+
+```opencypher
+MATCH (g:Game) WHERE
+(g.HT_result = "H" AND g.FT_result = "A") OR
+(g.HT_result = "A" AND g.FT_result = "H")
+RETURN g.league AS League, count(g) AS Comebacks
+ORDER BY Comebacks DESC;
+```
+
+10) Exciting leagues also tend to be very unpredictable. On that note, let's list
+all triplets of teams where, during the course of one season, team A won against
+team B, team B won against team C and team C won against team A.
+
+```opencypher
+MATCH (a)-[:Played {outcome: "won"}]->(p:Game {league: "ENG-Premier League", season: 2016})<--
+      (b)-[:Played {outcome: "won"}]->(q:Game {league: "ENG-Premier League", season: 2016})<--
+      (c)-[:Played {outcome: "won"}]->(r:Game {league: "ENG-Premier League", season: 2016})<--(a)
+WHERE p.date < q.date AND q.date < r.date
+RETURN a.name AS Team1, b.name AS Team2, c.name AS Team3;
+```
+
+### European road network example
+
+In this section we will show how to use some of Memgraph's built-in graph
+algorithms. More specifically, we will show how to use breadth-first search
+graph traversal algorithm, and Dijkstra's algorithm for finding weighted
+shortest paths between nodes in the graph.
+
+#### Data model
+
+One of the most common applications of graph traversal algorithms is driving
+route computation, so we will use European road network graph as an example.
+The graph consists of 999 major European cities from 39 countries in total.
+Each city is connected to the country it belongs to via an edge of type `:In_`.
+There are edges of type `:Road` connecting cities less than 500 kilometers
+apart. Distance between cities is specified in the `length` property of the
+edge.
+
+
+#### Example queries
+
+We have prepared a database snapshot for this example, so you can easily import
+it when starting Memgraph using the `--durability-directory` option.
+
+```bash
+/usr/lib/memgraph/memgraph --durability-directory /usr/share/memgraph/examples/Europe \
+  --durability-enabled=false --snapshot-on-exit=false
+```
+
+When using Docker, you can import the example with the following command:
+
+```bash
+docker run -p 7687:7687 \
+  -v mg_lib:/var/lib/memgraph -v mg_log:/var/log/memgraph -v mg_etc:/etc/memgraph \
+  memgraph --durability-directory /usr/share/memgraph/examples/Europe \
+  --durability-enabled=false --snapshot-on-exit=false
+```
+
+Now you're ready to try out some of the following queries.
+
+NOTE: If you modify the dataset, the changes will stay only during this run of
+Memgraph.
+
+Let's start off with a few simple queries.
+
+1) Let's list all of the countries in our road network.
+
+```opencypher
+MATCH (c:Country) RETURN c.name ORDER BY c.name;
+```
+
+2) Which Croatian cities are in our road network?
+
+```opencypher
+MATCH (c:City)-[:In_]->(:Country {name: "Croatia"})
+RETURN c.name ORDER BY c.name;
+```
+
+3) Which cities in our road network are less than 200 km away from Zagreb?
+
+```opencypher
+MATCH (:City {name: "Zagreb"})-[r:Road]->(c:City)
+WHERE r.length < 200
+RETURN c.name ORDER BY c.name;
+```
+
+Now let's try some queries using Memgraph's graph traversal capabilities.
+
+4) Say you want to drive from Zagreb to Paris. You might wonder, what is the
+least number of cities you have to visit if you don't want to drive more than
+500 kilometers between stops. Since the edges in our road network don't connect
+cities that are more than 500 km apart, this is a great use case for the
+breadth-first search (BFS) algorithm.
+
+```opencypher
+MATCH p = (:City {name: "Zagreb"})
+          -[:Road * bfs]->
+          (:City {name: "Paris"})
+RETURN nodes(p);
+```
+
+5) What if we want to bike to Paris instead of driving? It is unreasonable (and
+dangerous!) to bike 500 km per day. Let's limit ourselves to biking no more
+than 200 km in one go.
+
+```opencypher
+MATCH p = (:City {name: "Zagreb"})
+          -[:Road * bfs (e, v | e.length <= 200)]->
+          (:City {name: "Paris"})
+RETURN nodes(p);
+```
+
+"What is this special syntax?", you might wonder.
+
+`(e, v | e.length <= 200)` is called a *filter lambda*. It's a function that
+takes an edge symbol `e` and a vertex symbol `v` and decides whether this edge
+and vertex pair should be considered valid in breadth-first expansion by
+returning true or false (or nil). In the above example, lambda is returning
+true if edge length is not greater than 200, because we don't want to bike more
+than 200 km in one go.
+
+6) Let's say we also don't want to visit Vienna on our way to Paris, because we
+have a lot of friends there and visiting all of them would take up a lot of our
+time. We just have to update our filter lambda.
+
+```opencypher
+MATCH p = (:City {name: "Zagreb"})
+          -[:Road * bfs (e, v | e.length <= 200 AND v.name != "Vienna")]->
+          (:City {name: "Paris"})
+RETURN nodes(p);
+```
+
+As you can see, without the additional restriction we could visit 11 cities. If
+we want to avoid Vienna, we must visit at least 12 cities.
+
+7) Instead of counting the cities visited, we might want to find the shortest
+paths in terms of distance travelled. This is a textbook application of
+Dijkstra's algorithm. The following query will return the list of cities on the
+shortest path from Zagreb to Paris along with the total length of the path.
+
+```opencypher
+MATCH p = (:City {name: "Zagreb"})
+          -[:Road * wShortest (e, v | e.length) total_weight]->
+          (:City {name: "Paris"})
+RETURN nodes(p) as cities, total_weight;
+```
+
+As you can see, the syntax is quite similar to breadth-first search syntax.
+Instead of a filter lambda, we need to provide a *weight lambda* and the *total
+weight symbol*. Given an edge and vertex pair, weight lambda must return the
+cost of expanding to the given vertex using the given edge. The path returned
+will have the smallest possible sum of costs and it will be stored in the total
+weight symbol. A limitation of Dijkstra's algorithm is that the cost must be
+non-negative.
+
+8) We can also combine weight and filter lambdas in the shortest-path query.
+Let's say we're interested in the shortest path that doesn't require travelling
+more that 200 km in one go for our bike route.
+
+```opencypher
+MATCH p = (:City {name: "Zagreb"})
+      -[:Road * wShortest (e, v | e.length) total_weight (e, v | e.length <= 200)]->
+      (:City {name: "Paris"})
+RETURN nodes(p) as cities, total_weight;
+```
+
+9) Let's try and find 10 cities that are furthest away from Zagreb.
+
+```opencypher
+MATCH (:City {name: "Zagreb"})
+      -[:Road * wShortest (e, v | e.length) total_weight]->
+      (c:City)
+RETURN c, total_weight
+ORDER BY total_weight DESC LIMIT 10;
+```
+
+It is not surprising to see that they are all in Siberia.
+
+
+To learn more about these algorithms, we suggest you check out their Wikipedia
+pages:
+
+* [Breadth-first search](https://en.wikipedia.org/wiki/Breadth-first_search)
+* [Dijkstra's algorithm](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm)
+
+
+Now you're ready to explore the world of graph databases with Memgraph
+by yourself and try it on many more examples and datasets.
+
+### Graph Gists Examples
+
+A nice looking set of small graph examples can be found
+[here](https://neo4j.com/graphgists/).  You can take any use-case and try to
+execute the queries against Memgraph. To clear the database between trying out
+examples, execute the query:
+
+```opencypher
+MATCH (n) DETACH DELETE n;
+```

docs/user_technical/import-tools.md

@@ -0,0 +1,118 @@
+## Import Tools
+
+Memgraph comes with tools for importing data into the database. Currently,
+only import of CSV formatted is supported. We plan to support more formats in
+the future.
+
+### CSV Import Tool
+
+CSV data should be in Neo4j CSV compatible format. Detailed format
+specification can be found
+[here](https://neo4j.com/docs/operations-manual/current/tools/import/file-header-format/).
+
+The import tool is run from the console, using the `mg_import_csv` command.
+
+If you installed Memgraph using Docker, you will need to run the importer
+using the following command:
+
+```bash
+docker run -v mg_lib:/var/lib/memgraph -v mg_etc:/etc/memgraph -v mg_import:/import-data \
+  --entrypoint=mg_import_csv memgraph
+```
+
+You can pass CSV files containing node data using the `--nodes` option.
+Multiple files can be specified by repeating the `--nodes` option.  At least
+one node file should be specified. Similarly, graph edges (also known as
+relationships) are passed via the `--relationships` option.  Multiple
+relationship files are imported by repeating the option. Unlike nodes,
+relationships are not required.
+
+After reading the CSV files, the tool will by default search for the installed
+Memgraph configuration. If the configuration is found, the data will be
+written in the configured durability directory. If the configuration isn't
+found, you will need to use the `--out` option to specify the output file. You
+can use the same option to override the default behaviour.
+
+Memgraph will recover the imported data on the next startup by looking in the
+durability directory.
+
+For information on other options, run:
+
+```bash
+mg_import_csv --help
+```
+
+When using Docker, this translates to:
+
+```bash
+docker run --entrypoint=mg_import_csv memgraph --help
+```
+
+#### Example
+
+Let's import a simple dataset.
+
+Store the following in `comment_nodes.csv`.
+
+```csv
+id:ID(COMMENT_ID),country:string,browser:string,content:string,:LABEL
+0,Croatia,Chrome,yes,Message;Comment
+1,United Kingdom,Chrome,thanks,Message;Comment
+2,Germany,,LOL,Message;Comment
+3,France,Firefox,I see,Message;Comment
+4,Italy,Internet Explorer,fine,Message;Comment
+```
+
+Now, let's add `forum_nodes.csv`.
+
+```csv
+id:ID(FORUM_ID),title:string,:LABEL
+0,General,Forum
+1,Support,Forum
+2,Music,Forum
+3,Film,Forum
+4,Programming,Forum
+```
+
+And finally, set relationships between comments and forums in
+`relationships.csv`.
+
+```csv
+:START_ID(COMMENT_ID),:END_ID(FORUM_ID),:TYPE
+0,0,POSTED_ON
+1,1,POSTED_ON
+2,2,POSTED_ON
+3,3,POSTED_ON
+4,4,POSTED_ON
+```
+
+Now, you can import the dataset in Memgraph.
+
+WARNING: Your existing recovery data will be considered obsolete, and Memgraph
+will load the new dataset.
+
+Use the following command:
+
+```bash
+mg_import_csv --overwrite --nodes=comment_nodes.csv --nodes=forum_nodes.csv --relationships=relationships.csv
+```
+
+If using Docker, things are a bit more complicated. First you need to move the
+CSV files where the Docker image can see them:
+
+```bash
+mkdir -p /var/lib/docker/volumes/mg_import/_data
+cp comment_nodes.csv forum_nodes.csv relationships.csv /var/lib/docker/volumes/mg_import/_data
+```
+
+Then, run the importer with the following:
+
+```bash
+docker run -v mg_lib:/var/lib/memgraph -v mg_etc:/etc/memgraph -v mg_import:/import-data \
+  --entrypoint=mg_import_csv memgraph \
+  --overwrite \
+  --nodes=/import-data/comment_nodes.csv --nodes=/import-data/forum_nodes.csv \
+  --relationships=/import-data/relationships.csv
+```
+
+Next time you run Memgraph, the dataset will be loaded.

docs/user_technical/open-cypher.md

@@ -0,0 +1,858 @@
+## openCypher Query Language
+
+[*openCypher*](http://www.opencypher.org/) is a query language for querying
+graph databases. It aims to be intuitive and easy to learn, while
+providing a powerful interface for working with graph based data.
+
+*Memgraph* supports most of the commonly used constructs of the language. This
+chapter contains the details of implemented features. Additionally,
+not yet supported features of the language are listed.
+
+  * [Reading Existing Data](#reading-existing-data)
+  * [Writing New Data](#writing-new-data)
+  * [Reading & Writing](#reading-amp-writing)
+  * [Indexing](#indexing)
+  * [Other Features](#other-features)
+
+### Reading Existing Data
+
+The simplest usage of the language is to find data stored in the
+database. For that purpose, the following clauses are offered:
+
+  * `MATCH`, which searches for patterns;
+  * `WHERE`, for filtering the matched data and
+  * `RETURN`, for defining what will be presented to the user in the result
+    set.
+  * `UNION` and `UNION ALL` for combining results from multiple queries.
+
+#### MATCH
+
+This clause is used to obtain data from Memgraph by matching it to a given
+pattern. For example, to find each node in the database, you can use the
+following query.
+
+```opencypher
+MATCH (node) RETURN node
+```
+
+Finding connected nodes can be achieved by using the query:
+
+```opencypher
+MATCH (node1)-[connection]-(node2) RETURN node1, connection, node2
+```
+
+In addition to general pattern matching, you can narrow the search down by
+specifying node labels and properties. Similarly, edge types and properties
+can also be specified. For example, finding each node labeled as `Person` and
+with property `age` being 42, is done with the following query.
+
+```opencypher
+MATCH (n :Person {age: 42}) RETURN n
+```
+
+While their friends can be found with the following.
+
+```opencypher
+MATCH (n :Person {age: 42})-[:FriendOf]-(friend) RETURN friend
+```
+
+There are cases when a user needs to find data which is connected by
+traversing a path of connections, but the user doesn't know how many
+connections need to be traversed. openCypher allows for designating patterns
+with *variable path lengths*. Matching such a path is achieved by using the
+`*` (*asterisk*) symbol inside the edge element of a pattern. For example,
+traversing from `node1` to `node2` by following any number of connections in a
+single direction can be achieved with:
+
+```opencypher
+MATCH (node1)-[r*]->(node2) RETURN node1, r, node2
+```
+
+If paths are very long, finding them could take a long time. To prevent that,
+a user can provide the minimum and maximum length of the path. For example,
+paths of length between 2 and 4 can be obtained with a query like:
+
+```opencypher
+MATCH (node1)-[r*2..4]->(node2) RETURN node1, r, node2
+```
+
+It is possible to name patterns in the query and return the resulting paths.
+This is especially useful when matching variable length paths:
+
+```opencypher
+MATCH path = ()-[r*2..4]->() RETURN path
+```
+
+More details on how `MATCH` works can be found
+[here](https://neo4j.com/docs/developer-manual/current/cypher/clauses/match/).
+
+The `MATCH` clause can be modified by prepending the `OPTIONAL` keyword.
+`OPTIONAL MATCH` clause behaves the same as a regular `MATCH`, but when it
+fails to find the pattern, missing parts of the pattern will be filled with
+`null` values. Examples can be found
+[here](https://neo4j.com/docs/developer-manual/current/cypher/clauses/optional-match/).
+
+#### WHERE
+
+You have already seen that simple filtering can be achieved by using labels
+and properties in `MATCH` patterns. When more complex filtering is desired,
+you can use `WHERE` paired with `MATCH` or `OPTIONAL MATCH`. For example,
+finding each person older than 20 is done with the this query.
+
+```opencypher
+MATCH (n :Person) WHERE n.age > 20 RETURN n
+```
+
+Additional examples can be found
+[here](https://neo4j.com/docs/developer-manual/current/cypher/clauses/where/).
+
+#### RETURN
+
+The `RETURN` clause defines which data should be included in the resulting
+set. Basic usage was already shown in the examples for `MATCH` and `WHERE`
+clauses. Another feature of `RETURN` is renaming the results using the `AS`
+keyword.
+
+Example.
+
+```opencypher
+MATCH (n :Person) RETURN n AS people
+```
+
+That query would display all nodes under the header named `people` instead of
+`n`.
+
+When you want to get everything that was matched, you can use the `*`
+(*asterisk*) symbol.
+
+This query:
+
+```opencypher
+MATCH (node1)-[connection]-(node2) RETURN *
+```
+
+is equivalent to:
+
+```opencypher
+MATCH (node1)-[connection]-(node2) RETURN node1, connection, node2
+```
+
+`RETURN` can be followed by the `DISTINCT` operator, which will remove
+duplicate results. For example, getting unique names of people can be achieved
+with:
+
+```opencypher
+MATCH (n :Person) RETURN DISTINCT n.name
+```
+
+Besides choosing what will be the result and how it will be named, the
+`RETURN` clause can also be used to:
+
+  * limit results with `LIMIT` sub-clause;
+  * skip results with `SKIP` sub-clause;
+  * order results with `ORDER BY` sub-clause and
+  * perform aggregations (such as `count`).
+
+More details on `RETURN` can be found
+[here](https://neo4j.com/docs/developer-manual/current/cypher/clauses/return/).
+
+##### SKIP & LIMIT
+
+These sub-clauses take a number of how many results to skip or limit.
+For example, to get the first 3 results you can use this query.
+
+```opencypher
+MATCH (n :Person) RETURN n LIMIT 3
+```
+
+If you want to get all the results after the first 3, you can use the
+following.
+
+```opencypher
+MATCH (n :Person) RETURN n SKIP 3
+```
+
+The `SKIP` and `LIMIT` can be combined. So for example, to get the 2nd result,
+you can do:
+
+```opencypher
+MATCH (n :Person) RETURN n SKIP 1 LIMIT 1
+```
+
+##### ORDER BY
+
+Since the patterns which are matched can come in any order, it is very useful
+to be able to enforce some ordering among the results. In such cases, you can
+use the `ORDER BY` sub-clause.
+
+For example, the following query will get all `:Person` nodes and order them
+by their names.
+
+```opencypher
+MATCH (n :Person) RETURN n ORDER BY n.name
+```
+
+By default, ordering will be in the ascending order. To change the order to be
+descending, you should append `DESC`.
+
+For example, to order people by their name descending, you can use this query.
+
+```opencypher
+MATCH (n :Person) RETURN n ORDER BY n.name DESC
+```
+
+You can also order by multiple variables. The results will be sorted by the
+first variable listed. If the values are equal, the results are sorted by the
+second variable, and so on.
+
+Example. Ordering by first name descending and last name ascending.
+
+```opencypher
+MATCH (n :Person) RETURN n ORDER BY n.name DESC, n.lastName
+```
+
+Note that `ORDER BY` sees only the variable names as carried over by `RETURN`.
+This means that the following will result in an error.
+
+```opencypher
+MATCH (n :Person) RETURN old AS new ORDER BY old.name
+```
+
+Instead, the `new` variable must be used:
+
+```opencypher
+MATCH (n: Person) RETURN old AS new ORDER BY new.name
+```
+
+The `ORDER BY` sub-clause may come in handy with `SKIP` and/or `LIMIT`
+sub-clauses. For example, to get the oldest person you can use the following.
+
+```opencypher
+MATCH (n :Person) RETURN n ORDER BY n.age DESC LIMIT 1
+```
+
+##### Aggregating
+
+openCypher has functions for aggregating data. Memgraph currently supports
+the following aggregating functions.
+
+  * `avg`, for calculating the average.
+  * `collect`, for collecting multiple values into a single list or map. If given a single expression values are collected into a list. If given two expressions, values are collected into a map where the first expression denotes map keys (must be string values) and the second expression denotes map values.
+  * `count`, for counting the resulting values.
+  * `max`, for calculating the maximum result.
+  * `min`, for calculating the minimum result.
+  * `sum`, for getting the sum of numeric results.
+
+Example, calculating the average age:
+
+```opencypher
+MATCH (n :Person) RETURN avg(n.age) AS averageAge
+```
+
+Collecting items into a list:
+
+```opencypher
+MATCH (n :Person) RETURN collect(n.name) AS list_of_names
+```
+
+Collecting items into a map:
+
+```opencypher
+MATCH (n :Person) RETURN collect(n.name, n.age) AS map_name_to_age
+```
+
+Click
+[here](https://neo4j.com/docs/developer-manual/current/cypher/functions/aggregating/)
+for additional details on how aggregations work.
+
+#### UNION and UNION ALL
+
+openCypher supports combining results from multiple queries into a single result
+set. That result will contain rows that belong to queries in the union
+respecting the union type.
+
+Using `UNION` will contain only distinct rows while `UNION ALL` will keep all
+rows from all given queries.
+
+Restrictions when using `UNION` or `UNION ALL`:
+  * The number and the names of columns returned by queries must be the same
+    for all of them.
+  * There can be only one union type between single queries, i.e. a query can't
+    contain both `UNION` and `UNION ALL`.
+
+Example, get distinct names that are shared between persons and movies:
+
+```opencypher
+MATCH(n: Person) RETURN n.name AS name UNION MATCH(n: Movie) RETURN n.name AS name
+```
+
+Example, get all names that are shared between persons and movies (including duplicates):
+
+```opencypher
+MATCH(n: Person) RETURN n.name AS name UNION ALL MATCH(n: Movie) RETURN n.name AS name
+```
+
+### Writing New Data
+
+For adding new data, you can use the following clauses.
+
+  * `CREATE`, for creating new nodes and edges.
+  * `SET`, for adding new or updating existing labels and properties.
+  * `DELETE`, for deleting nodes and edges.
+  * `REMOVE`, for removing labels and properties.
+
+You can still use the `RETURN` clause to produce results after writing, but it
+is not mandatory.
+
+Details on which kind of data can be stored in *Memgraph* can be found in
+[Data Storage](storage.md) chapter.
+
+#### CREATE
+
+This clause is used to add new nodes and edges to the database. The creation
+is done by providing a pattern, similarly to `MATCH` clause.
+
+For example, to create 2 new nodes connected with a new edge, use this query.
+
+```opencypher
+CREATE (node1)-[:edge_type]->(node2)
+```
+
+Labels and properties can be set during creation using the same syntax as in
+[MATCH](#match) patterns. For example, creating a node with a label and a
+property:
+
+```opencypher
+CREATE (node :Label {property: "my property value"}
+```
+
+Additional information on `CREATE` is
+[here](https://neo4j.com/docs/developer-manual/current/cypher/clauses/create/).
+
+#### SET
+
+The `SET` clause is used to update labels and properties of already existing
+data.
+
+Example. Incrementing everyone's age by 1.
+
+```opencypher
+MATCH (n :Person) SET n.age = n.age + 1
+```
+
+Click
+[here](https://neo4j.com/docs/developer-manual/current/cypher/clauses/create/)
+for a more detailed explanation on what can be done with `SET`.
+
+#### DELETE
+
+This clause is used to delete nodes and edges from the database.
+
+Example. Removing all edges of a single type.
+
+```opencypher
+MATCH ()-[edge :type]-() DELETE edge
+```
+
+When testing the database, you want to often have a clean start by deleting
+every node and edge in the database. It is reasonable that deleting each node
+should delete all edges coming into or out of that node.
+
+```opencypher
+MATCH (node) DELETE node
+```
+
+But, openCypher prevents accidental deletion of edges. Therefore, the above
+query will report an error. Instead, you need to use the `DETACH` keyword,
+which will remove edges from a node you are deleting. The following should
+work and *delete everything* in the database.
+
+```opencypher
+MATCH (node) DETACH DELETE node
+```
+
+More examples are
+[here](https://neo4j.com/docs/developer-manual/current/cypher/clauses/delete/).
+
+#### REMOVE
+
+The `REMOVE` clause is used to remove labels and properties from nodes and
+edges.
+
+Example.
+
+```opencypher
+MATCH (n :WrongLabel) REMOVE n :WrongLabel, n.property
+```
+
+### Reading & Writing
+
+OpenCypher supports combining multiple reads and writes using the
+`WITH` clause. In addition to combining, the `MERGE` clause is provided which
+may create patterns if they do not exist.
+
+#### WITH
+
+The write part of the query cannot be simply followed by another read part. In
+order to combine them, `WITH` clause must be used. The names this clause
+establishes are transferred from one part to another.
+
+For example, creating a node and finding all nodes with the same property.
+
+```opencypher
+CREATE (node {property: 42}) WITH node.property AS propValue
+MATCH (n {property: propValue}) RETURN n
+```
+
+Note that the `node` is not visible after `WITH`, since only `node.property`
+was carried over.
+
+This clause behaves very much like `RETURN`, so you should refer to features
+of `RETURN`.
+
+#### MERGE
+
+The `MERGE` clause is used to ensure that a pattern you are looking for exists
+in the database. This means that if the pattern is not found, it will be
+created. In a way, this clause is like a combination of `MATCH` and `CREATE`.
+
+
+Example. Ensure that a person has at least one friend.
+
+```opencypher
+MATCH (n :Person) MERGE (n)-[:FriendOf]->(m)
+```
+
+The clause also provides additional features for updating the values depending
+on whether the pattern was created or matched. This is achieved with `ON
+CREATE` and `ON MATCH` sub clauses.
+
+Example. Set a different properties depending on what `MERGE` did.
+
+```opencypher
+MATCH (n :Person) MERGE (n)-[:FriendOf]->(m)
+ON CREATE SET m.prop = "created" ON MATCH SET m.prop = "existed"
+```
+
+For more details, click [this
+link](https://neo4j.com/docs/developer-manual/current/cypher/clauses/merge/).
+
+### Indexing
+
+An index stores additional information on certain types of data, so that
+retrieving said data becomes more efficient. Downsides of indexing are:
+
+  * requiring extra storage for each index and
+  * slowing down writes to the database.
+
+Carefully choosing which data to index can tremendously improve data retrieval
+efficiency, and thus make index downsides negligible.
+
+Memgraph automatically indexes labeled data. This improves queries
+which fetch nodes by label:
+
+```opencypher
+MATCH (n :Label) ... RETURN n
+```
+
+Indexing can also be applied to data with a specific combination of label and
+property. These are not automatically created, instead a user needs to create
+them explicitly. Creation is done using a special
+`CREATE INDEX ON :Label(property)` language construct.
+
+For example, to index nodes which is labeled as `:Person` and has a property
+named `age`:
+
+```opencypher
+CREATE INDEX ON :Person(age)
+```
+
+After the index is created, retrieving those nodes will become more efficient.
+For example, the following query will retrieve all nodes which have an `age`
+property, instead of fetching each `:Person` node and checking whether the
+property exists.
+
+```opencypher
+MATCH (n :Person {age: 42}) RETURN n
+```
+
+Using index based retrieval also works when filtering labels and properties
+with `WHERE`. For example, the same effect as in the previous example can be
+done with:
+
+```opencypher
+MATCH (n) WHERE n:Person AND n.age = 42 RETURN n
+```
+
+Since the filter inside `WHERE` can contain any kind of an expression, the
+expression can be complicated enough so that the index does not get used. We
+are continuously improving the recognition of index usage opportunities from a
+`WHERE` expression. If there is any suspicion that an index may not be used,
+we recommend putting properties and labels inside the `MATCH` pattern.
+
+Currently, once an index is created it cannot be deleted. This feature will be
+implemented very soon. The expected syntax for removing an index will be `DROP
+INDEX ON :Label(property)`.
+
+### Other Features
+
+The following sections describe some of the other supported features.
+
+#### Filtering Variable Length Paths
+
+OpenCypher supports only simple filtering when matching variable length paths.
+For example:
+
+```opencypher
+MATCH (n)-[edge_list:Type * {x: 42}]-(m)
+```
+
+This will produce only those paths whose edges have the required `Type` and `x`
+property value. Edges that compose the produced paths are stored in a symbol
+named `edge_list`. Naturally, the user could have specified any other symbol
+name.
+
+Memgraph extends openCypher with a syntax for arbitrary filter expressions
+during path matching. The next example filters edges which have property `x`
+between `0` and `10`.
+
+```opencypher
+MATCH (n)-[edge_list * (edge, node | 0 < edge.x < 10)]-(m)
+```
+
+Here we introduce a lambda function with parentheses, where the first two
+arguments, `edge` and `node`, correspond to each edge and node during path
+matching. `node` is the destination node we are moving to across the current
+`edge`. The last `node` value will be the same value as `m`. Following the
+pipe (`|`) character is an arbitrary expression which must produce a boolean
+value.  If `True`, matching continues, otherwise the path is discarded.
+
+The previous example can be written using the `all` function:
+
+```opencypher
+MATCH (n)-[edge_list *]-(m) WHERE all(edge IN r WHERE 0 < edge.x < 10)
+```
+
+However, filtering using a lambda function is more efficient because paths
+may be discarded earlier in the traversal. Furthermore, it provides more
+flexibility for deciding what kind of paths are matched due to more expressive
+filtering capabilities. Therefore, filtering through lambda functions should
+be preferred whenever possible.
+
+#### Breadth First Search
+
+A typical graph use-case is searching for the shortest path between nodes.
+The openCypher standard does not define this feature, so Memgraph provides
+a custom implementation, based on the edge expansion syntax.
+
+Finding the shortest path between nodes can be done using breadth-first
+expansion:
+
+```opencypher
+MATCH (a {id: 723})-[edge_list:Type *bfs..10]-(b {id: 882}) RETURN *
+```
+
+The above query will find all paths of length up to 10 between nodes `a` and `b`.
+The edge type and maximum path length are used in the same way like in variable
+length expansion.
+
+To find only the shortest path, simply append `LIMIT 1` to the `RETURN` clause.
+
+```opencypher
+MATCH (a {id: 723})-[edge_list:Type *bfs..10]-(b {id: 882}) RETURN * LIMIT 1
+```
+
+Breadth-first expansion allows an arbitrary expression filter that determines
+if an expansion is allowed. Following is an example in which expansion is
+allowed only over edges whose `x` property is greater than `12` and nodes `y`
+whose property is less than `3`:
+
+```opencypher
+MATCH (a {id: 723})-[*bfs..10 (e, n | e.x > 12 AND n.y < 3)]-() RETURN *
+```
+
+The filter is defined as a lambda function over `e` and `n`, which denote the edge
+and node being expanded over in the breadth first search. Note that if the user
+omits the edge list symbol (`edge_list` in previous examples) it will not be included
+in the result.
+
+There are a few benefits of the breadth-first expansion approach, as opposed to
+a specialized `shortestPath` function. For one, it is possible to inject
+expressions that filter on nodes and edges along the path itself, not just the final
+destination node. Furthermore, it's possible to find multiple paths to multiple destination
+nodes regardless of their length. Also, it is possible to simply go through a node's
+neighbourhood in breadth-first manner.
+
+Currently, it isn't possible to get all shortest paths to a single node using
+Memgraph's breadth-first expansion.
+
+#### Weighted Shortest Path
+
+Another standard use-case in a graph is searching for the weighted shortest
+path between nodes. The openCypher standard does not define this feature, so
+Memgraph provides a custom implementation, based on the edge expansion syntax.
+
+Finding the weighted shortest path between nodes is done using the weighted
+shortest path expansion:
+
+```opencypher
+MATCH (a {id: 723})-[
+        edge_list *wShortest 10 (e, n | e.weight) total_weight
+    ]-(b {id: 882})
+RETURN *
+```
+
+The above query will find the shortest path of length up to 10 nodes between
+nodes `a`  and `b`. The length restriction parameter is optional.
+
+Weighted Shortest Path expansion allows an arbitrary expression that determines
+the weight for the current expansion. Total weight of a path is calculated as
+the sum of all weights on the path between two nodes. Following is an example in
+which the weight between nodes is defined as the product of edge weights
+(instead of sum), assuming all weights are greater than '1':
+
+```opencypher
+MATCH (a {id: 723})-[
+        edge_list *wShortest 10 (e, n | log(e.weight)) total_weight
+    ]-(b {id: 882})
+RETURN exp(total_weight)
+```
+
+Weighted Shortest Path expansions also allows an arbitrary expression filter
+that determines if an expansion is allowed. Following is an example in which
+expansion is allowed only over edges whose `x` property is greater than `12`
+and nodes `y` whose property is less than `3`:
+
+```opencypher
+MATCH (a {id: 723})-[
+        edge_list *wShortest 10 (e, n | e.weight) total_weight (e, n | e.x > 12 AND n.y < 3)
+    ]-(b {id: 882})
+RETURN exp(total_weight)
+```
+
+Both weight and filter expression are defined as lambda functions over `e` and
+`n`, which denote the edge and the node being expanded over in the weighted
+shortest path search.
+
+#### UNWIND
+
+The `UNWIND` clause is used to unwind a list of values as individual rows.
+
+Example. Produce rows out of a single list.
+
+```opencypher
+UNWIND [1,2,3] AS listElement RETURN listElement
+```
+
+More examples are
+[here](https://neo4j.com/docs/developer-manual/current/cypher/clauses/unwind/).
+
+#### Functions
+
+You have already been introduced to one type of functions, [aggregating
+functions](#aggregating). This section contains the list of other supported
+functions.
+
+ Name            | Description
+-----------------|------------
+ `coalesce`      | Returns the first non null argument.
+ `startNode`     | Returns the starting node of an edge.
+ `endNode`       | Returns the destination node of an edge.
+ `degree`        | Returns the number of edges (both incoming and outgoing) of a node.
+ `head`          | Returns the first element of a list.
+ `last`          | Returns the last element of a list.
+ `properties`    | Returns the properties of a node or an edge.
+ `size`          | Returns the number of elements in a list or a map. When given a string it returns the number of characters. When given a path it returns the number of expansions (edges) in that path.
+ `toBoolean`     | Converts the argument to a boolean.
+ `toFloat`       | Converts the argument to a floating point number.
+ `toInteger`     | Converts the argument to an integer.
+ `type`          | Returns the type of an edge as a character string.
+ `keys`          | Returns a list keys of properties from an edge or a node. Each key is represented as a string of characters.
+ `labels`        | Returns a list of labels from a node. Each label is represented as a character string.
+ `nodes`         | Returns a list of nodes from a path.
+ `relationships` | Returns a list of relationships from a path.
+ `range`         | Constructs a list of value in given range.
+ `tail`          | Returns all elements after the first of a given list.
+ `abs`           | Returns the absolute value of a number.
+ `ceil`          | Returns the smallest integer greater than or equal to given number.
+ `floor`         | Returns the largest integer smaller than or equal to given number.
+ `round`         | Returns the number, rounded to the nearest integer. Tie-breaking is done using the *commercial rounding*,  where -1.5 produces -2 and 1.5 produces 2.
+ `exp`           | Calculates `e^n` where `e` is the base of the natural logarithm, and `n` is the given number.
+ `log`           | Calculates the natural logarithm of a given number.
+ `log10`         | Calculates the logarithm (base 10) of a given number.
+ `sqrt`          | Calculates the square root of a given number.
+ `acos`          | Calculates the arccosine of a given number.
+ `asin`          | Calculates the arcsine of a given number.
+ `atan`          | Calculates the arctangent of a given number.
+ `atan2`         | Calculates the arctangent2 of a given number.
+ `cos`           | Calculates the cosine of a given number.
+ `sin`           | Calculates the sine of a given number.
+ `tan`           | Calculates the tangent of a given number.
+ `sign`          | Applies the signum function to a given number and returns the result. The signum of positive numbers is 1, of negative -1 and for 0 returns 0.
+ `e`             | Returns the base of the natural logarithm.
+ `pi`            | Returns the constant *pi*.
+ `rand`          | Returns a random floating point number between 0 (inclusive) and 1 (exclusive).
+ `startsWith`    | Check if the first argument starts with the second.
+ `endsWith`      | Check if the first argument ends with the second.
+ `contains`      | Check if the first argument has an element which is equal to the second argument.
+ `left`          | Returns a string containing the specified number of leftmost characters of the original string.
+ `lTrim`         | Returns the original string with leading whitespace removed.
+ `replace`       | Returns a string in which all occurrences of a specified string in the original string have been replaced by another (specified) string.
+ `reverse`       | Returns a string in which the order of all characters in the original string have been reversed.
+ `right`         | Returns a string containing the specified number of rightmost characters of the original string.
+ `rTrim`         | Returns the original string with trailing whitespace removed.
+ `split`         | Returns a list of strings resulting from the splitting of the original string around matches of the given delimiter.
+ `substring`     | Returns a substring of the original string, beginning with a 0-based index start and length.
+ `toLower`       | Returns the original string in lowercase.
+ `toString`      | Converts an integer, float or boolean value to a string.
+ `toUpper`       | Returns the original string in uppercase.
+ `trim`          | Returns the original string with leading and trailing whitespace removed.
+ `all`           | Check if all elements of a list satisfy a predicate.<br/>The syntax is: `all(variable IN list WHERE predicate)`.<br/> NOTE: Whenever possible, use Memgraph's lambda functions when [matching](#filtering-variable-length-paths) instead.
+ `single`        | Check if only one element of a list satisfies a predicate.<br/>The syntax is: `single(variable IN list WHERE predicate)`.
+ `reduce`        | Accumulate list elements into a single result by applying an expression. The syntax is:<br/>`reduce(accumulator = initial_value, variable IN list | expression)`.
+ `extract`       | A list of values obtained by evaluating an expression for each element in list. The syntax is:<br>`extract(variable IN list | expression)`.
+ `assert`        | Raises an exception reported to the client if the given argument is not `true`.
+ `counter`       | Generates integers that are guaranteed to be unique on the database level, for the given counter name.
+ `counterSet`    | Sets the counter with the given name to the given value.
+ `indexInfo`     | Returns a list of all the indexes available in the database. The list includes indexes that are not yet ready for use (they are concurrently being built by another transaction).
+ `timestamp`     | Returns the difference, measured in milliseconds, between the current time and midnight, January 1, 1970 UTC.
+ `id`            | Returns identifier for a given node or edge. The identifier is generated during the initialization of node or edge and will be persisted through the durability mechanism.
+
+#### String Operators
+
+Apart from comparison and concatenation operators openCypher provides special
+string operators for easier matching of substrings:
+
+Operator           | Description
+-------------------|------------
+ `a STARTS WITH b` | Returns true if prefix of string a is equal to string b.
+ `a ENDS WITH b`   | Returns true if suffix of string a is equal to string b.
+ `a CONTAINS b`    | Returns true if some substring of string a is equal to string b.
+
+#### Parameters
+
+When automating the queries for Memgraph, it comes in handy to change only
+some parts of the query. Usually, these parts are values which are used for
+filtering results or similar, while the rest of the query remains the same.
+
+Parameters allow reusing the same query, but with different parameter values.
+The syntax uses the `$` symbol to designate a parameter name. We don't allow
+old Cypher parameter syntax using curly braces. For example, you can parameterize
+filtering a node property:
+
+```opencypher
+MATCH (node1 {property: $propertyValue}) RETURN node1
+```
+
+You can use parameters instead of any literal in the query, but not instead of
+property maps even though that is allowed in standard openCypher. Following
+example is illegal in Memgraph:
+
+```opencypher
+MATCH (node1 $propertyValue) RETURN node1
+```
+
+To use parameters with Python driver use following syntax:
+
+```python
+session.run('CREATE (alice:Person {name: $name, age: $ageValue}',
+            name='Alice', ageValue=22)).consume()
+```
+
+To use parameters which names are integers you will need to wrap parameters in
+a dictionary and convert them to strings before running a query:
+
+```python
+session.run('CREATE (alice:Person {name: $0, age: $1}',
+            {'0': "Alice", '1': 22})).consume()
+```
+
+To use parameters with some other driver please consult appropriate
+documentation.
+
+#### CASE
+
+Conditional expressions can be expressed in openCypher language by simple and
+generic form of `CASE` expression. A simple form is used to compare an expression
+against multiple predicates. For the first matched predicate result of the
+expression provided after the `THEN` keyword is returned.  If no expression is
+matched value following `ELSE` is returned is provided, or `null` if `ELSE` is not
+used:
+
+```opencypher
+MATCH (n)
+RETURN CASE n.currency WHEN "DOLLAR" THEN "$" WHEN "EURO" THEN "€" ELSE "UNKNOWN" END
+```
+
+In generic form, you don't need to provide an expression whose value is compared to
+predicates, but you can list multiple predicates and the first one that evaluates
+to true is matched:
+
+```opencypher
+MATCH (n)
+RETURN CASE WHEN n.height < 30 THEN "short" WHEN n.height > 300 THEN "tall" END
+```
+
+### Differences
+
+Although we try to implement openCypher query language as closely to the
+language reference as possible, we had to make some changes to enhance the
+user experience.
+
+#### Symbolic Names
+
+We don't allow symbolic names (variables, label names...) to be openCypher
+keywords (WHERE, MATCH, COUNT, SUM...).
+
+#### Unicode Codepoints in String Literal
+
+Use `\u` followed by 4 hex digits in string literal for UTF-16 codepoint and
+`\U` with 8 hex digits for UTF-32 codepoint in Memgraph.
+
+
+### Difference from Neo4j's Cypher Implementation
+
+The openCypher initiative stems from Neo4j's Cypher query language. Following is a list
+of most important differences between Neo's Cypher and Memgraph's openCypher implementation,
+for users that are already familiar with Neo4j. There might be other differences not documented
+here (especially subtle semantic ones).
+
+#### Unsupported Constructs
+
+* Data importing. Memgraph doesn't support Cypher's CSV importing capabilities.
+* The `FOREACH` language construct for performing an operation on every list element.
+* The `CALL` construct for a standalone function call. This can be expressed using
+  `RETURN functioncall()`. For example, with Memgraph you can get information about
+  the indexes present in the database using the `RETURN indexinfo()` openCypher query.
+* Stored procedures.
+* Regular expressions for string matching.
+* `shortestPath` and `allShortestPaths` functions. `shortestPath` can be expressed using
+  Memgraph's breadth-first expansion syntax already described in this document.
+* Patterns in expressions. For example, Memgraph doesn't support `size((n)-->())`. Most of the time
+  the same functionalities can be expressed differently in Memgraph using `OPTIONAL` expansions,
+  function calls etc.
+* Map projections such as `MATCH (n) RETURN n {.property1, .property2}`.
+
+#### Unsupported Functions
+
+General purpose functions:
+
+* `exists(n.property)` - This can be expressed using `n.property IS NOT NULL`.
+* `length()` is named `size()` in Memgraph.
+
+Aggregation functions:
+
+* `count(DISTINCT variable)` - This can be expressed using `WITH DISTINCT variable RETURN count(variable)`.
+
+Mathematical functions:
+
+* `percentileDisc()`
+* `stDev()`
+* `point()`
+* `distance()`
+* `degrees()`
+
+List functions:
+
+* `any()`
+* `none()`

docs/user_technical/quick-start.md

@@ -0,0 +1,281 @@
+## Quick Start
+
+This chapter outlines installing and running Memgraph, as well as executing
+basic queries against the database.
+
+### Installation
+
+The Memgraph binary is offered as:
+
+  * Debian package for Debian 9 (Stretch);
+  * RPM package for CentOS 7 and
+  * Docker image.
+
+After downloading the binary, proceed to the corresponding section below.
+
+NOTE: Currently, newer versions of Memgraph are not backward compatible with
+older versions. This is mainly noticeable by unsupported loading of storage
+snapshots between different versions.
+
+#### Docker Installation
+
+Before proceeding with the installation, please install the Docker engine on
+the system. Instructions on how to install Docker can be found on the
+[official Docker website](https://docs.docker.com/engine/installation).
+Memgraph Docker image was built with Docker version `1.12` and should be
+compatible with all later versions.
+
+After installing and running Docker, download the Memgraph Docker image and
+import it with the following command.
+
+```bash
+docker load -i /path/to/memgraph-<version>-docker.tar.gz
+```
+
+Memgraph is then started with another docker command.
+
+```bash
+docker run -p 7687:7687 \
+  -v mg_lib:/var/lib/memgraph -v mg_log:/var/log/memgraph -v mg_etc:/etc/memgraph \
+  memgraph
+```
+
+On success, expect to see output similar to the following.
+
+```bash
+Starting 8 workers
+Server is fully armed and operational
+Listening on 0.0.0.0 at 7687
+```
+
+Memgraph is now ready to process queries, you may now proceed to
+[querying](#querying). To stop Memgraph, press `Ctrl-c`.
+
+Memgraph configuration is available in Docker's named volume `mg_etc`. On
+Linux systems it should be in
+`/var/lib/docker/volumes/mg_etc/_data/memgraph.conf`. After changing the
+configuration, Memgraph needs to be restarted.
+
+##### Note about named volumes
+
+In case named volumes are reused between different versions of Memgraph, a user
+has to be careful because Docker will overwrite a folder within the container
+with existing data from the host machine. In the case where a new file is
+introduced, or two versions of Memgraph are not compatible, the new feature
+won't work or Memgraph won't be able to work correctly. The easiest way to
+solve the issue is to use another named volume or to remove existing named
+volume from the host with the following command.
+
+```bash
+docker volume rm <volume_name>
+```
+
+Named Docker volumes used in this documentation are: `mg_etc`, `mg_log` and
+`mg_lib`. E.g. to avoid any configuration issues between different Memgraph
+versions, `docker volume rm mg_etc` can be executed before running a new
+container.
+
+Another valid option is to try to migrate your existing volume to a
+newer version of Memgraph. In case of any issues, send an email to
+`tech@memgraph.com`.
+
+##### Note for OS X/macOS Users
+
+Although unlikely, some OS X/macOS users might experience minor difficulties
+after following the Docker installation instructions. Instead of running on
+`localhost`, a Docker container for Memgraph might be running on a custom IP
+address. Fortunately, that IP address can be found using the following
+algorithm:
+
+1) Find out the container ID of the Memgraph container
+
+By issuing the command `docker ps` the user should get an output similar to the
+following:
+
+```bash
+CONTAINER ID        IMAGE               COMMAND                  CREATED        ...
+9397623cd87e        memgraph            "/usr/lib/memgraph/m…"   2 seconds ago  ...
+```
+
+At this point, it is important to remember the container ID of the Memgraph
+image.  In our case, that is `9397623cd87e`.
+
+2) Use the container ID to retrieve an IP of the container
+
+```bash
+docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' 9397623cd87e
+```
+
+The command above should yield the sought IP. If that IP does not correspond to
+`localhost`, it should be used instead of `localhost` when firing up the
+`neo4j-client` in the [querying](#querying) section.
+
+#### Debian Package Installation
+
+After downloading Memgraph as a Debian package, install it by running the
+following.
+
+```bash
+dpkg -i /path/to/memgraph_<version>.deb
+```
+
+If the installation was successful, Memgraph should already be running. To
+make sure that is true, start it explicitly with the command:
+
+```bash
+systemctl start memgraph
+```
+
+To verify that Memgraph is running, run the following command.
+
+```bash
+journalctl --unit memgraph
+```
+
+It is expected to see something like the following output.
+
+```bash
+Nov 23 13:40:13 hostname memgraph[14654]: Starting 8 BoltS workers
+Nov 23 13:40:13 hostname memgraph[14654]: BoltS server is fully armed and operational
+Nov 23 13:40:13 hostname memgraph[14654]: BoltS listening on 0.0.0.0 at 7687
+```
+
+Memgraph is now ready to process queries, you may now proceed to
+[querying](#querying). To shutdown Memgraph server, issue the following
+command.
+
+```bash
+systemctl stop memgraph
+```
+
+Memgraph configuration is available in `/etc/memgraph/memgraph.conf`. After
+changing the configuration, Memgraph needs to be restarted.
+
+#### RPM Package Installation
+
+If you downloaded the RPM package of Memgraph, you can install it by running
+the following command.
+
+```bash
+rpm -U /path/to/memgraph-<version>.rpm
+```
+
+After the successful installation, Memgraph can be started as a service. To do
+so, type the following command.
+
+```bash
+systemctl start memgraph
+```
+
+To verify that Memgraph is running, run the following command.
+
+```bash
+journalctl --unit memgraph
+```
+
+It is expected to see something like the following output.
+
+```bash
+Nov 23 13:40:13 hostname memgraph[14654]: Starting 8 BoltS workers
+Nov 23 13:40:13 hostname memgraph[14654]: BoltS server is fully armed and operational
+Nov 23 13:40:13 hostname memgraph[14654]: BoltS listening on 0.0.0.0 at 7687
+```
+
+Memgraph is now ready to process queries, you may now proceed to
+[querying](#querying). To shutdown Memgraph server, issue the following
+command.
+
+```bash
+systemctl stop memgraph
+```
+
+Memgraph configuration is available in `/etc/memgraph/memgraph.conf`. After
+changing the configuration, Memgraph needs to be restarted.
+
+### Querying
+
+Memgraph supports the openCypher query language which has been developed by
+[Neo4j](http://neo4j.com). The language is currently going through a
+vendor-independent standardization process. It's a declarative language
+developed specifically for interaction with graph databases.
+
+The easiest way to execute openCypher queries against Memgraph, is using
+Neo4j's command-line tool. The command-line `neo4j-client` can be installed as
+described [on the official website](https://neo4j-client.net).
+
+After installing `neo4j-client`, connect to the running Memgraph instance by
+issuing the following shell command.
+
+```bash
+neo4j-client -u "" -p ""  localhost 7687
+```
+
+After the client has started it should present a command prompt similar to:
+
+```bash
+neo4j-client 2.1.3
+Enter `:help` for usage hints.
+Connected to 'neo4j://@localhost:7687'
+neo4j>
+```
+
+At this point it is possible to execute openCypher queries on Memgraph. Each
+query needs to end with the `;` (*semicolon*) character. For example:
+
+```opencypher
+CREATE (u:User {name: "Alice"})-[:Likes]->(m:Software {name: "Memgraph"});
+```
+
+The above will create 2 nodes in the database, one labeled "User" with name
+"Alice" and the other labeled "Software" with name "Memgraph". It will also
+create a relationship that "Alice" *likes* "Memgraph".
+
+To find created nodes and relationships, execute the following query:
+
+```opencypher
+MATCH (u:User)-[r]->(x) RETURN u, r, x;
+```
+
+#### Supported Languages
+
+If users wish to query Memgraph programmatically, they can do so using the
+[Bolt protocol](https://boltprotocol.org). Bolt was designed for efficient
+communication with graph databases and Memgraph supports
+[Version 1](https://boltprotocol.org/v1) of the protocol. Bolt protocol drivers
+for some popular programming languages are listed below:
+
+  * [Java](https://github.com/neo4j/neo4j-java-driver)
+  * [Python](https://github.com/neo4j/neo4j-python-driver)
+  * [JavaScript](https://github.com/neo4j/neo4j-javascript-driver)
+  * [C#](https://github.com/neo4j/neo4j-dotnet-driver)
+  * [Ruby](https://github.com/neo4jrb/neo4j)
+  * [Haskell](https://github.com/zmactep/hasbolt)
+  * [PHP](https://github.com/graphaware/neo4j-bolt-php)
+
+We have included some basic usage examples for some of the supported languages
+in the [Drivers](drivers.md) section.
+
+### Telemetry
+
+Telemetry is an automated process by which some useful data is collected at
+a remote point. At Memgraph, we use telemetry for the sole purpose of improving
+our product, thereby collecting some data about the machine that executes the
+database (CPU, memory, OS and kernel information) as well as some data about the
+database runtime (CPU usage, memory usage, vertices and edges count).
+
+Here at Memgraph, we deeply care about the privacy of our users and do not
+collect any sensitive information. If users wish to disable Memgraph's telemetry
+features, they can easily do so by either altering the line in
+`/etc/memgraph/memgraph.conf` that enables telemetry (`--telemetry-enabled=true`)
+into `--telemetry-enabled=false`, or by including the `--telemetry-enabled=false`
+as a command-line argument when running the executable.
+
+### Where to Next
+
+To learn more about the openCypher language, visit [openCypher Query
+Language](open-cypher.md) chapter in this document. For real-world examples
+of how to use Memgraph visit [Examples](examples.md) chapter. Details on
+what can be stored in Memgraph are in [Data Storage](storage.md) chapter.
+
+We *welcome and encourage* your feedback!
+

docs/user_technical/run

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+working_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+# curl and php are required
+if [ "$( which curl )" == "" ] || [ "$( which php )" == "" ]; then
+    echo "curl and php are required!"
+    exit 1
+fi
+
+cd ${working_dir}
+generator="couscous.phar"
+
+# download the generator if it's not already downloaded
+if [ ! -f ${generator} ]; then
+    curl -OS http://couscous.io/${generator}
+fi
+
+# run the preview
+php ${generator} preview

docs/user_technical/storage.md

@@ -0,0 +1,105 @@
+## Durability and Data Recovery
+
+*Memgraph* uses two mechanisms to ensure the durability of the stored data:
+
+  * write-ahead logging (WAL) and
+  * taking periodic snapshots.
+
+Write-ahead logging works by logging all database modifications to a file.
+This ensures that all operations are done atomically and provides a trace of
+steps needed to reconstruct the database state.
+
+Snapshots are taken periodically during the entire runtime of *Memgraph*. When
+a snapshot is triggered, the whole data storage is written to disk. The
+snapshot file provides a quicker way to restore the database state.
+
+Database recovery is done on startup from the most recently found snapshot
+file. Since the snapshot may be older than the most recent update logged in
+the WAL file, the recovery process will apply the remaining state changes
+found in the said WAL file.
+
+NOTE: Snapshot and WAL files are not (currently) compatible between *Memgraph*
+versions.
+
+Behaviour of the above mechanisms can be tweaked in the configuration file,
+usually found in `/etc/memgraph/memgraph.conf`.
+
+In addition to the above mentioned data durability and recovery, a
+snapshot file may be generated using *Memgraph's* import tools. For more
+information, take a look at [Import Tools](import-tools.md) chapter.
+
+## Storable Data Types
+
+Since *Memgraph* is a *graph* database management system, data is stored in
+the form of graph elements: nodes and edges. Each graph element can also
+contain various types of data. This chapter describes which data types are
+supported in *Memgraph*.
+
+### Node Labels & Edge Types
+
+Each node can have any number of labels. A label is a text value, which can be
+used to *label* or group nodes according to users' desires. A user can change
+labels at any time. Similarly to labels, each edge can have a type,
+represented as text. Unlike nodes, which can have multiple labels or none at
+all, edges *must* have exactly one edge type. Another difference to labels, is
+that the edge types are set upon creation and never modified again.
+
+### Properties
+
+Nodes and edges can store various properties. These are like mappings or
+tables containing property names and their accompanying values. Property names
+are represented as text, while values can be of different types. Each property
+name can store a single value, it is not possible to have multiple properties
+with the same name on a single graph element. Naturally, the same property
+names can be found across multiple graph elements. Also, there are no
+restrictions on the number of properties that can be stored in a single graph
+element. The only restriction is that the values must be of the supported
+types. Following is a table of supported data types.
+
+ Type      | Description
+-----------|------------
+ `Null`    | Denotes that the property has no value. This is the same as if the property does not exist.
+ `String`  | A character string, i.e. text.
+ `Boolean` | A boolean value, either `true` or `false`.
+ `Integer` | An integer number.
+ `Float`   | A floating-point number, i.e. a real number.
+ `List`    | A list containing any number of property values of any supported type. It can be used to store multiple values under a single property name.
+ `Map`     | A mapping of string keys to values of any supported type.
+
+ Note that even though it's possible to store `List` and `Map` property values, it is not possible to modify them. It is however possible to replace them completely. So, the following queries are legal:
+
+```opencypher
+CREATE (:Node {property: [1, 2, 3]})
+CREATE (:Node {property: {key: "value"}})
+```
+
+However, these queries are not:
+
+```opencypher
+MATCH (n:Node) SET n.property[0] = 0
+MATCH (n:Node) SET n.property.key = "other value"
+```
+
+### Cold data on disk
+
+Although *Memgraph* is an in-memory database by default, it offers an option
+to store a certain amount of data on disk. More precisely, the user can pass
+a list of properties they wish to keep stored on disk via the command line.
+In certain cases, this might result in a significant performance boost due to
+reduced memory usage. It is recommended to use this feature on large,
+cold properties, i.e. properties that are rarely accessed.
+
+For example, a user of a library database might identify author biographies
+and book summaries as cold properties. In that case, the user should run
+*Memgraph* as follows:
+
+```bash
+/usr/lib/memgraph/memgraph --properties-on-disk biography,summary
+```
+
+Note that the usage of *Memgraph* has not changed, i.e. durability and
+data recovery mechanisms are still in place and the query language remains
+the same. It is also important to note that the user cannot change the storage
+location of a property while *Memgraph* is running. Naturally, the user can
+reload their database from snapshot, provide a different list of properties on
+disk and rest assured that only those properties will be stored on disk.

docs/user_technical/upcoming-features.md

@@ -0,0 +1,61 @@
+## Upcoming Features
+
+This chapter describes some of the planned features, that we at Memgraph are
+working on.
+
+### Performance Improvements
+
+Excellent database performance is one of Memgraph's long-standing goals. We
+will be continually working on improving the performance. This includes:
+
+  * query compilation;
+  * query execution;
+  * core engine performance;
+  * algorithmic improvements (i.e. bidirectional breadth-first search);
+  * memory usage and
+  * other improvements.
+
+### Label-Property Index Usage Improvements
+
+Currently, indexing combinations of labels and properties can be created, but
+cannot be deleted. We plan to add a new query language construct which will
+allow deletion of created indices.
+
+### Improving openCypher Support
+
+Although we have implemented the most common features of the openCypher query
+language, there are other useful features we are still working on.
+
+#### Functions
+
+Memgraph's openCypher implementation supports the most useful functions, but
+there are more which openCypher provides. Some are related to not yet
+implemented features like paths, while some may use the features Memgraph
+already supports. Out of the remaining functions, some are more useful than
+others and as such they will be supported sooner.
+
+#### List Comprehensions
+
+List comprehensions are similar to the supported `collect` function, which
+generates a list out of multiple values. But unlike `collect`, list
+comprehensions offer a powerful mechanism for filtering or otherwise
+manipulating values which are collected into a list.
+
+For example, getting numbers between 0 and 10 and squaring them:
+
+```opencypher
+RETURN [x IN range(0, 10) | x^2] AS squares
+```
+
+Another example, to collect `:Person` nodes with `age` less than 42, without
+list comprehensions can be achieved with:
+
+```opencypher
+MATCH (n :Person) WHERE n.age < 42 RETURN collect(n)
+```
+
+Using list comprehensions, the same can be done with the query:
+
+```opencypher
+MATCH (n :Person) RETURN [n IN collect(n) WHERE n.age < 42]
+```

environment/.gitignore

@@ -1,2 +0,0 @@
-archives
-build

environment/README.md

@@ -1,4 +0,0 @@
-# Memgraph Build and Run Environments
-
-Please continue in
-[Notion](https://www.notion.so/memgraph/Tools-05e0baafb78a49b386e0063b4833d23d).

environment/os/.gitignore

@@ -1,3 +0,0 @@
-*.deb
-*.rpm
-*.tar.gz

environment/os/centos-7.sh

@@ -1,134 +0,0 @@
-#!/bin/bash
-
-set -Eeuo pipefail
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-source "$DIR/../util.sh"
-
-TOOLCHAIN_BUILD_DEPS=(
-    coreutils gcc gcc-c++ make # generic build tools
-    wget # used for archive download
-    gnupg2 # used for archive signature verification
-    tar gzip bzip2 xz unzip # used for archive unpacking
-    zlib-devel # zlib library used for all builds
-    expat-devel libipt-devel libbabeltrace-devel xz-devel python3-devel # gdb
-    texinfo # gdb
-    libcurl-devel # cmake
-    readline-devel # cmake and llvm
-    libffi-devel libxml2-devel perl-Digest-MD5 # llvm
-    libedit-devel pcre-devel automake bison # swig
-)
-
-TOOLCHAIN_RUN_DEPS=(
-    make # generic build tools
-    tar gzip bzip2 xz # used for archive unpacking
-    zlib # zlib library used for all builds
-    expat libipt libbabeltrace xz-libs python3 # for gdb
-    readline # for cmake and llvm
-    libffi libxml2 # for llvm
-)
-
-MEMGRAPH_BUILD_DEPS=(
-    git # source code control
-    make pkgconfig # build system
-    curl wget # for downloading libs
-    libuuid-devel java-11-openjdk # required by antlr
-    readline-devel # for memgraph console
-    python3-devel # for query modules
-    openssl-devel
-    libseccomp-devel
-    python3 python-virtualenv python3-pip nmap-ncat # for qa, macro_benchmark and stress tests
-    #
-    # IMPORTANT: python3-yaml does NOT exist on CentOS
-    # Install it using `pip3 install PyYAML`
-    #
-    PyYAML # Package name here does not correspond to the yum package!
-    libcurl-devel # mg-requests
-    sbcl # for custom Lisp C++ preprocessing
-    rpm-build rpmlint # for RPM package building
-    doxygen graphviz # source documentation generators
-    which mono-complete dotnet-sdk-3.1 golang nodejs zip unzip java-11-openjdk-devel # for driver tests
-    autoconf # for jemalloc code generation
-)
-
-list() {
-    echo "$1"
-}
-
-check() {
-    local missing=""
-    for pkg in $1; do
-        if [ "$pkg" == git ]; then
-            if ! which "git" >/dev/null; then
-                missing="git $missing"
-            fi
-            continue
-        fi
-        if [ "$pkg" == "PyYAML" ]; then
-            if ! python3 -c "import yaml" >/dev/null 2>/dev/null; then
-                missing="$pkg $missing"
-            fi
-            continue
-        fi
-        if ! yum list installed "$pkg" >/dev/null 2>/dev/null; then
-            missing="$pkg $missing"
-        fi
-    done
-    if [ "$missing" != "" ]; then
-        echo "MISSING PACKAGES: $missing"
-        exit 1
-    fi
-}
-
-install() {
-    cd "$DIR"
-    if [ "$EUID" -ne 0 ]; then
-        echo "Please run as root."
-        exit 1
-    fi
-    # If GitHub Actions runner is installed, append LANG to the environment.
-    # Python related tests doesn't work the LANG export.
-    if [ -d "/home/gh/actions-runner" ]; then
-        echo "LANG=en_US.utf8" >> /home/gh/actions-runner/.env
-    else
-        echo "NOTE: export LANG=en_US.utf8"
-    fi
-    yum install -y epel-release
-    yum update -y
-    yum install -y wget git python3 python3-pip
-    for pkg in $1; do
-        if [ "$pkg" == libipt ]; then
-            if ! yum list installed libipt >/dev/null 2>/dev/null; then
-                yum install -y http://repo.okay.com.mx/centos/8/x86_64/release/libipt-1.6.1-8.el8.x86_64.rpm
-            fi
-            continue
-        fi
-        if [ "$pkg" == libipt-devel ]; then
-            if ! yum list installed libipt-devel >/dev/null 2>/dev/null; then
-                yum install -y http://repo.okay.com.mx/centos/8/x86_64/release/libipt-devel-1.6.1-8.el8.x86_64.rpm
-            fi
-            continue
-        fi
-        if [ "$pkg" == dotnet-sdk-3.1 ]; then
-            if ! yum list installed dotnet-sdk-3.1 >/dev/null 2>/dev/null; then
-                wget -nv https://packages.microsoft.com/config/centos/7/packages-microsoft-prod.rpm -O packages-microsoft-prod.rpm
-                rpm -Uvh https://packages.microsoft.com/config/centos/7/packages-microsoft-prod.rpm
-                yum update -y
-                yum install -y dotnet-sdk-3.1
-            fi
-            continue
-        fi
-        if [ "$pkg" == PyYAML ]; then
-            if [ -z ${SUDO_USER+x} ]; then # Running as root (e.g. Docker).
-                pip3 install --user PyYAML
-            else # Running using sudo.
-                sudo -H -u "$SUDO_USER" bash -c "pip3 install --user PyYAML"
-            fi
-            continue
-        fi
-        yum install -y "$pkg"
-    done
-}
-
-deps=$2"[*]"
-"$1" "${!deps}"

environment/os/centos-8.sh

@@ -1,152 +0,0 @@
-#!/bin/bash
-
-set -Eeuo pipefail
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-source "$DIR/../util.sh"
-
-TOOLCHAIN_BUILD_DEPS=(
-    coreutils gcc gcc-c++ make # generic build tools
-    wget # used for archive download
-    gnupg2 # used for archive signature verification
-    tar gzip bzip2 xz unzip # used for archive unpacking
-    zlib-devel # zlib library used for all builds
-    expat-devel libipt-devel libbabeltrace-devel xz-devel python36-devel texinfo # for gdb
-    libcurl-devel # for cmake
-    readline-devel # for cmake and llvm
-    libffi-devel libxml2-devel # for llvm
-    libedit-devel pcre-devel automake bison # for swig
-)
-
-TOOLCHAIN_RUN_DEPS=(
-    make # generic build tools
-    tar gzip bzip2 xz # used for archive unpacking
-    zlib # zlib library used for all builds
-    expat libipt libbabeltrace xz-libs python36 # for gdb
-    readline # for cmake and llvm
-    libffi libxml2 # for llvm
-)
-
-MEMGRAPH_BUILD_DEPS=(
-    git # source code control
-    make pkgconf-pkg-config # build system
-    curl wget # for downloading libs
-    libuuid-devel java-11-openjdk # required by antlr
-    readline-devel # for memgraph console
-    python36-devel # for query modules
-    openssl-devel
-    libseccomp-devel
-    python36 python3-virtualenv python3-pip nmap-ncat # for qa, macro_benchmark and stress tests
-    #
-    # IMPORTANT: python3-yaml does NOT exist on CentOS
-    # Install it manually using `pip3 install PyYAML`
-    #
-    PyYAML # Package name here does not correspond to the yum package!
-    libcurl-devel # mg-requests
-    rpm-build rpmlint # for RPM package building
-    doxygen graphviz # source documentation generators
-    which mono-complete dotnet-sdk-3.1 nodejs golang zip unzip java-11-openjdk-devel # for driver tests
-    sbcl # for custom Lisp C++ preprocessing
-    autoconf # for jemalloc code generation
-)
-
-list() {
-    echo "$1"
-}
-
-check() {
-    local missing=""
-    for pkg in $1; do
-        if [ "$pkg" == "PyYAML" ]; then
-            if ! python3 -c "import yaml" >/dev/null 2>/dev/null; then
-                missing="$pkg $missing"
-            fi
-            continue
-        fi
-        if ! yum list installed "$pkg" >/dev/null 2>/dev/null; then
-            missing="$pkg $missing"
-        fi
-    done
-    if [ "$missing" != "" ]; then
-        echo "MISSING PACKAGES: $missing"
-        exit 1
-    fi
-}
-
-install() {
-    cd "$DIR"
-    if [ "$EUID" -ne 0 ]; then
-        echo "Please run as root."
-        exit 1
-    fi
-    # If GitHub Actions runner is installed, append LANG to the environment.
-    # Python related tests doesn't work the LANG export.
-    if [ -d "/home/gh/actions-runner" ]; then
-        echo "LANG=en_US.utf8" >> /home/gh/actions-runner/.env
-    else
-        echo "NOTE: export LANG=en_US.utf8"
-    fi
-    dnf install -y epel-release
-    dnf install -y 'dnf-command(config-manager)'
-    dnf config-manager --set-enabled powertools # Required to install texinfo.
-    dnf update -y
-    dnf install -y wget git python36 python3-pip
-    for pkg in $1; do
-        if [ "$pkg" == libipt ]; then
-            if ! dnf list installed libipt >/dev/null 2>/dev/null; then
-                dnf install -y http://repo.okay.com.mx/centos/8/x86_64/release/libipt-1.6.1-8.el8.x86_64.rpm
-            fi
-            continue
-        fi
-        if [ "$pkg" == libipt-devel ]; then
-            if ! yum list installed libipt-devel >/dev/null 2>/dev/null; then
-                dnf install -y http://repo.okay.com.mx/centos/8/x86_64/release/libipt-devel-1.6.1-8.el8.x86_64.rpm
-            fi
-            continue
-        fi
-        # Install GDB dependencies not present in the standard repos.
-        # https://bugs.centos.org/view.php?id=17068
-        # https://centos.pkgs.org
-	    # Since 2020, there is Babeltrace2 (https://babeltrace.org). Not used
-        # within GDB yet (an assumption).
-        if [ "$pkg" == libbabeltrace-devel ]; then
-            if ! dnf list installed libbabeltrace-devel >/dev/null 2>/dev/null; then
-                dnf install -y http://repo.okay.com.mx/centos/8/x86_64/release/libbabeltrace-devel-1.5.4-2.el8.x86_64.rpm
-            fi
-            continue
-        fi
-        if [ "$pkg" == sbcl ]; then
-            if ! dnf list installed cl-asdf >/dev/null 2>/dev/null; then
-                dnf install -y 	https://pkgs.dyn.su/el8/base/x86_64/cl-asdf-20101028-18.el8.noarch.rpm
-            fi
-            if ! dnf list installed common-lisp-controller >/dev/null 2>/dev/null; then
-                dnf install -y https://pkgs.dyn.su/el8/base/x86_64/common-lisp-controller-7.4-20.el8.noarch.rpm
-            fi
-            if ! dnf list installed sbcl >/dev/null 2>/dev/null; then
-                dnf install -y https://pkgs.dyn.su/el8/base/x86_64/sbcl-2.0.1-4.el8.x86_64.rpm
-            fi
-            continue
-        fi
-        if [ "$pkg" == dotnet-sdk-3.1 ]; then
-            if ! dnf list installed dotnet-sdk-3.1 >/dev/null 2>/dev/null; then
-                wget -nv https://packages.microsoft.com/config/centos/8/packages-microsoft-prod.rpm -O packages-microsoft-prod.rpm
-                rpm -Uvh https://packages.microsoft.com/config/centos/8/packages-microsoft-prod.rpm
-                dnf update -y
-                dnf install -y dotnet-sdk-3.1
-            fi
-            continue
-        fi
-        if [ "$pkg" == PyYAML ]; then
-            if [ -z ${SUDO_USER+x} ]; then # Running as root (e.g. Docker).
-                pip3 install --user PyYAML
-            else # Running using sudo.
-                sudo -H -u "$SUDO_USER" bash -c "pip3 install --user PyYAML"
-            fi
-            continue
-        fi
-        dnf install -y "$pkg"
-    done
-}
-
-deps=$2"[*]"
-"$1" "${!deps}"

environment/os/debian-10.sh

@@ -1,93 +0,0 @@
-#!/bin/bash
-
-set -Eeuo pipefail
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-source "$DIR/../util.sh"
-
-TOOLCHAIN_BUILD_DEPS=(
-    coreutils gcc g++ build-essential make # generic build tools
-    wget # used for archive download
-    gnupg # used for archive signature verification
-    tar gzip bzip2 xz-utils unzip # used for archive unpacking
-    zlib1g-dev # zlib library used for all builds
-    libexpat1-dev libipt-dev libbabeltrace-dev liblzma-dev python3-dev texinfo # for gdb
-    libcurl4-openssl-dev # for cmake
-    libreadline-dev # for cmake and llvm
-    libffi-dev libxml2-dev # for llvm
-    libedit-dev libpcre3-dev automake bison # for swig
-)
-
-TOOLCHAIN_RUN_DEPS=(
-    make # generic build tools
-    tar gzip bzip2 xz-utils # used for archive unpacking
-    zlib1g # zlib library used for all builds
-    libexpat1 libipt2 libbabeltrace1 liblzma5 python3 # for gdb
-    libcurl4 # for cmake
-    libreadline7 # for cmake and llvm
-    libffi6 libxml2 # for llvm
-)
-
-MEMGRAPH_BUILD_DEPS=(
-    git # source code control
-    make pkg-config # build system
-    curl wget # for downloading libs
-    uuid-dev default-jre-headless # required by antlr
-    libreadline-dev # for memgraph console
-    libpython3-dev python3-dev # for query modules
-    libssl-dev
-    libseccomp-dev
-    netcat # tests are using nc to wait for memgraph
-    python3 virtualenv python3-virtualenv python3-pip # for qa, macro_benchmark and stress tests
-    python3-yaml # for the configuration generator
-    libcurl4-openssl-dev # mg-requests
-    sbcl # for custom Lisp C++ preprocessing
-    doxygen graphviz # source documentation generators
-    mono-runtime mono-mcs zip unzip default-jdk-headless # for driver tests
-    dotnet-sdk-3.1 golang nodejs npm
-    autoconf # for jemalloc code generation
-)
-
-list() {
-    echo "$1"
-}
-
-check() {
-    check_all_dpkg "$1"
-}
-
-install() {
-    cat >/etc/apt/sources.list <<EOF
-deb http://deb.debian.org/debian/ buster main non-free contrib
-deb-src http://deb.debian.org/debian/ buster main non-free contrib
-deb http://deb.debian.org/debian/ buster-updates main contrib non-free
-deb-src http://deb.debian.org/debian/ buster-updates main contrib non-free
-deb http://security.debian.org/debian-security buster/updates main contrib non-free
-deb-src http://security.debian.org/debian-security buster/updates main contrib non-free
-EOF
-    cd "$DIR"
-    apt update
-    # If GitHub Actions runner is installed, append LANG to the environment.
-    # Python related tests doesn't work the LANG export.
-    if [ -d "/home/gh/actions-runner" ]; then
-        echo "LANG=en_US.utf8" >> /home/gh/actions-runner/.env
-    else
-        echo "NOTE: export LANG=en_US.utf8"
-    fi
-    apt install -y wget
-    for pkg in $1; do
-        if [ "$pkg" == dotnet-sdk-3.1 ]; then
-            if ! dpkg -s "$pkg" 2>/dev/null >/dev/null; then
-                wget -nv https://packages.microsoft.com/config/debian/10/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
-                dpkg -i packages-microsoft-prod.deb
-                apt-get update
-                apt-get install -y apt-transport-https dotnet-sdk-3.1
-            fi
-            continue
-        fi
-        apt install -y "$pkg"
-    done
-}
-
-deps=$2"[*]"
-"$1" "${!deps}"

environment/os/debian-9.sh

@@ -1,62 +0,0 @@
-#!/bin/bash
-
-set -Eeuo pipefail
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-source "$DIR/../util.sh"
-
-TOOLCHAIN_BUILD_DEPS=(
-    coreutils gcc g++ build-essential make # generic build tools
-    wget # used for archive download
-    gnupg # used for archive signature verification
-    tar gzip bzip2 xz-utils unzip # used for archive unpacking
-    zlib1g-dev # zlib library used for all builds
-    libexpat1-dev libipt-dev libbabeltrace-dev libbabeltrace-ctf-dev liblzma-dev python3-dev texinfo # for gdb
-    libcurl4-openssl-dev # for cmake
-    libreadline-dev # for cmake and llvm
-    libffi-dev libxml2-dev # for llvm
-    libedit-dev libpcre3-dev automake bison # for swig
-)
-
-TOOLCHAIN_RUN_DEPS=(
-    make # generic build tools
-    tar gzip bzip2 xz-utils # used for archive unpacking
-    zlib1g # zlib library used for all builds
-    libexpat1 libipt1 libbabeltrace1 libbabeltrace-ctf1 liblzma5 python3 # for gdb
-    libcurl3 # for cmake
-    libreadline7 # for cmake and llvm
-    libffi6 libxml2 # for llvm
-)
-
-MEMGRAPH_BUILD_DEPS=(
-    git # source code control
-    make pkg-config # build system
-    curl wget # for downloading libs
-    uuid-dev default-jre-headless # required by antlr
-    libreadline-dev # for memgraph console
-    libpython3-dev python3-dev # for query modules
-    libssl-dev
-    libseccomp-dev
-    python3 python-virtualenv python3-pip # for qa, macro_benchmark and stress tests
-    python3-yaml # for the configuration generator
-    libcurl4-openssl-dev # mg-requests
-    sbcl # for custom Lisp C++ preprocessing
-    doxygen graphviz # source documentation generators
-    mono-runtime mono-mcs nodejs zip unzip default-jdk-headless # for driver tests
-    autoconf # for jemalloc code generation
-)
-
-list() {
-    echo "$1"
-}
-
-check() {
-    check_all_dpkg "$1"
-}
-
-install() {
-    install_all_apt "$1"
-}
-
-deps=$2"[*]"
-"$1" "${!deps}"

environment/os/template.sh

@@ -1,36 +0,0 @@
-#!/bin/bash
-
-set -Eeuo pipefail
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-source "$DIR/../util.sh"
-
-TOOLCHAIN_BUILD_DEPS=(
-    pkg
-)
-
-TOOLCHAIN_RUN_DEPS=(
-    pkg
-)
-
-MEMGRAPH_BUILD_DEPS=(
-    pkg
-)
-
-list() {
-    echo "$1"
-}
-
-check() {
-    echo "TODO: Implement ${FUNCNAME[0]}."
-    exit 1
-}
-
-install() {
-    echo "TODO: Implement ${FUNCNAME[0]}."
-    exit 1
-}
-
-# http://ahmed.amayem.com/bash-indirect-expansion-exploration
-deps=$2"[*]"
-"$1" "${!deps}"

environment/os/ubuntu-18.04.sh

@@ -1,63 +0,0 @@
-#!/bin/bash
-
-set -Eeuo pipefail
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-source "$DIR/../util.sh"
-
-TOOLCHAIN_BUILD_DEPS=(
-    coreutils gcc g++ build-essential make # generic build tools
-    wget # archive download
-    gnupg # archive signature verification
-    tar gzip bzip2 xz-utils unzip # archive unpacking
-    zlib1g-dev # zlib library used for all builds
-    libexpat1-dev libipt-dev libbabeltrace-dev liblzma-dev python3-dev # gdb
-    texinfo # gdb
-    libcurl4-openssl-dev # cmake
-    libreadline-dev # cmake and llvm
-    libffi-dev libxml2-dev # llvm
-    libedit-dev libpcre3-dev automake bison # swig
-)
-
-TOOLCHAIN_RUN_DEPS=(
-    make # generic build tools
-    tar gzip bzip2 xz-utils # used for archive unpacking
-    zlib1g # zlib library used for all builds
-    libexpat1 libipt1 libbabeltrace1 liblzma5 python3 # for gdb
-    libcurl4 # for cmake
-    libreadline7 # for cmake and llvm
-    libffi6 libxml2 # for llvm
-)
-
-MEMGRAPH_BUILD_DEPS=(
-    git # source code control
-    make pkg-config # build system
-    curl wget # downloading libs
-    uuid-dev default-jre-headless # required by antlr
-    libreadline-dev # memgraph console
-    libpython3-dev python3-dev # for query modules
-    libssl-dev
-    libseccomp-dev
-    python3 virtualenv python3-virtualenv python3-pip # qa, macro bench and stress tests
-    python3-yaml # the configuration generator
-    libcurl4-openssl-dev # mg-requests
-    sbcl # custom Lisp C++ preprocessing
-    doxygen graphviz # source documentation generators
-    mono-runtime mono-mcs nodejs zip unzip default-jdk-headless # driver tests
-    autoconf # for jemalloc code generation
-)
-
-list() {
-    echo "$1"
-}
-
-check() {
-    check_all_dpkg "$1"
-}
-
-install() {
-    apt install -y $1
-}
-
-deps=$2"[*]"
-"$1" "${!deps}"

environment/os/ubuntu-20.04.sh

@@ -1,85 +0,0 @@
-#!/bin/bash
-
-set -Eeuo pipefail
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-source "$DIR/../util.sh"
-
-TOOLCHAIN_BUILD_DEPS=(
-    coreutils gcc g++ build-essential make # generic build tools
-    wget # used for archive download
-    gnupg # used for archive signature verification
-    tar gzip bzip2 xz-utils unzip # used for archive unpacking
-    zlib1g-dev # zlib library used for all builds
-    libexpat1-dev libipt-dev libbabeltrace-dev liblzma-dev python3-dev texinfo # for gdb
-    libcurl4-openssl-dev # for cmake
-    libreadline-dev # for cmake and llvm
-    libffi-dev libxml2-dev # for llvm
-    libedit-dev libpcre3-dev automake bison # for swig
-)
-
-TOOLCHAIN_RUN_DEPS=(
-    make # generic build tools
-    tar gzip bzip2 xz-utils # used for archive unpacking
-    zlib1g # zlib library used for all builds
-    libexpat1 libipt2 libbabeltrace1 liblzma5 python3 # for gdb
-    libcurl4 # for cmake
-    libreadline8 # for cmake and llvm
-    libffi7 libxml2 # for llvm
-)
-
-MEMGRAPH_BUILD_DEPS=(
-    git # source code control
-    make pkg-config # build system
-    curl wget # for downloading libs
-    uuid-dev default-jre-headless # required by antlr
-    libreadline-dev # for memgraph console
-    libpython3-dev python3-dev # for query modules
-    libssl-dev
-    libseccomp-dev
-    netcat # tests are using nc to wait for memgraph
-    python3 python3-virtualenv python3-pip # for qa, macro_benchmark and stress tests
-    python3-yaml # for the configuration generator
-    libcurl4-openssl-dev # mg-requests
-    sbcl # for custom Lisp C++ preprocessing
-    doxygen graphviz # source documentation generators
-    mono-runtime mono-mcs zip unzip default-jdk-headless # for driver tests
-    dotnet-sdk-3.1 golang nodejs npm
-    autoconf # for jemalloc code generation
-)
-
-list() {
-    echo "$1"
-}
-
-check() {
-    check_all_dpkg "$1"
-}
-
-install() {
-    cd "$DIR"
-    apt update
-    # If GitHub Actions runner is installed, append LANG to the environment.
-    # Python related tests doesn't work the LANG export.
-    if [ -d "/home/gh/actions-runner" ]; then
-        echo "LANG=en_US.utf8" >> /home/gh/actions-runner/.env
-    else
-        echo "NOTE: export LANG=en_US.utf8"
-    fi
-    apt install -y wget
-    for pkg in $1; do
-        if [ "$pkg" == dotnet-sdk-3.1 ]; then
-            if ! dpkg -s dotnet-sdk-3.1 2>/dev/null >/dev/null; then
-                wget -nv https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
-                dpkg -i packages-microsoft-prod.deb
-                apt-get update
-                apt-get install -y apt-transport-https dotnet-sdk-3.1
-            fi
-            continue
-        fi
-        apt install -y "$pkg"
-    done
-}
-
-deps=$2"[*]"
-"$1" "${!deps}"

environment/toolchain/v1.sh

@@ -1,651 +0,0 @@
-#!/bin/bash -e
-
-# helpers
-pushd () { command pushd "$@" > /dev/null; }
-popd () { command popd "$@" > /dev/null; }
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-CPUS=$( cat /proc/cpuinfo | grep processor | wc -l )
-cd "$DIR"
-
-# toolchain version
-TOOLCHAIN_VERSION=1
-
-# package versions used
-GCC_VERSION=8.3.0
-BINUTILS_VERSION=2.32
-GDB_VERSION=8.2.1
-CMAKE_VERSION=3.14.2
-CPPCHECK_VERSION=1.87
-LLVM_VERSION=8.0.0
-SWIG_VERSION=3.0.12 # used only for LLVM compilation
-
-# check for installed dependencies
-DISTRO="$( egrep '^(VERSION_)?ID=' /etc/os-release | sort | cut -d '=' -f 2- | sed 's/"//g' | paste -s -d '-' )"
-case "$DISTRO" in
-    debian-9)
-        DEPS_MANAGER=apt-get
-        DEPS_COMPILE=(
-            coreutils gcc g++ build-essential make # generic build tools
-            wget # used for archive download
-            gnupg # used for archive signature verification
-            tar gzip bzip2 xz-utils unzip # used for archive unpacking
-            zlib1g-dev # zlib library used for all builds
-            libexpat1-dev libipt-dev libbabeltrace-dev libbabeltrace-ctf-dev liblzma-dev python3-dev texinfo # for gdb
-            libcurl4-openssl-dev # for cmake
-            libreadline-dev # for cmake and llvm
-            libffi-dev libxml2-dev # for llvm
-            libedit-dev libpcre3-dev automake bison # for swig
-        )
-        DEPS_RUN=(
-            make # generic build tools
-            tar gzip bzip2 xz-utils # used for archive unpacking
-            zlib1g # zlib library used for all builds
-            libexpat1 libipt1 libbabeltrace1 libbabeltrace-ctf1 liblzma5 python3 # for gdb
-            libcurl3 # for cmake
-            libreadline7 # for cmake and llvm
-            libffi6 libxml2 # for llvm
-        )
-        ;;
-
-    debian-10)
-        DEPS_MANAGER=apt-get
-        DEPS_COMPILE=(
-            coreutils gcc g++ build-essential make # generic build tools
-            wget # used for archive download
-            gnupg # used for archive signature verification
-            tar gzip bzip2 xz-utils unzip # used for archive unpacking
-            zlib1g-dev # zlib library used for all builds
-            libexpat1-dev libipt-dev libbabeltrace-dev liblzma-dev python3-dev texinfo # for gdb
-            libcurl4-openssl-dev # for cmake
-            libreadline-dev # for cmake and llvm
-            libffi-dev libxml2-dev # for llvm
-            libedit-dev libpcre3-dev automake bison # for swig
-        )
-        DEPS_RUN=(
-            make # generic build tools
-            tar gzip bzip2 xz-utils # used for archive unpacking
-            zlib1g # zlib library used for all builds
-            libexpat1 libipt2 libbabeltrace1 liblzma5 python3 # for gdb
-            libcurl4 # for cmake
-            libreadline7 # for cmake and llvm
-            libffi6 libxml2 # for llvm
-        )
-        ;;
-
-    ubuntu-18.04)
-        DEPS_MANAGER=apt-get
-        DEPS_COMPILE=(
-            coreutils gcc g++ build-essential make # generic build tools
-            wget # used for archive download
-            gnupg # used for archive signature verification
-            tar gzip bzip2 xz-utils unzip # used for archive unpacking
-            zlib1g-dev # zlib library used for all builds
-            libexpat1-dev libipt-dev libbabeltrace-dev liblzma-dev python3-dev texinfo # for gdb
-            libcurl4-openssl-dev # for cmake
-            libreadline-dev # for cmake and llvm
-            libffi-dev libxml2-dev # for llvm
-            libedit-dev libpcre3-dev automake bison # for swig
-        )
-        DEPS_RUN=(
-            make # generic build tools
-            tar gzip bzip2 xz-utils # used for archive unpacking
-            zlib1g # zlib library used for all builds
-            libexpat1 libipt1 libbabeltrace1 liblzma5 python3 # for gdb
-            libcurl4 # for cmake
-            libreadline7 # for cmake and llvm
-            libffi6 libxml2 # for llvm
-        )
-        ;;
-
-    centos-7)
-        DEPS_MANAGER=yum
-        DEPS_COMPILE=(
-            coreutils gcc gcc-c++ make # generic build tools
-            wget # used for archive download
-            gnupg2 # used for archive signature verification
-            tar gzip bzip2 xz unzip # used for archive unpacking
-            zlib-devel # zlib library used for all builds
-            expat-devel libipt-devel libbabeltrace-devel xz-devel python3-devel texinfo # for gdb
-            libcurl-devel # for cmake
-            readline-devel # for cmake and llvm
-            libffi-devel libxml2-devel # for llvm
-            libedit-devel pcre-devel automake bison # for swig
-        )
-        DEPS_RUN=(
-            make # generic build tools
-            tar gzip bzip2 xz # used for archive unpacking
-            zlib # zlib library used for all builds
-            expat libipt libbabeltrace xz-libs python3 # for gdb
-            readline # for cmake and llvm
-            libffi libxml2 # for llvm
-        )
-        ;;
-
-    *)
-        echo "Unknown distribution: $DISTRO!"
-        exit 1
-        ;;
-esac
-find_missing_dependencies () {
-    local message="$1"; shift
-    local missing=""
-    while [ "$1" != "" ]; do
-        if [ "$DEPS_MANAGER" == "apt-get" ]; then
-            if ! dpkg -s $1 >/dev/null 2>/dev/null; then
-                missing="$1 $missing"
-            fi
-        elif [ "$DEPS_MANAGER" == "yum" ]; then
-            if ! yum list installed $1 >/dev/null 2>/dev/null; then
-                missing="$1 $missing"
-            fi
-        else
-            echo "Invalid package manager: $DEPS_MANAGER!"
-            exit 1
-        fi
-        shift
-    done
-    if [ "$missing" != "" ]; then
-        echo "$message: $missing"
-        exit 1
-    fi
-}
-find_missing_dependencies "Missing dependencies" ${DEPS_COMPILE[@]}
-find_missing_dependencies "All dependencies are installed, but the following runtime libraries were not found (they are probably invalid)" ${DEPS_RUN[@]}
-
-# check installation directory
-NAME=toolchain-v$TOOLCHAIN_VERSION
-PREFIX=/opt/$NAME
-mkdir -p $PREFIX >/dev/null 2>/dev/null || true
-if [ ! -d $PREFIX ] || [ ! -w $PREFIX ]; then
-    echo "Please make sure that the directory '$PREFIX' exists and is writable by the current user!"
-    echo
-    echo "If unsure, execute these commands as root:"
-    echo "    mkdir $PREFIX && chown $USER:$USER $PREFIX"
-    echo
-    echo "Press <return> when you have created the directory and granted permissions."
-    # wait for the directory to be created
-    while true; do
-        read
-        if [ ! -d $PREFIX ] || [ ! -w $PREFIX ]; then
-            echo
-            echo "You can't continue before you have created the directory and granted permissions!"
-            echo
-            echo "Press <return> when you have created the directory and granted permissions."
-        else
-            break
-        fi
-    done
-fi
-
-# create archives directory
-mkdir -p archives
-
-# download all archives
-pushd archives
-if [ ! -f gcc-$GCC_VERSION.tar.gz ]; then
-    wget https://ftp.gnu.org/gnu/gcc/gcc-$GCC_VERSION/gcc-$GCC_VERSION.tar.gz
-fi
-if [ ! -f binutils-$BINUTILS_VERSION.tar.gz ]; then
-    wget https://ftp.gnu.org/gnu/binutils/binutils-$BINUTILS_VERSION.tar.gz
-fi
-if [ ! -f gdb-$GDB_VERSION.tar.gz ]; then
-    wget https://ftp.gnu.org/gnu/gdb/gdb-$GDB_VERSION.tar.gz
-fi
-if [ ! -f cmake-$CMAKE_VERSION.tar.gz ]; then
-    wget https://github.com/Kitware/CMake/releases/download/v$CMAKE_VERSION/cmake-$CMAKE_VERSION.tar.gz
-fi
-if [ ! -f swig-$SWIG_VERSION.tar.gz ]; then
-    wget https://github.com/swig/swig/archive/rel-$SWIG_VERSION.tar.gz -O swig-$SWIG_VERSION.tar.gz
-fi
-if [ ! -f cppcheck-$CPPCHECK_VERSION.tar.gz ]; then
-    wget https://github.com/danmar/cppcheck/archive/$CPPCHECK_VERSION.tar.gz -O cppcheck-$CPPCHECK_VERSION.tar.gz
-fi
-if [ ! -f llvm-$LLVM_VERSION.src.tar.xz ]; then
-    wget https://releases.llvm.org/$LLVM_VERSION/llvm-$LLVM_VERSION.src.tar.xz
-    wget https://releases.llvm.org/$LLVM_VERSION/cfe-$LLVM_VERSION.src.tar.xz
-    wget https://releases.llvm.org/$LLVM_VERSION/lld-$LLVM_VERSION.src.tar.xz
-    wget https://releases.llvm.org/$LLVM_VERSION/compiler-rt-$LLVM_VERSION.src.tar.xz
-    wget https://releases.llvm.org/$LLVM_VERSION/clang-tools-extra-$LLVM_VERSION.src.tar.xz
-fi
-if [ ! -f pahole-gdb-master.zip ]; then
-    wget https://github.com/PhilArmstrong/pahole-gdb/archive/master.zip -O pahole-gdb-master.zip
-fi
-
-# verify all archives
-# NOTE: Verification can fail if the archive is signed by another developer. I
-# haven't added commands to download all developer GnuPG keys because the
-# download is very slow. If the verification fails for you, figure out who has
-# signed the archive and download their public key instead.
-GPG="gpg --homedir .gnupg"
-KEYSERVER="hkp://keyserver.ubuntu.com"
-mkdir -p .gnupg
-chmod 700 .gnupg
-# verify gcc
-if [ ! -f gcc-$GCC_VERSION.tar.gz.sig ]; then
-    wget https://ftp.gnu.org/gnu/gcc/gcc-$GCC_VERSION/gcc-$GCC_VERSION.tar.gz.sig
-fi
-# list of valid gcc gnupg keys: https://gcc.gnu.org/mirrors.html
-$GPG --keyserver $KEYSERVER --recv-keys 0xA328C3A2C3C45C06
-$GPG --verify gcc-$GCC_VERSION.tar.gz.sig gcc-$GCC_VERSION.tar.gz
-# verify binutils
-if [ ! -f binutils-$BINUTILS_VERSION.tar.gz.sig ]; then
-    wget https://ftp.gnu.org/gnu/binutils/binutils-$BINUTILS_VERSION.tar.gz.sig
-fi
-$GPG --keyserver $KEYSERVER --recv-keys 0xDD9E3C4F
-$GPG --verify binutils-$BINUTILS_VERSION.tar.gz.sig binutils-$BINUTILS_VERSION.tar.gz
-# verify gdb
-if [ ! -f gdb-$GDB_VERSION.tar.gz.sig ]; then
-    wget https://ftp.gnu.org/gnu/gdb/gdb-$GDB_VERSION.tar.gz.sig
-fi
-$GPG --keyserver $KEYSERVER --recv-keys 0xFF325CF3
-$GPG --verify gdb-$GDB_VERSION.tar.gz.sig gdb-$GDB_VERSION.tar.gz
-# verify cmake
-if [ ! -f cmake-$CMAKE_VERSION-SHA-256.txt ] || [ ! -f cmake-$CMAKE_VERSION-SHA-256.txt.asc ]; then
-    wget https://github.com/Kitware/CMake/releases/download/v$CMAKE_VERSION/cmake-$CMAKE_VERSION-SHA-256.txt
-    wget https://github.com/Kitware/CMake/releases/download/v$CMAKE_VERSION/cmake-$CMAKE_VERSION-SHA-256.txt.asc
-    # Because CentOS 7 doesn't have the `--ignore-missing` flag for `sha256sum`
-    # we filter out the missing files from the sums here manually.
-    cat cmake-$CMAKE_VERSION-SHA-256.txt | grep "cmake-$CMAKE_VERSION.tar.gz" > cmake-$CMAKE_VERSION-SHA-256-filtered.txt
-fi
-$GPG --keyserver $KEYSERVER --recv-keys 0xC6C265324BBEBDC350B513D02D2CEF1034921684
-sha256sum -c cmake-$CMAKE_VERSION-SHA-256-filtered.txt
-$GPG --verify cmake-$CMAKE_VERSION-SHA-256.txt.asc cmake-$CMAKE_VERSION-SHA-256.txt
-# verify llvm, cfe, lld, clang-tools-extra
-if [ ! -f llvm-$LLVM_VERSION.src.tar.xz.sig ]; then
-    wget https://releases.llvm.org/$LLVM_VERSION/llvm-$LLVM_VERSION.src.tar.xz.sig
-    wget https://releases.llvm.org/$LLVM_VERSION/cfe-$LLVM_VERSION.src.tar.xz.sig
-    wget https://releases.llvm.org/$LLVM_VERSION/lld-$LLVM_VERSION.src.tar.xz.sig
-    wget https://releases.llvm.org/$LLVM_VERSION/compiler-rt-$LLVM_VERSION.src.tar.xz.sig
-    wget https://releases.llvm.org/$LLVM_VERSION/clang-tools-extra-$LLVM_VERSION.src.tar.xz.sig
-fi
-# list of valid llvm gnupg keys: https://releases.llvm.org/download.html
-$GPG --keyserver $KEYSERVER --recv-keys 0x345AD05D
-$GPG --verify llvm-$LLVM_VERSION.src.tar.xz.sig llvm-$LLVM_VERSION.src.tar.xz
-$GPG --verify cfe-$LLVM_VERSION.src.tar.xz.sig cfe-$LLVM_VERSION.src.tar.xz
-$GPG --verify lld-$LLVM_VERSION.src.tar.xz.sig lld-$LLVM_VERSION.src.tar.xz
-$GPG --verify compiler-rt-$LLVM_VERSION.src.tar.xz.sig compiler-rt-$LLVM_VERSION.src.tar.xz
-$GPG --verify clang-tools-extra-$LLVM_VERSION.src.tar.xz.sig clang-tools-extra-$LLVM_VERSION.src.tar.xz
-popd
-
-# create build directory
-mkdir -p build
-pushd build
-
-# compile gcc
-if [ ! -f $PREFIX/bin/gcc ]; then
-    if [ -d gcc-$GCC_VERSION ]; then
-        rm -rf gcc-$GCC_VERSION
-    fi
-    tar -xvf ../archives/gcc-$GCC_VERSION.tar.gz
-    pushd gcc-$GCC_VERSION
-    ./contrib/download_prerequisites
-    mkdir build && pushd build
-    # influenced by: https://buildd.debian.org/status/fetch.php?pkg=gcc-8&arch=amd64&ver=8.3.0-6&stamp=1554588545
-    ../configure -v \
-        --build=x86_64-linux-gnu \
-        --host=x86_64-linux-gnu \
-        --target=x86_64-linux-gnu \
-        --prefix=$PREFIX \
-        --disable-multilib \
-        --with-system-zlib \
-        --enable-checking=release \
-        --enable-languages=c,c++,fortran \
-        --enable-gold=yes \
-        --enable-ld=yes \
-        --enable-lto \
-        --enable-bootstrap \
-        --disable-vtable-verify \
-        --disable-werror \
-        --without-included-gettext \
-        --enable-threads=posix \
-        --enable-nls \
-        --enable-clocale=gnu \
-        --enable-libstdcxx-debug \
-        --enable-libstdcxx-time=yes \
-        --enable-gnu-unique-object \
-        --enable-libmpx \
-        --enable-plugin \
-        --enable-default-pie \
-        --with-target-system-zlib \
-        --with-tune=generic \
-        --without-cuda-driver
-        #--program-suffix=$( printf "$GCC_VERSION" | cut -d '.' -f 1,2 ) \
-    make -j$CPUS
-    # make -k check # run test suite
-    make install
-    popd && popd
-fi
-
-# activate toolchain
-export PATH=$PREFIX/bin:$PATH
-export LD_LIBRARY_PATH=$PREFIX/lib64
-
-# compile binutils
-if [ ! -f $PREFIX/bin/ld.gold ]; then
-    if [ -d binutils-$BINUTILS_VERSION ]; then
-        rm -rf binutils-$BINUTILS_VERSION
-    fi
-    tar -xvf ../archives/binutils-$BINUTILS_VERSION.tar.gz
-    pushd binutils-$BINUTILS_VERSION
-    mkdir build && pushd build
-    # influenced by: https://buildd.debian.org/status/fetch.php?pkg=binutils&arch=amd64&ver=2.32-7&stamp=1553247092
-    env \
-        CC=gcc \
-        CXX=g++ \
-        CFLAGS="-g -O2" \
-        CXXFLAGS="-g -O2" \
-        LDFLAGS="" \
-        ../configure \
-            --build=x86_64-linux-gnu \
-            --host=x86_64-linux-gnu \
-            --prefix=$PREFIX \
-            --enable-ld=default \
-            --enable-gold \
-            --enable-lto \
-            --enable-plugins \
-            --enable-shared \
-            --enable-threads \
-            --with-system-zlib \
-            --enable-deterministic-archives \
-            --disable-compressed-debug-sections \
-            --enable-new-dtags \
-            --disable-werror
-    make -j$CPUS
-    # make -k check # run test suite
-    make install
-    popd && popd
-fi
-
-# compile gdb
-if [ ! -f $PREFIX/bin/gdb ]; then
-    if [ -d gdb-$GDB_VERSION ]; then
-        rm -rf gdb-$GDB_VERSION
-    fi
-    tar -xvf ../archives/gdb-$GDB_VERSION.tar.gz
-    pushd gdb-$GDB_VERSION
-    mkdir build && pushd build
-    # https://buildd.debian.org/status/fetch.php?pkg=gdb&arch=amd64&ver=8.2.1-2&stamp=1550831554&raw=0
-    env \
-        CC=gcc \
-        CXX=g++ \
-        CFLAGS="-g -O2 -fstack-protector-strong -Wformat -Werror=format-security" \
-        CXXFLAGS="-g -O2 -fstack-protector-strong -Wformat -Werror=format-security" \
-        CPPFLAGS="-Wdate-time -D_FORTIFY_SOURCE=2 -fPIC" \
-        LDFLAGS="-Wl,-z,relro" \
-        PYTHON="" \
-        ../configure \
-            --build=x86_64-linux-gnu \
-            --host=x86_64-linux-gnu \
-            --prefix=$PREFIX \
-            --disable-maintainer-mode \
-            --disable-dependency-tracking \
-            --disable-silent-rules \
-            --disable-gdbtk \
-            --disable-shared \
-            --without-guile \
-            --with-system-gdbinit=$PREFIX/etc/gdb/gdbinit \
-            --with-system-readline \
-            --with-expat \
-            --with-system-zlib \
-            --with-lzma \
-            --with-babeltrace \
-            --with-intel-pt \
-            --enable-tui \
-            --with-python=python3
-    make -j$CPUS
-    make install
-    popd && popd
-fi
-
-# install pahole
-if [ ! -d $PREFIX/share/pahole-gdb ]; then
-    unzip ../archives/pahole-gdb-master.zip
-    mv pahole-gdb-master $PREFIX/share/pahole-gdb
-fi
-
-# setup system gdbinit
-if [ ! -f $PREFIX/etc/gdb/gdbinit ]; then
-    mkdir -p $PREFIX/etc/gdb
-    cat >$PREFIX/etc/gdb/gdbinit <<EOF
-# improve formatting
-set print pretty on
-set print object on
-set print static-members on
-set print vtbl on
-set print demangle on
-set demangle-style gnu-v3
-set print sevenbit-strings off
-
-# load libstdc++ pretty printers
-add-auto-load-scripts-directory $PREFIX/lib64
-add-auto-load-safe-path $PREFIX
-
-# load pahole
-python
-sys.path.insert(0, "$PREFIX/share/pahole-gdb")
-import offsets
-import pahole
-end
-EOF
-fi
-
-# compile cmake
-if [ ! -f $PREFIX/bin/cmake ]; then
-    if [ -d cmake-$CMAKE_VERSION ]; then
-        rm -rf cmake-$CMAKE_VERSION
-    fi
-    tar -xvf ../archives/cmake-$CMAKE_VERSION.tar.gz
-    pushd cmake-$CMAKE_VERSION
-    # influenced by: https://buildd.debian.org/status/fetch.php?pkg=cmake&arch=amd64&ver=3.13.4-1&stamp=1549799837
-    echo 'set(CMAKE_SKIP_RPATH ON CACHE BOOL "Skip rpath" FORCE)' >> build-flags.cmake
-    echo 'set(CMAKE_USE_RELATIVE_PATHS ON CACHE BOOL "Use relative paths" FORCE)' >> build-flags.cmake
-    echo 'set(CMAKE_C_FLAGS "-g -O2 -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2" CACHE STRING "C flags" FORCE)' >> build-flags.cmake
-    echo 'set(CMAKE_CXX_FLAGS "-g -O2 -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2" CACHE STRING "C++ flags" FORCE)' >> build-flags.cmake
-    echo 'set(CMAKE_SKIP_BOOTSTRAP_TEST ON CACHE BOOL "Skip BootstrapTest" FORCE)' >> build-flags.cmake
-    echo 'set(BUILD_CursesDialog ON CACHE BOOL "Build curses GUI" FORCE)' >> build-flags.cmake
-    mkdir build && pushd build
-    ../bootstrap \
-        --prefix=$PREFIX \
-        --init=../build-flags.cmake \
-        --parallel=$CPUS \
-        --system-curl
-    make -j$CPUS
-    # make test # run test suite
-    make install
-    popd && popd
-fi
-
-# compile cppcheck
-if [ ! -f $PREFIX/bin/cppcheck ]; then
-    if [ -d cppcheck-$CPPCHECK_VERSION ]; then
-        rm -rf cppcheck-$CPPCHECK_VERSION
-    fi
-    tar -xvf ../archives/cppcheck-$CPPCHECK_VERSION.tar.gz
-    pushd cppcheck-$CPPCHECK_VERSION
-    env \
-        CC=gcc \
-        CXX=g++ \
-        PREFIX=$PREFIX \
-        CFGDIR=$PREFIX/share/cppcheck/cfg \
-            make -j$CPUS
-    env \
-        CC=gcc \
-        CXX=g++ \
-        PREFIX=$PREFIX \
-        CFGDIR=$PREFIX/share/cppcheck/cfg \
-            make install
-    popd
-fi
-
-# compile swig
-if [ ! -d swig-$SWIG_VERSION/install ]; then
-    if [ -d swig-$SWIG_VERSION ]; then
-        rm -rf swig-$SWIG_VERSION
-    fi
-    tar -xvf ../archives/swig-$SWIG_VERSION.tar.gz
-    mv swig-rel-$SWIG_VERSION swig-$SWIG_VERSION
-    pushd swig-$SWIG_VERSION
-    ./autogen.sh
-    mkdir build && pushd build
-    ../configure --prefix=$DIR/build/swig-$SWIG_VERSION/install
-    make -j$CPUS
-    make install
-    popd && popd
-fi
-
-# compile llvm
-if [ ! -f $PREFIX/bin/clang ]; then
-    if [ -d llvm-$LLVM_VERSION ]; then
-        rm -rf llvm-$LLVM_VERSION
-    fi
-    tar -xvf ../archives/llvm-$LLVM_VERSION.src.tar.xz
-    mv llvm-$LLVM_VERSION.src llvm-$LLVM_VERSION
-    tar -xvf ../archives/cfe-$LLVM_VERSION.src.tar.xz
-    mv cfe-$LLVM_VERSION.src llvm-$LLVM_VERSION/tools/clang
-    tar -xvf ../archives/lld-$LLVM_VERSION.src.tar.xz
-    mv lld-$LLVM_VERSION.src/ llvm-$LLVM_VERSION/tools/lld
-    tar -xvf ../archives/compiler-rt-$LLVM_VERSION.src.tar.xz
-    mv compiler-rt-$LLVM_VERSION.src/ llvm-$LLVM_VERSION/projects/compiler-rt
-    tar -xvf ../archives/clang-tools-extra-$LLVM_VERSION.src.tar.xz
-    mv clang-tools-extra-$LLVM_VERSION.src/ llvm-$LLVM_VERSION/tools/clang/tools/extra
-    pushd llvm-$LLVM_VERSION
-    mkdir build && pushd build
-    # activate swig
-    export PATH=$DIR/build/swig-$SWIG_VERSION/install/bin:$PATH
-    # influenced by: https://buildd.debian.org/status/fetch.php?pkg=llvm-toolchain-7&arch=amd64&ver=1%3A7.0.1%7E%2Brc2-1%7Eexp1&stamp=1541506173&raw=0
-    cmake .. \
-        -DGCC_INSTALL_PREFIX=$PREFIX \
-        -DCMAKE_C_COMPILER=$PREFIX/bin/gcc \
-        -DCMAKE_CXX_COMPILER=$PREFIX/bin/g++ \
-        -DCMAKE_CXX_LINK_FLAGS="-L$PREFIX/lib64 -Wl,-rpath,$PREFIX/lib64" \
-        -DCMAKE_INSTALL_PREFIX=$PREFIX \
-        -DCMAKE_BUILD_TYPE=RelWithDebInfo \
-        -DCMAKE_CXX_FLAGS_RELWITHDEBINFO="-O2 -DNDEBUG" \
-        -DCMAKE_CXX_FLAGS=' -fuse-ld=gold -fPIC -Wno-unused-command-line-argument -Wno-unknown-warning-option' \
-        -DCMAKE_C_FLAGS=' -fuse-ld=gold -fPIC -Wno-unused-command-line-argument -Wno-unknown-warning-option' \
-        -DLLVM_LINK_LLVM_DYLIB=ON \
-        -DLLVM_INSTALL_UTILS=ON \
-        -DLLVM_VERSION_SUFFIX= \
-        -DLLVM_BUILD_LLVM_DYLIB=ON \
-        -DLLVM_ENABLE_RTTI=ON \
-        -DLLVM_ENABLE_FFI=ON \
-        -DLLVM_BINUTILS_INCDIR=$PREFIX/include/ \
-        -DLLVM_USE_PERF=yes \
-        -DLIBCLANG_LIBRARY_VERSION=1 \
-        -DCLANG_ENABLE_BOOTSTRAP=ON
-    make -j$CPUS
-    make -j$CPUS check-clang # run clang test suite
-    make -j$CPUS check-lld # run lld test suite
-    make install
-    popd && popd
-fi
-
-# create README
-if [ ! -f $PREFIX/README.md ]; then
-    cat >$PREFIX/README.md <<EOF
-# Memgraph Toolchain v$TOOLCHAIN_VERSION
-
-## Included tools
-
- - GCC $GCC_VERSION
- - Binutils $BINUTILS_VERSION
- - GDB $GDB_VERSION
- - CMake $CMAKE_VERSION
- - Cppcheck $CPPCHECK_VERSION
- - LLVM (Clang, LLD, compiler-rt, Clang tools extra) $LLVM_VERSION
-
-## Required libraries
-
-In order to be able to run all of these tools you should install the following
-packages:
-
-\`\`\`
-$DEPS_MANAGER install ${DEPS_RUN[@]}
-\`\`\`
-
-## Usage
-
-In order to use the toolchain you just have to source the activation script:
-
-\`\`\`
-source $PREFIX/activate
-\`\`\`
-EOF
-fi
-
-# create activation script
-if [ ! -f $PREFIX/activate ]; then
-    cat >$PREFIX/activate <<EOF
-# This file must be used with "source $PREFIX/activate" *from bash*
-# You can't run it directly!
-
-# check for active virtual environments
-if [ "\$( type -t deactivate )" != "" ]; then
-    echo "You already have an active virtual environment!"
-    return 0
-fi
-
-# check that we aren't root
-if [ "\$USER" == "root" ]; then
-    echo "You shouldn't use the toolchan as root!"
-    return 0
-fi
-
-# save original environment
-export ORIG_PATH=\$PATH
-export ORIG_PS1=\$PS1
-export ORIG_LD_LIBRARY_PATH=\$LD_LIBRARY_PATH
-
-# activate new environment
-export PATH=$PREFIX/bin:\$PATH
-export PS1="(TOOLCHAIN) \$PS1"
-export LD_LIBRARY_PATH=$PREFIX/lib:$PREFIX/lib64
-
-# disable root
-function su () {
-    echo "You don't want to use root functions while using the toolchain!"
-    return 1
-}
-function sudo () {
-    echo "You don't want to use root functions while using the toolchain!"
-    return 1
-}
-
-# create deactivation function
-function deactivate() {
-    export PATH=\$ORIG_PATH
-    export PS1=\$ORIG_PS1
-    export LD_LIBRARY_PATH=\$ORIG_LD_LIBRARY_PATH
-    unset ORIG_PATH ORIG_PS1 ORIG_LD_LIBRARY_PATH
-    unset -f su sudo deactivate
-}
-EOF
-fi
-
-# create toolchain archive
-if [ ! -f $NAME-binaries-$DISTRO.tar.gz ]; then
-    tar --owner=root --group=root -cpvzf $NAME-binaries-$DISTRO.tar.gz -C /opt $NAME
-fi
-
-# output final instructions
-echo -e "\n\n"
-echo "All tools have been built. They are installed in '$PREFIX'."
-echo "In order to distribute the tools to someone else, an archive with the toolchain was created in the 'build' directory."
-echo "If you want to install the packed tools you should execute the following command:"
-echo
-echo "    tar -xvzf build/$NAME-binaries.tar.gz -C /opt"
-echo
-echo "Because the tools were built on this machine, you should probably change the permissions of the installation directory using:"
-echo
-echo "    OPTIONAL: chown -R root:root $PREFIX"
-echo
-echo "In order to use all of the newly compiled tools you should use the prepared activation script:"
-echo
-echo "    source $PREFIX/activate"
-echo
-echo "Or, for more advanced uses, you can add the following lines to your script:"
-echo
-echo "    export PATH=$PREFIX/bin:\$PATH"
-echo "    export LD_LIBRARY_PATH=$PREFIX/lib:$PREFIX/lib64"
-echo
-echo "Enjoy!"

environment/toolchain/v2.sh

@@ -1,533 +0,0 @@
-#!/bin/bash -e
-
-# helpers
-pushd () { command pushd "$@" > /dev/null; }
-popd () { command popd "$@" > /dev/null; }
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-CPUS=$( grep -c processor < /proc/cpuinfo )
-cd "$DIR"
-
-source "$DIR/../util.sh"
-DISTRO="$(operating_system)"
-
-# toolchain version
-TOOLCHAIN_VERSION=2
-
-# package versions used
-GCC_VERSION=10.2.0
-BINUTILS_VERSION=2.35.1
-case "$DISTRO" in
-    centos-7) # because GDB >= 9 does NOT compile with readline6.
-        GDB_VERSION=8.3
-    ;;
-    *)
-        GDB_VERSION=10.1
-    ;;
-esac
-CMAKE_VERSION=3.18.4
-CPPCHECK_VERSION=2.2
-LLVM_VERSION=11.0.0
-SWIG_VERSION=4.0.2 # used only for LLVM compilation
-
-# Check for the dependencies.
-echo "ALL BUILD PACKAGES: $($DIR/../os/$DISTRO.sh list TOOLCHAIN_BUILD_DEPS)"
-$DIR/../os/$DISTRO.sh check TOOLCHAIN_BUILD_DEPS
-echo "ALL RUN PACKAGES: $($DIR/../os/$DISTRO.sh list TOOLCHAIN_RUN_DEPS)"
-$DIR/../os/$DISTRO.sh check TOOLCHAIN_RUN_DEPS
-
-# check installation directory
-NAME=toolchain-v$TOOLCHAIN_VERSION
-PREFIX=/opt/$NAME
-mkdir -p $PREFIX >/dev/null 2>/dev/null || true
-if [ ! -d $PREFIX ] || [ ! -w $PREFIX ]; then
-    echo "Please make sure that the directory '$PREFIX' exists and is writable by the current user!"
-    echo
-    echo "If unsure, execute these commands as root:"
-    echo "    mkdir $PREFIX && chown $USER:$USER $PREFIX"
-    echo
-    echo "Press <return> when you have created the directory and granted permissions."
-    # wait for the directory to be created
-    while true; do
-        read
-        if [ ! -d $PREFIX ] || [ ! -w $PREFIX ]; then
-            echo
-            echo "You can't continue before you have created the directory and granted permissions!"
-            echo
-            echo "Press <return> when you have created the directory and granted permissions."
-        else
-            break
-        fi
-    done
-fi
-
-# create archives directory
-mkdir -p archives
-
-# download all archives
-pushd archives
-if [ ! -f gcc-$GCC_VERSION.tar.gz ]; then
-    wget https://ftp.gnu.org/gnu/gcc/gcc-$GCC_VERSION/gcc-$GCC_VERSION.tar.gz
-fi
-if [ ! -f binutils-$BINUTILS_VERSION.tar.gz ]; then
-    wget https://ftp.gnu.org/gnu/binutils/binutils-$BINUTILS_VERSION.tar.gz
-fi
-if [ ! -f gdb-$GDB_VERSION.tar.gz ]; then
-    wget https://ftp.gnu.org/gnu/gdb/gdb-$GDB_VERSION.tar.gz
-fi
-if [ ! -f cmake-$CMAKE_VERSION.tar.gz ]; then
-    wget https://github.com/Kitware/CMake/releases/download/v$CMAKE_VERSION/cmake-$CMAKE_VERSION.tar.gz
-fi
-if [ ! -f swig-$SWIG_VERSION.tar.gz ]; then
-    wget https://github.com/swig/swig/archive/rel-$SWIG_VERSION.tar.gz -O swig-$SWIG_VERSION.tar.gz
-fi
-if [ ! -f cppcheck-$CPPCHECK_VERSION.tar.gz ]; then
-    wget https://github.com/danmar/cppcheck/archive/$CPPCHECK_VERSION.tar.gz -O cppcheck-$CPPCHECK_VERSION.tar.gz
-fi
-if [ ! -f llvm-$LLVM_VERSION.src.tar.xz ]; then
-    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION/llvm-$LLVM_VERSION.src.tar.xz
-    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION/clang-$LLVM_VERSION.src.tar.xz
-    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION/lld-$LLVM_VERSION.src.tar.xz
-    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION/clang-tools-extra-$LLVM_VERSION.src.tar.xz
-    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION/compiler-rt-$LLVM_VERSION.src.tar.xz
-fi
-if [ ! -f pahole-gdb-master.zip ]; then
-    wget https://github.com/PhilArmstrong/pahole-gdb/archive/master.zip -O pahole-gdb-master.zip
-fi
-
-# verify all archives
-# NOTE: Verification can fail if the archive is signed by another developer. I
-# haven't added commands to download all developer GnuPG keys because the
-# download is very slow. If the verification fails for you, figure out who has
-# signed the archive and download their public key instead.
-GPG="gpg --homedir .gnupg"
-KEYSERVER="hkp://keyserver.ubuntu.com"
-mkdir -p .gnupg
-chmod 700 .gnupg
-# verify gcc
-if [ ! -f gcc-$GCC_VERSION.tar.gz.sig ]; then
-    wget https://ftp.gnu.org/gnu/gcc/gcc-$GCC_VERSION/gcc-$GCC_VERSION.tar.gz.sig
-fi
-# list of valid gcc gnupg keys: https://gcc.gnu.org/mirrors.html
-$GPG --keyserver $KEYSERVER --recv-keys 0x3AB00996FC26A641
-$GPG --verify gcc-$GCC_VERSION.tar.gz.sig gcc-$GCC_VERSION.tar.gz
-# verify binutils
-if [ ! -f binutils-$BINUTILS_VERSION.tar.gz.sig ]; then
-    wget https://ftp.gnu.org/gnu/binutils/binutils-$BINUTILS_VERSION.tar.gz.sig
-fi
-$GPG --keyserver $KEYSERVER --recv-keys 0xDD9E3C4F
-$GPG --verify binutils-$BINUTILS_VERSION.tar.gz.sig binutils-$BINUTILS_VERSION.tar.gz
-# verify gdb
-if [ ! -f gdb-$GDB_VERSION.tar.gz.sig ]; then
-    wget https://ftp.gnu.org/gnu/gdb/gdb-$GDB_VERSION.tar.gz.sig
-fi
-$GPG --keyserver $KEYSERVER --recv-keys 0xFF325CF3
-$GPG --verify gdb-$GDB_VERSION.tar.gz.sig gdb-$GDB_VERSION.tar.gz
-# verify cmake
-if [ ! -f cmake-$CMAKE_VERSION-SHA-256.txt ] || [ ! -f cmake-$CMAKE_VERSION-SHA-256.txt.asc ]; then
-    wget https://github.com/Kitware/CMake/releases/download/v$CMAKE_VERSION/cmake-$CMAKE_VERSION-SHA-256.txt
-    wget https://github.com/Kitware/CMake/releases/download/v$CMAKE_VERSION/cmake-$CMAKE_VERSION-SHA-256.txt.asc
-    # Because CentOS 7 doesn't have the `--ignore-missing` flag for `sha256sum`
-    # we filter out the missing files from the sums here manually.
-    cat cmake-$CMAKE_VERSION-SHA-256.txt | grep "cmake-$CMAKE_VERSION.tar.gz" > cmake-$CMAKE_VERSION-SHA-256-filtered.txt
-fi
-$GPG --keyserver $KEYSERVER --recv-keys 0xC6C265324BBEBDC350B513D02D2CEF1034921684
-sha256sum -c cmake-$CMAKE_VERSION-SHA-256-filtered.txt
-$GPG --verify cmake-$CMAKE_VERSION-SHA-256.txt.asc cmake-$CMAKE_VERSION-SHA-256.txt
-# verify llvm, cfe, lld, clang-tools-extra
-if [ ! -f llvm-$LLVM_VERSION.src.tar.xz.sig ]; then
-    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION/llvm-$LLVM_VERSION.src.tar.xz.sig
-    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION/clang-$LLVM_VERSION.src.tar.xz.sig
-    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION/lld-$LLVM_VERSION.src.tar.xz.sig
-    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION/clang-tools-extra-$LLVM_VERSION.src.tar.xz.sig
-    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION/compiler-rt-$LLVM_VERSION.src.tar.xz.sig
-fi
-# list of valid llvm gnupg keys: https://releases.llvm.org/download.html
-$GPG --keyserver $KEYSERVER --recv-keys 0x345AD05D
-$GPG --verify llvm-$LLVM_VERSION.src.tar.xz.sig llvm-$LLVM_VERSION.src.tar.xz
-$GPG --verify clang-$LLVM_VERSION.src.tar.xz.sig clang-$LLVM_VERSION.src.tar.xz
-$GPG --verify lld-$LLVM_VERSION.src.tar.xz.sig lld-$LLVM_VERSION.src.tar.xz
-$GPG --verify clang-tools-extra-$LLVM_VERSION.src.tar.xz.sig clang-tools-extra-$LLVM_VERSION.src.tar.xz
-$GPG --verify compiler-rt-$LLVM_VERSION.src.tar.xz.sig compiler-rt-$LLVM_VERSION.src.tar.xz
-popd
-
-# create build directory
-mkdir -p build
-pushd build
-
-# compile gcc
-if [ ! -f $PREFIX/bin/gcc ]; then
-    if [ -d gcc-$GCC_VERSION ]; then
-        rm -rf gcc-$GCC_VERSION
-    fi
-    tar -xvf ../archives/gcc-$GCC_VERSION.tar.gz
-    pushd gcc-$GCC_VERSION
-    ./contrib/download_prerequisites
-    mkdir build && pushd build
-    # influenced by: https://buildd.debian.org/status/fetch.php?pkg=gcc-8&arch=amd64&ver=8.3.0-6&stamp=1554588545
-    ../configure -v \
-        --build=x86_64-linux-gnu \
-        --host=x86_64-linux-gnu \
-        --target=x86_64-linux-gnu \
-        --prefix=$PREFIX \
-        --disable-multilib \
-        --with-system-zlib \
-        --enable-checking=release \
-        --enable-languages=c,c++,fortran \
-        --enable-gold=yes \
-        --enable-ld=yes \
-        --enable-lto \
-        --enable-bootstrap \
-        --disable-vtable-verify \
-        --disable-werror \
-        --without-included-gettext \
-        --enable-threads=posix \
-        --enable-nls \
-        --enable-clocale=gnu \
-        --enable-libstdcxx-debug \
-        --enable-libstdcxx-time=yes \
-        --enable-gnu-unique-object \
-        --enable-libmpx \
-        --enable-plugin \
-        --enable-default-pie \
-        --with-target-system-zlib \
-        --with-tune=generic \
-        --without-cuda-driver
-        #--program-suffix=$( printf "$GCC_VERSION" | cut -d '.' -f 1,2 ) \
-    make -j$CPUS
-    # make -k check # run test suite
-    make install
-    popd && popd
-fi
-
-# activate toolchain
-export PATH=$PREFIX/bin:$PATH
-export LD_LIBRARY_PATH=$PREFIX/lib64
-
-# compile binutils
-if [ ! -f $PREFIX/bin/ld.gold ]; then
-    if [ -d binutils-$BINUTILS_VERSION ]; then
-        rm -rf binutils-$BINUTILS_VERSION
-    fi
-    tar -xvf ../archives/binutils-$BINUTILS_VERSION.tar.gz
-    pushd binutils-$BINUTILS_VERSION
-    mkdir build && pushd build
-    # influenced by: https://buildd.debian.org/status/fetch.php?pkg=binutils&arch=amd64&ver=2.32-7&stamp=1553247092
-    env \
-        CC=gcc \
-        CXX=g++ \
-        CFLAGS="-g -O2" \
-        CXXFLAGS="-g -O2" \
-        LDFLAGS="" \
-        ../configure \
-            --build=x86_64-linux-gnu \
-            --host=x86_64-linux-gnu \
-            --prefix=$PREFIX \
-            --enable-ld=default \
-            --enable-gold \
-            --enable-lto \
-            --enable-plugins \
-            --enable-shared \
-            --enable-threads \
-            --with-system-zlib \
-            --enable-deterministic-archives \
-            --disable-compressed-debug-sections \
-            --enable-new-dtags \
-            --disable-werror
-    make -j$CPUS
-    # make -k check # run test suite
-    make install
-    popd && popd
-fi
-
-# compile gdb
-if [ ! -f $PREFIX/bin/gdb ]; then
-    if [ -d gdb-$GDB_VERSION ]; then
-        rm -rf gdb-$GDB_VERSION
-    fi
-    tar -xvf ../archives/gdb-$GDB_VERSION.tar.gz
-    pushd gdb-$GDB_VERSION
-    mkdir build && pushd build
-    # https://buildd.debian.org/status/fetch.php?pkg=gdb&arch=amd64&ver=8.2.1-2&stamp=1550831554&raw=0
-    env \
-        CC=gcc \
-        CXX=g++ \
-        CFLAGS="-g -O2 -fstack-protector-strong -Wformat -Werror=format-security" \
-        CXXFLAGS="-g -O2 -fstack-protector-strong -Wformat -Werror=format-security" \
-        CPPFLAGS="-Wdate-time -D_FORTIFY_SOURCE=2 -fPIC" \
-        LDFLAGS="-Wl,-z,relro" \
-        PYTHON="" \
-        ../configure \
-            --build=x86_64-linux-gnu \
-            --host=x86_64-linux-gnu \
-            --prefix=$PREFIX \
-            --disable-maintainer-mode \
-            --disable-dependency-tracking \
-            --disable-silent-rules \
-            --disable-gdbtk \
-            --disable-shared \
-            --without-guile \
-            --with-system-gdbinit=$PREFIX/etc/gdb/gdbinit \
-            --with-system-readline \
-            --with-expat \
-            --with-system-zlib \
-            --with-lzma \
-            --with-babeltrace \
-            --with-intel-pt \
-            --enable-tui \
-            --with-python=python3
-    make -j$CPUS
-    make install
-    popd && popd
-fi
-
-# install pahole
-if [ ! -d $PREFIX/share/pahole-gdb ]; then
-    unzip ../archives/pahole-gdb-master.zip
-    mv pahole-gdb-master $PREFIX/share/pahole-gdb
-fi
-
-# setup system gdbinit
-if [ ! -f $PREFIX/etc/gdb/gdbinit ]; then
-    mkdir -p $PREFIX/etc/gdb
-    cat >$PREFIX/etc/gdb/gdbinit <<EOF
-# improve formatting
-set print pretty on
-set print object on
-set print static-members on
-set print vtbl on
-set print demangle on
-set demangle-style gnu-v3
-set print sevenbit-strings off
-
-# load libstdc++ pretty printers
-add-auto-load-scripts-directory $PREFIX/lib64
-add-auto-load-safe-path $PREFIX
-
-# load pahole
-python
-sys.path.insert(0, "$PREFIX/share/pahole-gdb")
-import offsets
-import pahole
-end
-EOF
-fi
-
-# compile cmake
-if [ ! -f $PREFIX/bin/cmake ]; then
-    if [ -d cmake-$CMAKE_VERSION ]; then
-        rm -rf cmake-$CMAKE_VERSION
-    fi
-    tar -xvf ../archives/cmake-$CMAKE_VERSION.tar.gz
-    pushd cmake-$CMAKE_VERSION
-    # influenced by: https://buildd.debian.org/status/fetch.php?pkg=cmake&arch=amd64&ver=3.13.4-1&stamp=1549799837
-    echo 'set(CMAKE_SKIP_RPATH ON CACHE BOOL "Skip rpath" FORCE)' >> build-flags.cmake
-    echo 'set(CMAKE_USE_RELATIVE_PATHS ON CACHE BOOL "Use relative paths" FORCE)' >> build-flags.cmake
-    echo 'set(CMAKE_C_FLAGS "-g -O2 -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2" CACHE STRING "C flags" FORCE)' >> build-flags.cmake
-    echo 'set(CMAKE_CXX_FLAGS "-g -O2 -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2" CACHE STRING "C++ flags" FORCE)' >> build-flags.cmake
-    echo 'set(CMAKE_SKIP_BOOTSTRAP_TEST ON CACHE BOOL "Skip BootstrapTest" FORCE)' >> build-flags.cmake
-    echo 'set(BUILD_CursesDialog ON CACHE BOOL "Build curses GUI" FORCE)' >> build-flags.cmake
-    mkdir build && pushd build
-    ../bootstrap \
-        --prefix=$PREFIX \
-        --init=../build-flags.cmake \
-        --parallel=$CPUS \
-        --system-curl
-    make -j$CPUS
-    # make test # run test suite
-    make install
-    popd && popd
-fi
-
-# compile cppcheck
-if [ ! -f $PREFIX/bin/cppcheck ]; then
-    if [ -d cppcheck-$CPPCHECK_VERSION ]; then
-        rm -rf cppcheck-$CPPCHECK_VERSION
-    fi
-    tar -xvf ../archives/cppcheck-$CPPCHECK_VERSION.tar.gz
-    pushd cppcheck-$CPPCHECK_VERSION
-    env \
-        CC=gcc \
-        CXX=g++ \
-        PREFIX=$PREFIX \
-        FILESDIR=$PREFIX/share/cppcheck \
-        CFGDIR=$PREFIX/share/cppcheck/cfg \
-            make -j$CPUS
-    env \
-        CC=gcc \
-        CXX=g++ \
-        PREFIX=$PREFIX \
-        FILESDIR=$PREFIX/share/cppcheck \
-        CFGDIR=$PREFIX/share/cppcheck/cfg \
-            make install
-    popd
-fi
-
-# compile swig
-if [ ! -d swig-$SWIG_VERSION/install ]; then
-    if [ -d swig-$SWIG_VERSION ]; then
-        rm -rf swig-$SWIG_VERSION
-    fi
-    tar -xvf ../archives/swig-$SWIG_VERSION.tar.gz
-    mv swig-rel-$SWIG_VERSION swig-$SWIG_VERSION
-    pushd swig-$SWIG_VERSION
-    ./autogen.sh
-    mkdir build && pushd build
-    ../configure --prefix=$DIR/build/swig-$SWIG_VERSION/install
-    make -j$CPUS
-    make install
-    popd && popd
-fi
-
-# compile llvm
-if [ ! -f $PREFIX/bin/clang ]; then
-    if [ -d llvm-$LLVM_VERSION ]; then
-        rm -rf llvm-$LLVM_VERSION
-    fi
-    tar -xvf ../archives/llvm-$LLVM_VERSION.src.tar.xz
-    mv llvm-$LLVM_VERSION.src llvm-$LLVM_VERSION
-    tar -xvf ../archives/clang-$LLVM_VERSION.src.tar.xz
-    mv clang-$LLVM_VERSION.src llvm-$LLVM_VERSION/tools/clang
-    tar -xvf ../archives/lld-$LLVM_VERSION.src.tar.xz
-    mv lld-$LLVM_VERSION.src/ llvm-$LLVM_VERSION/tools/lld
-    tar -xvf ../archives/clang-tools-extra-$LLVM_VERSION.src.tar.xz
-    mv clang-tools-extra-$LLVM_VERSION.src/ llvm-$LLVM_VERSION/tools/clang/tools/extra
-    tar -xvf ../archives/compiler-rt-$LLVM_VERSION.src.tar.xz
-    mv compiler-rt-$LLVM_VERSION.src/ llvm-$LLVM_VERSION/projects/compiler-rt
-    pushd llvm-$LLVM_VERSION
-    mkdir build && pushd build
-    # activate swig
-    export PATH=$DIR/build/swig-$SWIG_VERSION/install/bin:$PATH
-    # influenced by: https://buildd.debian.org/status/fetch.php?pkg=llvm-toolchain-7&arch=amd64&ver=1%3A7.0.1%7E%2Brc2-1%7Eexp1&stamp=1541506173&raw=0
-    cmake .. \
-        -DCMAKE_C_COMPILER=$PREFIX/bin/gcc \
-        -DCMAKE_CXX_COMPILER=$PREFIX/bin/g++ \
-        -DCMAKE_CXX_LINK_FLAGS="-L$PREFIX/lib64 -Wl,-rpath,$PREFIX/lib64" \
-        -DCMAKE_INSTALL_PREFIX=$PREFIX \
-        -DCMAKE_BUILD_TYPE=RelWithDebInfo \
-        -DCMAKE_CXX_FLAGS_RELWITHDEBINFO="-O2 -DNDEBUG" \
-        -DCMAKE_CXX_FLAGS=' -fuse-ld=gold -fPIC -Wno-unused-command-line-argument -Wno-unknown-warning-option' \
-        -DCMAKE_C_FLAGS=' -fuse-ld=gold -fPIC -Wno-unused-command-line-argument -Wno-unknown-warning-option' \
-        -DLLVM_LINK_LLVM_DYLIB=ON \
-        -DLLVM_INSTALL_UTILS=ON \
-        -DLLVM_VERSION_SUFFIX= \
-        -DLLVM_BUILD_LLVM_DYLIB=ON \
-        -DLLVM_ENABLE_RTTI=ON \
-        -DLLVM_ENABLE_FFI=ON \
-        -DLLVM_BINUTILS_INCDIR=$PREFIX/include/ \
-        -DLLVM_USE_PERF=yes
-    make -j$CPUS
-    make -j$CPUS check-clang # run clang test suite
-    make -j$CPUS check-lld # run lld test suite
-    make install
-    popd && popd
-fi
-
-# create README
-if [ ! -f $PREFIX/README.md ]; then
-    cat >$PREFIX/README.md <<EOF
-# Memgraph Toolchain v$TOOLCHAIN_VERSION
-
-## Included tools
-
- - GCC $GCC_VERSION
- - Binutils $BINUTILS_VERSION
- - GDB $GDB_VERSION
- - CMake $CMAKE_VERSION
- - Cppcheck $CPPCHECK_VERSION
- - LLVM (Clang, LLD, compiler-rt, Clang tools extra) $LLVM_VERSION
-
-## Required libraries
-
-In order to be able to run all of these tools you should install the following
-packages:
-
-\`\`\`
-$($DIR/../os/$DISTRO.sh list TOOLCHAIN_RUN_DEPS)
-\`\`\`
-
-## Usage
-
-In order to use the toolchain you just have to source the activation script:
-
-\`\`\`
-source $PREFIX/activate
-\`\`\`
-EOF
-fi
-
-# create activation script
-if [ ! -f $PREFIX/activate ]; then
-    cat >$PREFIX/activate <<EOF
-# This file must be used with "source $PREFIX/activate" *from bash*
-# You can't run it directly!
-
-# check for active virtual environments
-if [ "\$( type -t deactivate )" != "" ]; then
-    echo "You already have an active virtual environment!"
-    return 0
-fi
-
-# check that we aren't root
-if [ "\$USER" == "root" ]; then
-    echo "You shouldn't use the toolchan as root!"
-    return 0
-fi
-
-# save original environment
-export ORIG_PATH=\$PATH
-export ORIG_PS1=\$PS1
-export ORIG_LD_LIBRARY_PATH=\$LD_LIBRARY_PATH
-
-# activate new environment
-export PATH=$PREFIX/bin:\$PATH
-export PS1="($NAME) \$PS1"
-export LD_LIBRARY_PATH=$PREFIX/lib:$PREFIX/lib64
-
-# disable root
-function su () {
-    echo "You don't want to use root functions while using the toolchain!"
-    return 1
-}
-function sudo () {
-    echo "You don't want to use root functions while using the toolchain!"
-    return 1
-}
-
-# create deactivation function
-function deactivate() {
-    export PATH=\$ORIG_PATH
-    export PS1=\$ORIG_PS1
-    export LD_LIBRARY_PATH=\$ORIG_LD_LIBRARY_PATH
-    unset ORIG_PATH ORIG_PS1 ORIG_LD_LIBRARY_PATH
-    unset -f su sudo deactivate
-}
-EOF
-fi
-
-# create toolchain archive
-if [ ! -f $NAME-binaries-$DISTRO.tar.gz ]; then
-    tar --owner=root --group=root -cpvzf $NAME-binaries-$DISTRO.tar.gz -C /opt $NAME
-fi
-
-# output final instructions
-echo -e "\n\n"
-echo "All tools have been built. They are installed in '$PREFIX'."
-echo "In order to distribute the tools to someone else, an archive with the toolchain was created in the 'build' directory."
-echo "If you want to install the packed tools you should execute the following command:"
-echo
-echo "    tar -xvzf build/$NAME-binaries.tar.gz -C /opt"
-echo
-echo "Because the tools were built on this machine, you should probably change the permissions of the installation directory using:"
-echo
-echo "    OPTIONAL: chown -R root:root $PREFIX"
-echo
-echo "In order to use all of the newly compiled tools you should use the prepared activation script:"
-echo
-echo "    source $PREFIX/activate"
-echo
-echo "Or, for more advanced uses, you can add the following lines to your script:"
-echo
-echo "    export PATH=$PREFIX/bin:\$PATH"
-echo "    export LD_LIBRARY_PATH=$PREFIX/lib:$PREFIX/lib64"
-echo
-echo "Enjoy!"

environment/util.sh

@@ -1,50 +0,0 @@
-#!/bin/bash
-
-operating_system() {
-    grep -E '^(VERSION_)?ID=' /etc/os-release | \
-    sort | cut -d '=' -f 2- | sed 's/"//g' | paste -s -d '-'
-}
-
-check_all_yum() {
-    local missing=""
-    for pkg in $1; do
-        if ! yum list installed "$pkg" >/dev/null 2>/dev/null; then
-            missing="$pkg $missing"
-        fi
-    done
-    if [ "$missing" != "" ]; then
-        echo "MISSING PACKAGES: $missing"
-        exit 1
-    fi
-}
-
-check_all_dpkg() {
-    local missing=""
-    for pkg in $1; do
-        if ! dpkg -s "$pkg" >/dev/null 2>/dev/null; then
-            missing="$pkg $missing"
-        fi
-    done
-    if [ "$missing" != "" ]; then
-        echo "MISSING PACKAGES: $missing"
-        exit 1
-    fi
-}
-
-check_all_dnf() {
-    local missing=""
-    for pkg in $1; do
-        if ! dnf list installed "$pkg" >/dev/null 2>/dev/null; then
-            missing="$pkg $missing"
-        fi
-    done
-    if [ "$missing" != "" ]; then
-        echo "MISSING PACKAGES: $missing"
-        exit 1
-    fi
-}
-install_all_apt() {
-    for pkg in $1; do
-        apt install -y "$pkg"
-    done
-}

experimental/CMakeLists.txt

@@ -0,0 +1,2 @@
+# distributed
+add_subdirectory(distributed)

experimental/distributed/.clang-format

@@ -0,0 +1,8 @@
+---
+Language:     Cpp
+BasedOnStyle: Google
+Standard:     "C++11"
+UseTab:       Never
+DerivePointerAlignment: false
+PointerAlignment: Right
+...

experimental/distributed/.gitignore

@@ -0,0 +1,7 @@
+*.out
+*.pyc
+main
+libs/
+*.cereal
+*.backup
+*.out

experimental/distributed/CMakeLists.txt

@@ -0,0 +1,42 @@
+project(distributed)
+
+# set directory variables
+set(src_dir ${PROJECT_SOURCE_DIR}/src)
+set(libs_dir ${PROJECT_SOURCE_DIR}/libs)
+
+# includes
+include_directories(SYSTEM ${libs_dir}/cereal/include)
+include_directories(${src_dir})
+
+# library from distributed sources
+file(GLOB_RECURSE src_files ${src_dir}/*.cpp)
+add_library(distributed_lib STATIC ${src_files})
+
+## distributed Memgraph executable
+set(executable_name main)
+add_executable(${executable_name} ${PROJECT_SOURCE_DIR}/main.cpp)
+target_link_libraries(${executable_name} distributed_lib memgraph_lib)
+
+## dummy distributed Memgraph client
+set(executable_name main-client)
+add_executable(${executable_name} ${PROJECT_SOURCE_DIR}/main-client.cpp)
+target_link_libraries(${executable_name} distributed_lib memgraph_lib)
+
+# tests
+enable_testing()
+add_subdirectory(tests)
+
+# copy test scripts into the build/ directory (for distributed tests)
+configure_file(${PROJECT_SOURCE_DIR}/tests/start_distributed
+  ${PROJECT_BINARY_DIR}/tests/start_distributed COPYONLY)
+
+configure_file(${PROJECT_SOURCE_DIR}/tests/config
+  ${PROJECT_BINARY_DIR}/tests/config COPYONLY)
+
+# copy main scripts into build/ directory (for distributed Memgraph)
+configure_file(${PROJECT_SOURCE_DIR}/start_main.py
+  ${PROJECT_BINARY_DIR}/start_main.py COPYONLY)
+
+configure_file(${PROJECT_SOURCE_DIR}/config
+  ${PROJECT_BINARY_DIR}/config COPYONLY)
+

experimental/distributed/README.md

@@ -0,0 +1,35 @@
+
+# distributed memgraph
+
+This subdirectory structure implements distributed infrastructure of Memgraph.
+
+## Terminology
+
+* Memgraph Node Id (mnid): a machine (processs) that runs a (distributed) Memgraph program.
+* Node: a computer that performs (distributed) work.
+* Vertex: an abstract graph concept.
+* Reactor: a unit of concurrent execution, lives on its own thread.
+* Channel: a (one-way) communication abstraction between Reactors. The reactors can be on the same machine or on different processes.
+* Message: gets sent through channels. Must be serializable if sent via network layer (library: cereal).
+* Event: arrival of a (subclass of) Message. You can register callbacks. Register exact callbacks (not for derivated/subclasses).
+* EventStream: read-end of a channel, is owned by exactly one Reactor/thread.
+* ChannelWriter: write-end of a channel, can be owned (wrote into) by multiple threads.
+
+## Ownership:
+
+* System, Distributed are singletons. They should be always alive.
+* ChannelWriter (write-end) should be lightweight and can be copied arbitrarily.
+* EventStream (read-end) should never be written by anyone except the owner (the reactor that created it).
+* In general: always think about who owns an object. Preferably write it in its comment block.
+
+## Code Conventions
+
+* Locked: A method having a "Locked..." prefix indicates that you
+  have to lock the appropriate mutex before calling this function.
+* ALWAYS close channels. You will memory leak if you don't.
+  Reactor::CloseChannel or Subscription::Close will do the trick.
+
+## Dependencies
+
+* cereal
+* <other memgraph dependencies>

experimental/distributed/config

@@ -0,0 +1,3 @@
+0 127.0.0.1 10010
+1 127.0.0.1 10011
+2 127.0.0.1 10012

experimental/distributed/init

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+working_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+libs_dir=$working_dir/libs
+if [ ! -d $libs_dir ]; then
+    mkdir $libs_dir
+fi
+
+cd $libs_dir
+git clone https://github.com/USCiLab/cereal.git
+cd $libs_dir/cereal
+git checkout v1.2.2

experimental/distributed/main-client.cpp

@@ -0,0 +1,77 @@
+#include <fstream>
+#include <iostream>
+#include <memory>
+
+#include "memgraph_config.hpp"
+#include "memgraph_distributed.hpp"
+#include "memgraph_transactions.hpp"
+#include "reactors_distributed.hpp"
+
+/**
+ * List of queries that should be executed.
+ */
+std::vector<std::string> queries = {
+    {"create vertex", "create vertex", "create vertex", "create vertex",
+     "create vertex", "create vertex", "create vertex", "create vertex",
+     "create vertex", "create vertex", "vertex count", "create vertex",
+     "create vertex", "vertex count"}};
+
+/**
+ * This is the client that issues some hard-coded queries.
+ */
+class Client : public Reactor {
+ public:
+  Client(std::string name) : Reactor(name) {}
+
+  void IssueQueries(std::shared_ptr<ChannelWriter> channel_to_leader) {
+    // (concurrently) create a couple of vertices
+    for (int query_idx = 0; query_idx < static_cast<int64_t>(queries.size());
+         ++query_idx) {
+      // register callback
+      std::string channel_name = "query-" + std::to_string(query_idx);
+      auto stream = Open(channel_name).first;
+      stream->OnEventOnce().ChainOnce<ResultMsg>(
+          [this, query_idx](const ResultMsg &msg, const Subscription &sub) {
+            std::cout << "Result of query " << query_idx << " ("
+                      << queries[query_idx] << "):" << std::endl
+                      << "  " << msg.result() << std::endl;
+            sub.CloseChannel();
+          });
+
+      // then issue the query (to avoid race conditions)
+      std::cout << "Issuing command " << query_idx << " (" << queries[query_idx]
+                << ")" << std::endl;
+      channel_to_leader->Send<QueryMsg>(channel_name, queries[query_idx]);
+    }
+  }
+
+  virtual void Run() {
+    MemgraphDistributed &memgraph = MemgraphDistributed::GetInstance();
+    auto mnid = memgraph.LeaderMnid();
+
+    memgraph.FindChannel(mnid, "master", "client-queries")
+        ->OnEventOnce()
+        .ChainOnce<ChannelResolvedMessage>(
+            [this](const ChannelResolvedMessage &msg, const Subscription &sub) {
+              sub.CloseChannel();
+              IssueQueries(msg.channelWriter());
+            });
+  }
+};
+
+int main(int argc, char *argv[]) {
+  gflags::ParseCommandLineFlags(&argc, &argv, true);
+  google::InitGoogleLogging(argv[0]);
+
+  System &system = System::GetInstance();
+  Distributed &distributed = Distributed::GetInstance();
+  MemgraphDistributed &memgraph = MemgraphDistributed::GetInstance();
+  memgraph.RegisterConfig(ParseConfig());
+  distributed.StartServices();
+
+  system.Spawn<Client>("client");
+
+  system.AwaitShutdown();
+  distributed.StopServices();
+  return 0;
+}

experimental/distributed/main.cpp

@@ -0,0 +1,215 @@
+#include <fstream>
+#include <iostream>
+#include <random>
+
+#include <gflags/gflags.h>
+#include <glog/logging.h>
+
+#include "memgraph_config.hpp"
+#include "memgraph_distributed.hpp"
+#include "memgraph_transactions.hpp"
+#include "reactors_distributed.hpp"
+#include "storage.hpp"
+
+DEFINE_uint64(my_mnid, -1, "Memgraph node id"); // TODO(zuza): this should be assigned by the leader once in the future
+
+class Master : public Reactor {
+ public:
+  Master(std::string name, MnidT mnid) : Reactor(name), mnid_(mnid) {
+    MemgraphDistributed& memgraph = MemgraphDistributed::GetInstance();
+    worker_mnids_ = memgraph.GetAllMnids();
+    // remove the leader (itself), because it is not a worker
+    auto leader_it = std::find(worker_mnids_.begin(), worker_mnids_.end(), memgraph.LeaderMnid());
+    worker_mnids_.erase(leader_it);
+  }
+
+  virtual void Run() {
+    Distributed &distributed = Distributed::GetInstance();
+
+    std::cout << "Master (" << mnid_ << ") @ " << distributed.network().Address()
+              << ":" << distributed.network().Port() << std::endl;
+
+    // TODO(zuza): check if all workers are up
+
+    // start listening on queries arriving from the client
+    auto stream = Open("client-queries").first;
+    stream->OnEvent<QueryMsg>([this](const QueryMsg &msg, const Subscription &){
+      // process query message
+      if (msg.query() == "create vertex") {
+        InstallMakeVertex(msg.GetReturnChannelWriter());
+      } else if (msg.query() == "vertex count") {
+        InstallVertexCount(msg.GetReturnChannelWriter());
+      } else {
+        std::cerr << "unknown query" << std::endl;
+      }
+    });
+  }
+
+ private:
+  /**
+   * Organizes communication with all workers and performs VertexCount.
+   */
+  void InstallVertexCount(std::shared_ptr<ChannelWriter> return_channel) {
+    // open channel through which answers will arrive
+    auto channel_name = "response" + std::to_string(xid++);
+    auto result = Open(channel_name).first;
+
+    // create struct to keep track of responses
+    struct VertexCountResponse {
+      VertexCountResponse(int64_t count, int64_t remaining)
+          : count_(count), remaining_(remaining) {}
+
+      int64_t count_;
+      int64_t remaining_;
+    };
+
+    // allocate it dynamically so it lives outside the scope of this function
+    // it will be deallocated once all responses arrive and channel is closed
+    auto response = std::make_shared<VertexCountResponse>(0, worker_mnids_.size());
+
+    // register callbacks
+    result->OnEvent<ResultQueryVertexCount>(
+      [this, response, return_channel](const ResultQueryVertexCount &msg,
+                                       const Subscription &sub){
+        response->count_ += msg.count();
+        --response->remaining_;
+        if (response->remaining_ == 0) {
+          sub.CloseChannel();
+          return_channel->Send<ResultMsg>(std::to_string(response->count_));
+        }
+      });
+
+    // instruct workers to count vertices
+    for (auto wmnid : worker_mnids_)
+      VertexCount(wmnid, channel_name);
+  }
+
+  /**
+   * Asynchronously counts vertices on the given node.
+   *
+   * @param mnid Id of the node whose vertices should be counted.
+   * @param channel_name Name of the channel on which response will arrive.
+   */
+  void VertexCount(MnidT mnid, std::string channel_name) {
+    MemgraphDistributed::GetInstance().FindChannel(mnid, "worker", "main")
+      ->OnEventOnceThenClose<ChannelResolvedMessage>(
+          [this, channel_name](const ChannelResolvedMessage &msg){
+            msg.channelWriter()->Send<QueryVertexCount>(channel_name);
+          });
+  }
+
+  /**
+   * Organizes communication with a random worker and performs MakeVertex.
+   */
+  void InstallMakeVertex(std::shared_ptr<ChannelWriter> return_channel) {
+    // choose worker on random and instruct it to make vertex
+    auto wmnid = worker_mnids_[rand() % worker_mnids_.size()];
+
+    // open channel through which answer will arrive
+    auto channel_name = "response" + std::to_string(xid++);
+    auto result = Open(channel_name).first;
+
+    // register callbacks for the answer
+    // TODO(zuza): this is actually pretty bad because if SuccessQueryCreateVertex arrives, then
+    //             FailureQueryCreateVertex never gets unsubscribed. This could cause memory leaks
+    //             in the future (not currently since all callbacks get destroyed when channel is closed).
+    //             The best thing to do is to implement a ThenOnce and Either. Perhaps even a ThenClose.
+    //             An Either in conjunction with a failure detector event stream should eventually fail
+    //             the transaction and close the channel.
+    result->OnEventOnceThenClose<SuccessQueryCreateVertex>(
+        [this, return_channel](const SuccessQueryCreateVertex &) {
+          return_channel->Send<ResultMsg>("success");
+      });
+    result->OnEventOnceThenClose<FailureQueryCreateVertex>(
+        [this, return_channel](const FailureQueryCreateVertex &) {
+          return_channel->Send<ResultMsg>("failure");
+      });
+
+    // instruct worker to make vertex
+    MakeVertex(wmnid, channel_name);
+  }
+
+  /**
+   * Asynchronously creates vertex on the give node.
+   *
+   * @param mnid Id of the node on which vertex should be created.
+   * @param channel_name Name of the channel on which response will arrive.
+   */
+  void MakeVertex(MnidT mnid, std::string channel_name) {
+    MemgraphDistributed::GetInstance().FindChannel(mnid, "worker", "main")
+      ->OnEventOnceThenClose<ChannelResolvedMessage>(
+        [this, channel_name](const ChannelResolvedMessage &msg){
+          msg.channelWriter()->Send<QueryCreateVertex>(channel_name);
+      });
+  }
+
+ protected:
+  // node id
+  const MnidT mnid_;
+
+  // transaction id
+  int64_t xid{0};
+
+  // list of ids of nodes that act as worker
+  std::vector<MnidT> worker_mnids_;
+};
+
+class Worker : public Reactor {
+ public:
+  Worker(std::string name, MnidT mnid)
+      : Reactor(name), mnid_(mnid), storage_(mnid) {}
+
+  virtual void Run() {
+    Distributed &distributed = Distributed::GetInstance();
+
+    std::cout << "Worker (" << mnid_ << ") @ " << distributed.network().Address()
+              << ":" << distributed.network().Port() << std::endl;
+
+    main_.first->OnEvent<QueryCreateVertex>([this](const QueryCreateVertex& msg,
+                                                   const Subscription &) {
+      std::random_device rd; // slow random number generator
+
+      // succeed and fail with 50-50 (just for testing)
+      // TODO: remove random failure
+      if (rd() % 2 == 0) {
+        storage_.MakeVertex();
+        std::cout << "Vertex created" << std::endl;
+        msg.GetReturnChannelWriter()->Send<SuccessQueryCreateVertex>();
+      } else {
+        msg.GetReturnChannelWriter()->Send<FailureQueryCreateVertex>();
+      }
+    });
+
+    main_.first->OnEvent<QueryVertexCount>([this](const QueryVertexCount &msg,
+                                                  const Subscription &){
+      auto count = storage_.VertexCount();
+      msg.GetReturnChannelWriter()->Send<ResultQueryVertexCount>(count);
+    });
+  }
+
+ protected:
+  const MnidT mnid_;
+  ShardedStorage storage_;
+};
+
+int main(int argc, char *argv[]) {
+  gflags::ParseCommandLineFlags(&argc, &argv, /* remove flags from command line */ true);
+  std::string logging_name = std::string(argv[0]) + "-mnid-" + std::to_string(FLAGS_my_mnid);
+  google::InitGoogleLogging(logging_name.c_str());
+
+  System &system = System::GetInstance();
+  Distributed& distributed = Distributed::GetInstance();
+  MemgraphDistributed& memgraph = MemgraphDistributed::GetInstance();
+  memgraph.RegisterConfig(ParseConfig());
+  distributed.StartServices();
+
+  if (FLAGS_my_mnid == memgraph.LeaderMnid()) {
+    system.Spawn<Master>("master", FLAGS_my_mnid);
+  } else {
+    system.Spawn<Worker>("worker", FLAGS_my_mnid);
+  }
+  system.AwaitShutdown();
+  distributed.StopServices();
+
+  return 0;
+}

experimental/distributed/src/graph.hpp

@@ -0,0 +1,164 @@
+#pragma once
+
+#include <cassert>
+#include <unordered_map>
+#include <vector>
+
+#include "uid.hpp"
+
+enum class EdgeType { OUTGOING, INCOMING };
+
+/** A vertex in the graph. Has incoming and outgoing edges which
+ * are defined as global addresses of other vertices */
+class Vertex {
+ public:
+  Vertex(const UniqueVid &id) : id_(id) {}
+
+  const auto &id() const { return id_; };
+  const auto &edges_out() const { return edges_out_; }
+  const auto &edges_in() const { return edges_in_; }
+
+  void AddConnection(EdgeType edge_type, const GlobalVertAddress &gad) {
+    (edge_type == EdgeType::INCOMING ? edges_in_ : edges_out_)
+        .emplace_back(gad);
+  }
+
+  /** Changes all old_address edges to have the new Memgraph node id */
+  void RedirectEdges(const GlobalVertAddress& old_address, int64_t new_mnid) {
+    for (auto &address : edges_in_)
+      if (address == old_address) address.cur_mnid_ = new_mnid;
+    for (auto &address : edges_out_)
+      if (address == old_address) address.cur_mnid_ = new_mnid;
+  }
+
+ private:
+  UniqueVid id_;
+
+  // global addresses of vertices this vertex is connected to
+  std::vector<GlobalVertAddress> edges_out_;
+  std::vector<GlobalVertAddress> edges_in_;
+};
+
+/**
+ * A storage that doesn't assume everything is in-memory.
+ */
+class ShardedStorage {
+ public:
+  // Unique Memgraph node ID. Uniqueness is ensured by the (distributed) system.
+  const int64_t mnid_;
+
+  ShardedStorage(int64_t mnid) : mnid_(mnid) {}
+
+  int64_t VertexCount() const { return vertices_.size(); }
+
+  /** Gets a vertex. */
+  Vertex &GetVertex(const UniqueVid &gid) {
+    auto found = vertices_.find(gid);
+    assert(found != vertices_.end());
+    return found->second;
+  }
+
+  /**
+   * Returns the number of edges that cross from this
+   * node into another one
+   */
+  int64_t BoundaryEdgeCount() const {
+    int64_t count = 0;
+    auto count_f = [this, &count](const auto &edges) {
+      for (const GlobalVertAddress &address : edges)
+        if (address.cur_mnid_ != mnid_) count++;
+    };
+    for (const auto &vertex : vertices_) {
+      count_f(vertex.second.edges_out());
+      count_f(vertex.second.edges_in());
+    }
+
+    return count;
+  }
+
+  /** Creates a new vertex on this node. Returns its global id */
+  const UniqueVid &MakeVertex() {
+    UniqueVid new_id(mnid_, next_vertex_sequence_++);
+    auto new_vertex = vertices_.emplace(std::make_pair(new_id, Vertex(new_id)));
+    return new_vertex.first->first;
+  };
+
+  /** Places the existing vertex on this node */
+  void PlaceVertex(const UniqueVid &gid, const Vertex &vertex) {
+    vertices_.emplace(gid, vertex);
+  }
+
+  /** Removes the vertex with the given ID from this node */
+  void RemoveVertex(const UniqueVid &gid) { vertices_.erase(gid); }
+
+  auto begin() const { return vertices_.begin(); }
+
+  auto end() const { return vertices_.end(); }
+
+ private:
+  // counter of sequences numbers of vertices created on this node
+  int64_t next_vertex_sequence_{0};
+
+  // vertex storage of this node
+  std::unordered_map<UniqueVid, Vertex> vertices_;
+};
+
+/**
+ * A distributed system consisting of mulitple nodes.
+ * For the time being it's not modelling a distributed
+ * system correctly in terms of message passing (as opposed
+ * to operating on nodes and their data directly).
+ */
+class Distributed {
+ public:
+  /** Creates a distributed with the given number of nodes */
+  Distributed(int initial_mnode_count = 0) {
+    for (int mnode_id = 0; mnode_id < initial_mnode_count; mnode_id++)
+      AddMnode();
+  }
+
+  int64_t AddMnode() {
+    int64_t new_mnode_id = mnodes_.size();
+    mnodes_.emplace_back(new_mnode_id);
+    return new_mnode_id;
+  }
+
+  int MnodeCount() const { return mnodes_.size(); }
+
+  auto &GetMnode(int64_t mnode_id) { return mnodes_[mnode_id]; }
+
+  GlobalVertAddress MakeVertex(int64_t mnid) {
+    return {mnid, mnodes_[mnid].MakeVertex()};
+  }
+
+  Vertex &GetVertex(const GlobalVertAddress &address) {
+    return mnodes_[address.cur_mnid_].GetVertex(address.uvid_);
+  }
+
+  /** Moves a vertex with the given global id to the given mnode */
+  void MoveVertex(const GlobalVertAddress &gad, int64_t destination) {
+    const Vertex &vertex = GetVertex(gad);
+
+    // make sure that all edges to and from the vertex are updated
+    for (auto &edge : vertex.edges_in())
+      GetVertex(edge).RedirectEdges(gad, destination);
+    for (auto &edge : vertex.edges_out())
+      GetVertex(edge).RedirectEdges(gad, destination);
+
+    // change vertex destination
+    mnodes_[destination].PlaceVertex(gad.uvid_, vertex);
+    mnodes_[gad.cur_mnid_].RemoveVertex(gad.uvid_);
+  }
+
+  void MakeEdge(const GlobalVertAddress &from, const GlobalVertAddress &to) {
+    GetVertex(from).AddConnection(EdgeType::OUTGOING, to);
+    GetVertex(to).AddConnection(EdgeType::INCOMING, from);
+  }
+
+  auto begin() const { return mnodes_.begin(); }
+
+  auto end() const { return mnodes_.end(); }
+
+ private:
+  std::vector<ShardedStorage> mnodes_;
+};

experimental/distributed/src/memgraph_config.cpp

@@ -0,0 +1,25 @@
+#include "memgraph_config.hpp"
+
+DEFINE_string(config_filename, "", "File containing list of all processes");
+
+Config ParseConfig(const std::string &filename) {
+  std::ifstream file(filename, std::ifstream::in);
+  assert(file.good());
+
+  Config config;
+
+  while (file.good()) {
+    MnidT mnid;
+    std::string address;
+    uint16_t port;
+
+    file >> mnid >> address >> port;
+    if (file.eof())
+      break;
+
+    config.nodes.push_back(Config::NodeConfig{mnid, address, port});
+  }
+
+  file.close();
+  return config;
+}