Added support for additional python decorator timed_read_proc

Co-authored-by: antonio2368 <antonio2368@users.noreply.github.com>
Co-authored-by: Ivan Despot <ivan.g.despot@outlook.com>

.arcconfig

@@ -1,7 +0,0 @@
-{
-  "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,9 +1,10 @@
 ---
 Language:     Cpp
 BasedOnStyle: Google
-Standard:     "C++11"
+Standard:     "c++20"
 UseTab:       Never
 DerivePointerAlignment: false
 PointerAlignment: Right
-ColumnLimit : 80
+ColumnLimit : 120
+IncludeBlocks: Preserve
 ...

.clang-tidy

@@ -0,0 +1,88 @@
+---
+Checks: '*,
+         -abseil-string-find-str-contains,
+         -altera-struct-pack-align,
+         -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-*,
+         -google-runtime-references,
+         -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-use-nullptr,
+         -hicpp-vararg,
+         -llvm-header-guard,
+         -llvm-include-order,
+         -llvmlibc-callee-namespace,
+         -llvmlibc-implementation-in-namespace,
+         -llvmlibc-restrict-system-libc-headers,
+         -misc-non-private-member-variables-in-classes,
+         -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-function-cognitive-complexity,
+         -readability-implicit-bool-conversion,
+         -readability-magic-numbers,
+         -readability-named-parameter,
+         -misc-no-recursion'
+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

@@ -0,0 +1,43 @@
+#!/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
+
+  echo "Running header checker..."
+  $project_folder/tools/header-checker.py $tmpdir/$file
+  code=$?
+
+  if [ $code -ne 0 ]; then
+    break
+  fi
+done;
+
+return $code

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,34 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[BUG] "
+labels: bug
+assignees: gitbuda, antonio2368
+
+---
+
+
+**Memgraph version**
+Which version did you use?
+
+**Environment**
+Some information about the environment you are using Memgraph on: operating
+system, how do you connect, with or without docker, which driver etc.
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Run the following query '...'
+2. Click on '....'
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Logs**
+If applicable, add logs of Memgraph, CLI output or screenshots to help explain
+your problem.
+
+**Additional context**
+Add any other context about the problem here.

.github/pull_request_template.md

@@ -0,0 +1,9 @@
+[master < Epic] PR
+- [ ] Check, and update documentation if necessary
+- [ ] Update [changelog](https://docs.memgraph.com/memgraph/changelog)
+- [ ] Write E2E tests
+- [ ] Compare the [benchmarking results](https://bench-graph.memgraph.com/) between the master branch and the Epic branch
+
+[master < Task] PR
+- [ ] Check, and update documentation if necessary
+- [ ] Update [changelog](https://docs.memgraph.com/memgraph/changelog)

.github/workflows/daily_banchmark.yaml

@@ -0,0 +1,70 @@
+name: Daily Benchmark
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 1 * * *"
+
+jobs:
+  release_benchmarks:
+    name: "Release benchmarks"
+    runs-on: [self-hosted, Linux, X64, Diff, Gen7]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Build only memgraph release binaries.
+          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/diff.yaml

@@ -0,0 +1,402 @@
+name: Diff
+
+on:
+  workflow_dispatch:
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+      - '.clang-format'
+      - 'CODEOWNERS'
+
+jobs:
+  community_build:
+    name: "Community build"
+    runs-on: [self-hosted, Linux, X64, Diff]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/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-v3/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure -j$THREADS
+
+  code_analysis:
+    name: "Code analysis"
+    runs-on: [self-hosted, Linux, X64, Diff]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/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-v3/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-v3/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-v3/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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Build debug binaries.
+          cd build
+          cmake ..
+          make -j$THREADS
+
+      - name: Run leftover CTest tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v3/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-v3/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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/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 unit tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v3/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure -j$THREADS
+
+      - name: Run e2e 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-root-directory .
+
+      - 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-v3/activate
+
+          cd build
+
+          # create mgconsole
+          # we use the -B to force the build
+          make -j$THREADS -B mgconsole
+
+          # Create enterprise DEB package.
+          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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Build only memgraph release binaries.
+          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

@@ -0,0 +1,46 @@
+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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Build debug binaries.
+
+          cd build
+          cmake ..
+          make -j$THREADS
+
+      - name: Run clang-tidy
+        run: |
+          source /opt/toolchain-v3/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-v3/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

@@ -0,0 +1,161 @@
+name: Package All
+
+# TODO(gitbuda): Cleanup docker container if GHA job was canceled.
+
+on: workflow_dispatch
+
+jobs:
+  centos-7:
+    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 centos-7
+      - name: "Upload package"
+        uses: actions/upload-artifact@v2
+        with:
+          name: centos-7
+          path: build/output/centos-7/memgraph*.rpm
+
+  centos-8:
+    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 centos-8
+      - name: "Upload package"
+        uses: actions/upload-artifact@v2
+        with:
+          name: centos-8
+          path: build/output/centos-8/memgraph*.rpm
+
+  debian-9:
+    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 debian-9
+      - name: "Upload package"
+        uses: actions/upload-artifact@v2
+        with:
+          name: debian-9
+          path: build/output/debian-9/memgraph*.deb
+
+  debian-10:
+    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 debian-10
+      - name: "Upload package"
+        uses: actions/upload-artifact@v2
+        with:
+          name: debian-10
+          path: build/output/debian-10/memgraph*.deb
+
+  debian-11:
+    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 debian-11
+      - name: "Upload package"
+        uses: actions/upload-artifact@v2
+        with:
+          name: debian-11
+          path: build/output/debian-11/memgraph*.deb
+
+  docker:
+    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 debian-10 --for-docker
+          ./run.sh docker
+      - name: "Upload package"
+        uses: actions/upload-artifact@v2
+        with:
+          name: docker
+          path: build/output/docker/memgraph*.tar.gz
+
+  ubuntu-1804:
+    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 ubuntu-18.04
+      - name: "Upload package"
+        uses: actions/upload-artifact@v2
+        with:
+          name: ubuntu-1804
+          path: build/output/ubuntu-18.04/memgraph*.deb
+
+  ubuntu-2004:
+    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 ubuntu-20.04
+      - name: "Upload package"
+        uses: actions/upload-artifact@v2
+        with:
+          name: ubuntu-2004
+          path: build/output/ubuntu-20.04/memgraph*.deb
+
+  debian-10-platform:
+    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 debian-10 --for-platform
+      - name: "Upload package"
+        uses: actions/upload-artifact@v2
+        with:
+          name: debian-10-platform
+          path: build/output/debian-10/memgraph*.deb

.github/workflows/release_centos8.yaml

@@ -0,0 +1,315 @@
+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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    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-v3/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-v3/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure
+
+  coverage_build:
+    name: "Coverage build"
+    runs-on: [self-hosted, Linux, X64, CentOS8]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/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-v3/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure
+
+      - name: Compute code coverage
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v3/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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Build debug binaries.
+          cd build
+          cmake ..
+          make -j$THREADS
+
+      - name: Run leftover CTest tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v3/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-v3/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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    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-v3/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-v3/activate
+
+          cd build
+
+          # create mgconsole
+          # we use the -B to force the build
+          make -j$THREADS -B mgconsole
+
+          # Create enterprise RPM package.
+          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-v3/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 unit tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v3/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure
+
+      - name: Run e2e 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-root-directory .
+
+      - 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

@@ -0,0 +1,356 @@
+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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    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-v3/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-v3/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure
+
+  coverage_build:
+    name: "Coverage build"
+    runs-on: [self-hosted, Linux, X64, Debian10]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/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-v3/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure
+
+      - name: Compute code coverage
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v3/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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Build debug binaries.
+          cd build
+          cmake ..
+          make -j$THREADS
+
+      - name: Run leftover CTest tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v3/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-v3/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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    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-v3/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-v3/activate
+
+          cd build
+
+          # create mgconsole
+          # we use the -B to force the build
+          make -j$THREADS -B mgconsole
+
+          # Create enterprise DEB package.
+          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-v3/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 unit tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v3/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure
+
+      - name: Run e2e 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-root-directory .
+
+      - 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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    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-v3/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

@@ -0,0 +1,314 @@
+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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    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-v3/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-v3/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure
+
+  coverage_build:
+    name: "Coverage build"
+    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/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-v3/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure
+
+      - name: Compute code coverage
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v3/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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    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-v3/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Build debug binaries.
+          cd build
+          cmake ..
+          make -j$THREADS
+
+      - name: Run leftover CTest tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v3/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-v3/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
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    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-v3/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-v3/activate
+
+          cd build
+
+          # create mgconsole
+          # we use the -B to force the build
+          make -j$THREADS -B mgconsole
+
+          # Create enterprise DEB package.
+          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-v3/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 unit tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v3/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure
+
+      - name: Run e2e 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-root-directory .
+
+      - 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

@@ -29,3 +29,40 @@ ve3/
 perf.data*
 TAGS
 *.apollo_measurements
+
+# Lisp compiled object code
+*.fas
+*.fasl
+
+# LCP generated C++ files
+*.lcp.cpp
+
+src/database/distributed/serialization.hpp
+src/database/single_node_ha/serialization.hpp
+src/distributed/bfs_rpc_messages.hpp
+src/distributed/coordination_rpc_messages.hpp
+src/distributed/data_rpc_messages.hpp
+src/distributed/durability_rpc_messages.hpp
+src/distributed/dynamic_worker_rpc_messages.hpp
+src/distributed/index_rpc_messages.hpp
+src/distributed/plan_rpc_messages.hpp
+src/distributed/pull_produce_rpc_messages.hpp
+src/distributed/storage_gc_rpc_messages.hpp
+src/distributed/token_sharing_rpc_messages.hpp
+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.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.hpp
+src/storage/distributed/rpc/concurrent_id_mapper_rpc_messages.hpp
+src/transactions/distributed/engine_rpc_messages.hpp

.ycm_extra_conf.py

@@ -1,168 +0,0 @@
-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./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,148 +1,5 @@
-# Change Log
+Change Log for all versions of Memgraph can be found on-line at
+https://docs.memgraph.com/memgraph/changelog
 
-## v0.10.0
-
-### Breaking Changes
-
-* Snapshot format changed (not backward compatible).
-
-### Major Features and Improvements
-
-* [Enterprise Ed.] Distributed storage and execution
-* `reduce` and `single` functions added to openCypher.
-* `wShortest` edge expansion added to openCypher.
-* Support packaging RPM on CentOS 7.
-
-### Bug Fixes and Other Changes
-
-* Report an error if updating a deleted element.
-* Log an error if reading info on available memory fails.
-* Fix a bug when `MATCH` would stop matching if a result was empty, but later
-  results still contain data to be matched. The simplest case of this was the
-  query: `UNWIND [1,2,3] AS x MATCH (n :Label {prop: x}) RETURN n`. If there
-  was no node `(:Label {prop: 1})`, then the `MATCH` wouldn't even try to find
-  for `x` being 2 or 3.
-* Report an error if trying to compare a property value with something that
-  cannot be stored in a property.
-* Fix crashes in some obscure cases.
-* Add minor performance improvements.
-
-## v0.9.0
-
-### Breaking Changes
-
-* Snapshot format changed (not backward compatible).
-* Snapshot configuration flags changed, general durability flags added.
-
-### Major Features and Improvements
-
-* Write-ahead log added.
-* `nodes` and `relationships` functions added.
-* `UNION` and `UNION ALL` is implemented.
-* Concurrent index creation is now enabled.
-
-### Bug Fixes and Other Changes
-
-
-## v0.8.0
-
-### Major Features and Improvements
-
-* CASE construct (without aggregations).
-* Named path support added.
-* Maps can now be stored as vertex/edge properties.
-* Map indexing supported.
-* `rand` function added.
-* `assert` function added.
-* `counter` and `counterSet` functions added.
-* `indexInfo` function added.
-* `collect` aggregation now supports Map collection.
-* Changed the BFS syntax.
-
-### Bug Fixes and Other Changes
-
-* Use \u to specify 4 digit codepoint and \U for 8 digit
-* Keywords appearing in header (named expressions) keep original case.
-* Our Bolt protocol implementation is now completely compatible with the protocol version 1 specification. (https://boltprotocol.org/v1/)
-* Added a log warning when running out of memory and the `memory_warning_threshold` flag
-* Edges are no longer additionally filtered after expansion.
-
-## v0.7.0
-
-### Major Features and Improvements
-
-* Variable length path `MATCH`.
-* Explicitly started transactions (multi-query transactions).
-* Map literal.
-* Query parameters (except for parameters in place of property maps).
-* `all` function in openCypher.
-* `degree` function in openCypher.
-* User specified transaction execution timeout.
-
-### Bug Fixes and Other Changes
-
-* Concurrent `BUILD INDEX` deadlock now returns an error to the client.
-* A `MATCH` preceeded by `OPTIONAL MATCH` expansion inconsistencies.
-* High concurrency Antlr parsing bug.
-* Indexing improvements.
-* Query stripping and caching speedups.
-
-## v0.6.0
-
-### Major Features and Improvements
-
-* AST caching.
-* Label + property index support.
-* Different logging setup & format.
-
-## v0.5.0
-
-### Major Features and Improvements
-
-* Use label indexes to speed up querying.
-* Generate multiple query plans and use the cost estimator to select the best.
-* Snapshots & Recovery.
-* Abandon old yaml configuration and migrate to gflags.
-* Query stripping & AST caching support.
-
-### Bug Fixes and Other Changes
-
-* Fixed race condition in MVCC. Hints exp+aborted race condition prevented.
-* Fixed conceptual bug in MVCC GC. Evaluate old records w.r.t. the oldest.
-  transaction's id AND snapshot.
-* User friendly error messages thrown from the query engine.
-
-## Build 837
-
-### Bug Fixes and Other Changes
-
-* List indexing supported with preceeding IN (for example in query `RETURN 1 IN [[1,2]][0]`).
-
-## Build 825
-
-### Major Features and Improvements
-
-* RETURN *, count(*), OPTIONAL MATCH, UNWIND, DISTINCT (except DISTINCT in aggregate functions), list indexing and slicing, escaped labels, IN LIST operator, range function.
-
-### Bug Fixes and Other Changes
-
-* TCP_NODELAY -> import should be faster.
-* Clear hint bits.
-
-## Build 783
-
-### Major Features and Improvements
-
-* SKIP, LIMIT, ORDER BY.
-* Math functions.
-* Initial support for MERGE clause.
-
-### Bug Fixes and Other Changes
-
-* Unhandled Lock Timeout Exception.
-
-## Build 755
-
-### Major Features and Improvements
-
-* MATCH, CREATE, WHERE, SET, REMOVE, DELETE.
+All the updates to the Change Log can be made in the following repository:
+https://github.com/memgraph/docs

CMakeLists.txt

@@ -1,6 +1,6 @@
 # MemGraph CMake configuration
 
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.8)
 
 # !! IMPORTANT !! run ./project_root/init.sh before cmake command
 # to download dependencies
@@ -31,18 +31,129 @@ 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()
 
-# Get current commit hash.
-execute_process(
-    OUTPUT_VARIABLE COMMIT_HASH
-    COMMAND git rev-parse --short HEAD
-)
-string(STRIP ${COMMIT_HASH} COMMIT_HASH)
-
 # -----------------------------------------------------------------------------
 
-project(memgraph VERSION 0.9.0)
+project(memgraph)
+
+# Install licenses.
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/licenses/
+        DESTINATION share/doc/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 "2.0.1")
+
+# 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_offering "")
+else()
+  set(get_version_offering "--open-source")
+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_offering}
+                "${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_offering}
+                --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_offering}
+                --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()
+
 # -----------------------------------------------------------------------------
 
 # setup CMake module path, defines path for include() and find_package()
@@ -62,21 +173,27 @@ add_custom_target(clean_all
 
 # build flags -----------------------------------------------------------------
 
-# 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")
+# 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")
 
 # 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-7.3, we are using gcc-6.3 on build machines (license is
-# valid there also).
+# Last checked for gcc-10.2 which we are using on the build machines.
 # ** 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++")
@@ -102,13 +219,6 @@ 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
@@ -122,11 +232,6 @@ 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)
@@ -137,55 +242,16 @@ if (USE_READLINE)
   endif()
 endif()
 
-set(Boost_USE_STATIC_LIBS ON)
-find_package(Boost 1.62 REQUIRED COMPONENTS iostreams serialization)
-
 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})
-# -----------------------------------------------------------------------------
-
-# 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)
 
 if (TEST_COVERAGE)
   string(TOLOWER ${CMAKE_BUILD_TYPE} lower_build_type)
@@ -196,21 +262,74 @@ 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()
+
+set(ENABLE_JEMALLOC ON)
+
+if (ASAN)
+  message(WARNING "Disabling jemalloc as it doesn't work well with ASAN")
+  set(ENABLE_JEMALLOC OFF)
+  # Enable Addres sanitizer and get nicer stack traces in error messages.
+  # NOTE: AddressSanitizer uses llvm-symbolizer binary from the Clang
+  # distribution to symbolize the stack traces (note that ideally the
+  # llvm-symbolizer version must match the version of ASan runtime library).
+  # Just make sure llvm-symbolizer is in PATH before running the binary or
+  # provide it in separate ASAN_SYMBOLIZER_PATH environment variable.
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
+  # To detect Stack-use-after-return bugs set run-time flag:
+  #   ASAN_OPTIONS=detect_stack_use_after_return=1
+  # To check initialization order bugs set run-time flag:
+  #   ASAN_OPTIONS=check_initialization_order=true
+  #     This mode reports an error if initializer for a global variable accesses
+  #     dynamically initialized global from another translation unit, which is
+  #     not yet initialized
+  #   ASAN_OPTIONS=strict_init_order=true
+  #     This mode reports an error if initializer for a global variable accesses
+  #     any dynamically initialized global from another translation unit.
+endif()
+
+if (TSAN)
+  # ThreadSanitizer generally requires all code to be compiled with -fsanitize=thread.
+  # If some code (e.g. dynamic libraries) is not compiled with the flag, it can
+  # lead to false positive race reports, false negative race reports and/or
+  # missed stack frames in reports depending on the nature of non-instrumented
+  # code. To not produce false positive reports ThreadSanitizer has to see all
+  # synchronization in the program, some synchronization operations (namely,
+  # atomic operations and thread-safe static initialization) are intercepted
+  # during compilation (and can only be intercepted during compilation).
+  # ThreadSanitizer stack trace collection also relies on compiler instrumentation
+  # (unwinding stack on each memory access is too expensive).
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=thread")
+  # By default ThreadSanitizer uses addr2line utility to symbolize reports.
+  # llvm-symbolizer is faster, consumes less memory and produces much better
+  # reports. To use it set runtime flag:
+  #   TSAN_OPTIONS="extern-symbolizer-path=~/llvm-symbolizer"
+  # For more runtime flags see: https://github.com/google/sanitizers/wiki/ThreadSanitizerFlags
+endif()
+
+if (UBSAN)
+  # Compile with UBSAN but disable vptr check. This is disabled because it
+  # requires linking with clang++ to make sure C++ specific parts of the
+  # 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.
+endif()
+
+set(MG_PYTHON_VERSION "" CACHE STRING "Specify the exact python version used by the query modules")
+
 # Add subprojects
 include_directories(src)
 add_subdirectory(src)
 
-if(POC)
-  add_subdirectory(poc)
-endif()
-
-if(EXPERIMENTAL)
-  add_subdirectory(experimental)
-endif()
-
-if(CUSTOMERS)
-  add_subdirectory(customers)
-endif()
+# Release configuration
+add_subdirectory(release)
 
 enable_testing()
 add_subdirectory(tests)
@@ -219,52 +338,10 @@ 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.")
-
-# RPM specific
-set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION /var /var/lib /var/log /etc/logrotate.d /lib /lib/systemd /lib/systemd/system)
-set(CPACK_RPM_PACKAGE_REQUIRES_PRE "shadow-utils,systemd")
-# set(CPACK_RPM_USER_BINARY_SPECFILE "${CMAKE_SOURCE_DIR}/release/rpm/memgraph.spec.in")
-set(CPACK_RPM_PRE_INSTALL_SCRIPT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/release/rpm/preinst")
-set(CPACK_RPM_POST_INSTALL_SCRIPT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/release/rpm/postinst")
-set(CPACK_RPM_PRE_UNINSTALL_SCRIPT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/release/rpm/prerm")
-# 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.")
-
-# All variables must be set before including.
-include(CPack)
-# ---- End Setup CPack ----
+install(FILES ${CMAKE_BINARY_DIR}/bin/mgconsole
+  PERMISSIONS OWNER_EXECUTE OWNER_READ OWNER_WRITE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
+  TYPE BIN)

CODEOWNERS

@@ -0,0 +1 @@
+* @gitbuda @antonio2368 @antaljanosbenjamin @kostasrim @jbajic

CODE_OF_CONDUCT.md

@@ -0,0 +1,127 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+- Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+- The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing other's private information, such as a physical or email address,
+  without their explicit permission
+- Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[contact@memgraph.com](contact@memgraph.com). All complaints will be reviewed
+and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the Contributor Covenant, version 2.1,
+available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html](https://www.contributor-covenant.org/version/2/1/code_of_conduct.html).
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder][mozilla coc].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq](https://www.contributor-covenant.org/faq).
+Translations are available at
+[https://www.contributor-covenant.org/translations](https://www.contributor-covenant.org/translations).

CONTRIBUTING.md

@@ -0,0 +1,121 @@
+# How to contribute?
+
+This is a general purpose guide for contributing to Memgraph. We're still
+working out the kinks to make contributing to this project as easy and
+transparent as possible, but we're not quite there yet. Hopefully, this document
+makes the process for contributing clear and answers some questions that you may
+have.
+
+- [How to contribute?](#how-to-contribute)
+  - [Open development](#open-development)
+  - [Branch organization](#branch-organization)
+  - [Bugs & changes](#bugs--changes)
+    - [Where to find known issues?](#where-to-find-known-issues)
+    - [Proposing a change](#proposing-a-change)
+    - [Your first pull request](#your-first-pull-request)
+    - [Sending a pull request](#sending-a-pull-request)
+    - [Style guide](#style-guide)
+  - [How to get in touch?](#how-to-get-in-touch)
+  - [Code of Conduct](#code-of-conduct)
+  - [License](#license)
+  - [Attribution](#attribution)
+
+## Open development
+
+All work on Memgraph is done via [GitHub](https://github.com/memgraph/memgraph).
+Both core team members and external contributors send pull requests which go
+through the same review process.
+
+## Branch organization
+
+Most pull requests should target the [`master
+branch`](https://github.com/memgraph/memgraph/tree/master). We only use separate
+branches for developing new features and fixing bugs before they are merged with
+`master`. We do our best to keep `master` in good shape, with all tests passing.
+
+Code that lands in `master` must be compatible with the latest stable release.
+It may contain additional features but no breaking changes if it's not
+absolutely necessary. We should be able to release a new minor version from the
+tip of `master` at any time.
+
+## Bugs & changes
+
+### Where to find known issues?
+
+We are using [GitHub Issues](https://github.com/memgraph/memgraph/issues) for
+our public bugs. We keep a close eye on this and try to make it clear when we
+have an internal fix in progress. Before filing a new task, try to make sure
+your problem doesn't already exist.
+
+### Proposing a change
+
+If you intend to change the public API, or make any non-trivial changes to the
+implementation, we recommend [filing an
+issue](https://github.com/memgraph/memgraph/issues/new). This lets us reach an
+agreement on your proposal before you put significant effort into it.
+
+If you're only fixing a bug, it's fine to submit a pull request right away but
+we still recommend to file an issue detailing what you're fixing. This is
+helpful in case we don't accept that specific fix but want to keep track of the
+issue.
+
+### Your first pull request
+
+Working on your first Pull Request? You can learn how from this free video
+series:
+
+**[How to Contribute to an Open Source Project on
+GitHub](https://app.egghead.io/courses/how-to-contribute-to-an-open-source-project-on-github)**
+
+If you decide to fix an issue, please be sure to check the comment thread in
+case somebody is already working on a fix. If nobody is working on it at the
+moment, please leave a comment stating that you intend to work on it so other
+people don't accidentally duplicate your effort.
+
+If somebody claims an issue but doesn't follow up for more than two weeks, it's
+fine to take it over but you should still leave a comment.
+
+### Sending a pull request
+
+The core team is monitoring for pull requests. We will review your pull request
+and either merge it, request changes to it, or close it with an explanation.
+**Before submitting a pull request,** please make sure the following is done:
+
+1. Fork [the repository](https://github.com/memgraph/memgraph) and create your
+   branch from `master`.
+2. If you've fixed a bug or added code that should be tested, add tests!
+3. Use the formatter `clang-format` for C/C++ code and `flake8` for Python code.
+   `clang-format` will automatically detect the `.clang-format` file in the root
+   directory while `flake8` can be used with the default configuration.
+
+### Style guide
+
+Memgraph uses the [Google Style
+Guide](https://google.github.io/styleguide/cppguide.html) for C++ in most of its
+code. You should follow them whenever writing new code.
+
+## How to get in touch?
+
+Aside from communicating directly via Pull Requests and Issues, the Memgraph
+Community [Discord Server](https://discord.gg/memgraph) is the best place for
+conversing with project maintainers and other community members.
+
+## [Code of Conduct](https://github.com/memgraph/memgraph/blob/master/CODE_OF_CONDUCT.md)
+
+Memgraph has adopted the [Contributor
+Covenant](https://www.contributor-covenant.org/) as its Code of Conduct, and we
+expect project participants to adhere to it. Please read [the full
+text](https://github.com/memgraph/memgraph/blob/master/CODE_OF_CONDUCT.md) so
+that you can understand what actions will and will not be tolerated.
+
+## License
+
+By contributing to Memgraph, you agree that your contributions will be licensed
+under the [Memgraph licensing
+scheme](https://github.com/memgraph/memgraph/blob/master/LICENSE).
+
+## Attribution
+
+This Contributing guide is adapted from the **React.js Contributing guide**
+available at
+[https://reactjs.org/docs/how-to-contribute.html](https://reactjs.org/docs/how-to-contribute.html).

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           = Doxylogo.png
+PROJECT_LOGO           = docs/doxygen/memgraph_logo.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,7 +839,6 @@ 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

LICENSE

@@ -0,0 +1,5 @@
+Source code in this repository is variously licensed under the Business Source
+License 1.1 (BSL), the Memgraph Enterprise License (MEL). A copy of each licence
+can be found in the licences directory. Source code in a given file is licensed
+under the BSL and the copyright belongs to The Memgraph Authors unless
+otherwise noted at th beginning of the file.

README.md

@@ -1,24 +1,128 @@
-# memgraph
+<p align="center">
+<img width="400px" src="https://uploads-ssl.webflow.com/5e7ceb09657a69bdab054b3a/5e7ceb09657a6937ab054bba_Black_Original%20_Logo.png">
+</p>
 
-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.
+---
 
-## dependencies
+<p align="center">
+Build modern, graph-based applications on top of your streaming data in minutes.
+</p>
 
-Memgraph can be compiled using any modern c++ compiler. It mostly relies on
-the standard template library, however, some things do require external
-libraries.
+<p align="center">
+  <a href="https://github.com/memgraph/memgraph/blob/master/licenses/APL.txt">
+    <img src="https://img.shields.io/badge/license-APL-green" alt="license" title="license"/>
+  </a>
+  <a href="https://github.com/memgraph/memgraph/blob/master/licenses/BSL.txt">
+    <img src="https://img.shields.io/badge/license-BSL-yellowgreen" alt="license" title="license"/>
+  </a>
+  <a href="https://github.com/memgraph/memgraph/blob/master/licenses/MEL.txt" alt="Documentation">
+    <img src="https://img.shields.io/badge/license-MEL-yellow" alt="license" title="license"/>
+  </a>
+</p>
 
-Some code contains linux-specific libraries and the build is only supported
-on a 64 bit linux kernel.
+<p align="center">
+  <a href="https://github.com/memgraph/memgraph">
+    <img src="https://img.shields.io/github/workflow/status/memgraph/memgraph/Release%20Ubuntu%2020.04/master" alt="build" title="build"/>
+  </a>
+  <a href="https://memgraph.com/docs/" alt="Documentation">
+    <img src="https://img.shields.io/badge/documentation-Memgraph-orange" />
+  </a>
+</p>
 
-* linux
-* clang 3.8 (good c++11 support, especially lock free atomics)
-* antlr (compiler frontend)
-* cppitertools
-* fmt format
-* google benchmark
-* google test
-* glog
-* gflags
+<p align="center">
+  <a href="https://memgr.ph/join-discord">
+    <img src="https://img.shields.io/badge/Discord-7289DA?style=for-the-badge&logo=discord&logoColor=white" alt="Discord"/>
+  </a>
+</p>
+
+## :clipboard: Description
+
+Memgraph is a streaming graph application platform that helps you wrangle your
+streaming data, build sophisticated models that you can query in real-time, and
+develop graph applications.
+
+Memgraph directly connects to your streaming infrastructure. You can ingest data
+from sources like Kafka, SQL, or plain CSV files. Memgraph provides a standard
+interface to query your data with Cypher, a widely-used and declarative query
+language that is easy to write, understand and optimize for performance. This is
+achieved by using the property graph data model, which stores data in terms of
+objects, their attributes, and the relationships that connect them. This is a
+natural and effective way to model many real-world problems without relying on
+complex SQL schemas.
+
+Memgraph is implemented in C/C++ and leverages an in-memory first architecture
+to ensure that you’re getting the best possible performance consistently and
+without surprises. It’s also ACID-compliant and highly available.
+
+## :floppy_disk: Download & Install
+
+### Windows
+
+[![Windows](https://img.shields.io/badge/Windows-Docker-0078D6?style=for-the-badge&logo=windows&logoColor=white)](https://memgraph.com/docs/memgraph/install-memgraph-on-windows-docker)
+[![Windows](https://img.shields.io/badge/Windows-WSL-0078D6?style=for-the-badge&logo=windows&logoColor=white)](https://memgraph.com/docs/memgraph/install-memgraph-on-windows-wsl)
+
+### macOS
+
+[![macOS](https://img.shields.io/badge/macOS-Docker-000000?style=for-the-badge&logo=macos&logoColor=F0F0F0)](https://memgraph.com/docs/memgraph/install-memgraph-on-macos-docker)
+
+### Linux
+
+[![Linux](https://img.shields.io/badge/Linux-Docker-FCC624?style=for-the-badge&logo=linux&logoColor=black)](https://memgraph.com/docs/memgraph/install-memgraph-on-linux-docker)
+[![Debian](https://img.shields.io/badge/Debian-D70A53?style=for-the-badge&logo=debian&logoColor=white)](https://memgraph.com/docs/memgraph/install-memgraph-on-debian)
+[![Ubuntu](https://img.shields.io/badge/Ubuntu-E95420?style=for-the-badge&logo=ubuntu&logoColor=white)](https://memgraph.com/docs/memgraph/install-memgraph-on-ubuntu)
+[![Cent
+OS](https://img.shields.io/badge/cent%20os-002260?style=for-the-badge&logo=centos&logoColor=F0F0F0)](https://memgraph.com/docs/memgraph/install-memgraph-from-rpm)
+
+You can find the binaries and Docker images on the [Download
+Hub](https://memgraph.com/download) and the installation instructions in the
+[official documentation](https://memgraph.com/docs/memgraph/installation).
+
+## :zap: Features
+
+- Run Python, Rust, and C/C++ code natively, check out the
+  [MAGE](https://github.com/memgraph/mage) graph algorithm library
+- Native support for machine learning
+- Streaming support
+- Replication
+- Authentication and authorization
+- ACID compliance
+
+## :bookmark_tabs: Documentation
+
+The Memgraph documentation is available at
+[memgraph.com/docs](https://memgraph.com/docs).
+
+## :question: Configuration
+
+Command line options that Memgraph accepts are available in the [reference
+guide](https://memgraph.com/docs/memgraph/reference-guide/configuration).
+
+## :trophy: Contributing
+
+The main purpose of this repository is to continue evolving Memgraph, making it
+faster and easier to use. Development of Memgraph happens in the open on GitHub,
+and we are grateful to the community for contributing bug fixes and
+improvements. Read below to learn how you can take part in improving Memgraph.
+
+### Code of Conduct
+
+Memgraph has adopted a Code of Conduct that we expect project participants to
+adhere to. Please read [the full text](CODE_OF_CONDUCT.md) so that you can
+understand what actions will and will not be tolerated.
+
+### Contributing Guide
+
+Read our [contributing guide](CONTRIBUTING.md) to learn about our development
+process and how to propose bug fixes and improvements.
+
+### :scroll: License
+
+Memgraph Community is available under the [BSL
+license](./licenses/BSL.txt).</br> Memgraph Enterprise is available under the
+[MEL license](./licenses/MEL.txt).
+
+<p align="center">
+  <a href="#">
+    <img src="https://img.shields.io/badge/⬆️back_to_top_⬆️-white" alt="Back to top" title="Back to top"/>
+  </a>
+</p>

apollo_archives.py

@@ -1,39 +0,0 @@
-#!/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

@@ -1,20 +0,0 @@
-- name: Binaries
-  archive:
-    - build_debug/memgraph
-    - build_release/memgraph
-    - build_release/tools/src/mg_import_csv
-    - build_release/tools/src/mg_statsd
-    - 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

@@ -1,94 +0,0 @@
-- 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=600 ./init
-    doxygen Doxyfile
-
-    # Remove default build directory.
-    rm -r build
-
-    # Build debug binaries.
-    mkdir build_debug
-    cd build_debug
-    cmake ..
-    TIMEOUT=1000 make -j$THREADS
-
-    # Build coverage binaries.
-    cd ..
-    mkdir build_coverage
-    cd build_coverage
-    cmake -DTEST_COVERAGE=ON ..
-    TIMEOUT=1000 make -j$THREADS memgraph__unit
-
-    # Build release binaries.
-    cd ..
-    mkdir build_release
-    cd build_release
-    cmake -DCMAKE_BUILD_TYPE=release ..
-    TIMEOUT=1000 make -j$THREADS memgraph tools memgraph__macro_benchmark memgraph__stress memgraph__manual__card_fraud_generate_snapshot
-
-    # Generate distributed card fraud dataset.
-    cd ../tests/distributed/card_fraud
-    ./generate_dataset.sh
-    cd ../../..
-
-    # Checkout to parent commit and initialize.
-    cd ../parent
-    git checkout HEAD~1
-    TIMEOUT=600 ./init
-
-    # Build parent release binaries.
-    mkdir build_release
-    cd build_release
-    cmake -DCMAKE_BUILD_TYPE=release ..
-    TIMEOUT=1000 make -j$THREADS memgraph memgraph__macro_benchmark
-
-
-# release build is the default one
-- name: Release build
-  commands: |
-    TIMEOUT=600 ./init
-    doxygen Doxyfile
-
-    # Remove default build directory.
-    rm -r build
-
-    # Build debug binaries.
-    mkdir build_debug
-    cd build_debug
-    cmake ..
-    TIMEOUT=1000 make -j$THREADS
-
-    # Build coverage binaries.
-    cd ..
-    mkdir build_coverage
-    cd build_coverage
-    cmake -DTEST_COVERAGE=ON ..
-    TIMEOUT=1000 make -j$THREADS memgraph__unit
-
-    # Build release binaries.
-    cd ..
-    mkdir build_release
-    cd build_release
-    cmake -DCMAKE_BUILD_TYPE=Release -DUSE_READLINE=OFF ..
-    TIMEOUT=1000 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
-
-    # Generate distributed card fraud dataset.
-    cd ../../tests/distributed/card_fraud
-    ./generate_dataset.sh

cmake/FindSeccomp.cmake

@@ -0,0 +1,90 @@
+#.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

@@ -1,19 +0,0 @@
-# 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

@@ -1,93 +0,0 @@
-# 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
-
-# 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
-
-## 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/flags.yaml

@@ -0,0 +1,105 @@
+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
+
+  - name: "isolation_level"
+    value: "SNAPSHOT_ISOLATION"
+    override: true
+
+  - name: "allow_load_csv"
+    value: "true"
+    override: false
+
+undocumented:
+  - "flag_file"
+  - "also_log_to_stderr"
+  - "help"
+  - "help_xml"
+  - "version"
+  - "organization_name"
+  - "license_key"

config/generate.py

@@ -0,0 +1,124 @@
+#!/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

@@ -1,15 +0,0 @@
-# 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

@@ -1,9 +0,0 @@
-# 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

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

customers/elliott/README_internal.md

@@ -1,70 +0,0 @@
-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

@@ -1,71 +0,0 @@
----
-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

@@ -1,12 +0,0 @@
-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

@@ -1,125 +0,0 @@
-#!/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

@@ -1,39 +0,0 @@
-{
-    "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

@@ -1,39 +0,0 @@
-{
-    "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

@@ -1,39 +0,0 @@
-{
-    "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

@@ -1,3 +0,0 @@
-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

@@ -1,118 +0,0 @@
-#!/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

@@ -1,207 +0,0 @@
-#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

@@ -1,5 +0,0 @@
-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

@@ -1,31 +0,0 @@
-{
-   "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

@@ -1,20 +0,0 @@
-{
-  "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,6 +1,2 @@
 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

@@ -1,193 +0,0 @@
-# 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/quick-start.md

@@ -1,78 +0,0 @@
-# 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/workflow.md

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

docs/user_technical/README.md

@@ -1,22 +0,0 @@
-# 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)
-  * [Storable Data Types](data-types.md)
-  * [openCypher Query Language](open-cypher.md)
-  * [Import Tools](import-tools.md)
-  * [Upcoming Features](upcoming-features.md)
-
-[//]: # (Nothing should go below the contents section)

docs/user_technical/bundle_community

@@ -1,58 +0,0 @@
-#!/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/couscous.yml

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

docs/user_technical/data-types.md

@@ -1,47 +0,0 @@
-## 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:
-
-    CREATE (:Node {property: [1, 2, 3]})
-    CREATE (:Node {property: {key: "value"}})
-
-However, these queries are not:
-
-    MATCH (n:Node) SET n.property[0] = 0
-    MATCH (n:Node) SET n.property.key = "other value"

docs/user_technical/drivers.md

@@ -1,205 +0,0 @@
-## Bolt Drivers
-
-Clients connect to Memgraph using the
-[Bolt protocol](https://boltprotocol.org/). Bolt was designed for efficient
-communication with graph databases. Memgraph supports
-[Version 1](https://boltprotocol.org/v1/) of the protocol. Official Bolt
-protocol drivers are provided for multiple programming languages:
-
-  * [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)
-
-### 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:
-
-```
-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, and
-#   * disable encryption (not supported).
-driver = GraphDatabase.driver("bolt://localhost:7687",
-                              auth=basic_auth("", ""),
-                              encrypted=False)
-
-# 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.  Encryption
-has to be disabled by calling `withoutEncryption` method against the `Config`
-builder.
-
-```
-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().withoutEncryption().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. SSL
-can be disabled by passing `{encrypted: 'ENCRYPTION_OFF'}` during the driver
-construction.
-
-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.
-
-```
-var neo4j = require('neo4j-driver').v1;
-var driver = neo4j.driver("bolt://localhost:7687",
-                          neo4j.auth.basic("neo4j", "1234"),
-                          {encrypted: 'ENCRYPTION_OFF'});
-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. Encryption is disabled
-by setting `EncryptionLevel.NONE` on the `Config`.
-
-```
-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;
-    config.EncryptionLevel = EncryptionLevel.None;
-    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!");
-  }
-}
-```
-
-### 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.
-
-#### Secure Sockets Layer (SSL)
-
-Secure connections are not supported. For this reason each client
-driver needs to be configured not to use encryption. Consult driver-specific
-guides for details.

docs/user_technical/examples.md

@@ -1,173 +0,0 @@
-## 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.
-
-```
-/usr/lib/memgraph/memgraph --durability-directory /usr/share/memgraph/examples/TEDTalk \
-  --durability-enabled=false --snapshot-on-exit=false
-```
-
-When using Memgraph installed from DEB package, you may need to stop the
-currently running Memgraph server before you can import the example. Use the
-following command:
-
-```
-systemctl stop memgraph
-```
-
-When using Docker, you can import the example with the following command:
-
-```
-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:
-```
-MATCH (n:Speaker {name: "Hans Rosling"})-[:Gave]->(m:Talk)
-RETURN m.title;
-```
-
-
-2) Find the top 20 speakers with most talks given:
-
-```
-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:
-```
-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:
-```
-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.
-```
-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:
-```
-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:
-
-```
-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:
-```
-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:
-```
-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:
-```
-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:
-```
-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;
-```
-
-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:
-
-```
-MATCH (n) DETACH DELETE n;
-```
-
-

docs/user_technical/import-tools.md

@@ -1,118 +0,0 @@
-## 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:
-
-```
-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:
-
-```
-mg_import_csv --help
-```
-
-When using Docker, this translates to:
-
-```
-docker run --entrypoint=mg_import_csv memgraph --help
-```
-
-#### Example
-
-Let's import a simple dataset.
-
-Store the following in `comment_nodes.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`.
-
-```
-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`.
-
-```
-: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:
-
-```
-mg_import_csv --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:
-
-```
-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:
-
-```
-docker run -v mg_lib:/var/lib/memgraph -v mg_etc:/etc/memgraph -v mg_import:/import-data \
-  --entrypoint=mg_import_csv memgraph \
-  --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

@@ -1,733 +0,0 @@
-## 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.
-
-    MATCH (node) RETURN node
-
-Finding connected nodes can be achieved by using the query:
-
-    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.
-
-    MATCH (n :Person {age: 42}) RETURN n
-
-While their friends can be found with the following.
-
-    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:
-
-    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:
-
-    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:
-
-    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.
-
-    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.
-
-    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:
-
-    MATCH (node1)-[connection]-(node2) RETURN *
-
-is equivalent to:
-
-    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:
-
-    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.
-
-    MATCH (n :Person) RETURN n LIMIT 3
-
-If you want to get all the results after the first 3, you can use the
-following.
-
-    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:
-
-    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.
-
-    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.
-
-    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.
-
-    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.
-
-    MATCH (n :Person) RETURN old AS new ORDER BY old.name
-
-Instead, the `new` variable must be used:
-
-    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.
-
-    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:
-
-    MATCH (n :Person) RETURN avg(n.age) AS averageAge
-
-Collecting items into a list:
-
-    MATCH (n :Person) RETURN collect(n.name) AS list_of_names
-
-Collecting items into a map:
-
-    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, ie. a query can't
-    contain both `UNION` and `UNION ALL`.
-
-Example, get distinct names that are shared between persons and movies:
-
-    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):
-
-    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
-**Storable Data Types** 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.
-
-    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:
-
-    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.
-
-    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.
-
-    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.
-
-    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.
-
-    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.
-
-    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.
-
-    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.
-
-    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.
-
-    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:
-
-    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`:
-
-    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.
-
-    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:
-
-    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:
-
-    MATCH (n)-[r:Type * {x: 42}]-(m)
-
-This will produce only those paths whose edges have the required `Type` and `x`
-property value.
-
-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`.
-
-    MATCH (n)-[r * (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:
-
-    MATCH (n)-[r *]-(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:
-
-    MATCH (a {id: 723})-[r: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.
-
-    MATCH (a {id: 723})-[r: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`:
-
-    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.
-
-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:
-
-    MATCH (a {id: 723})-[le *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`.
-
-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':
-
-    MATCH (a {id: 723})-[le *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`:
-
-    MATCH (a {id: 723})-[le *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.
-
-    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.
- `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)`.
- `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).
-
-#### 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:
-
-    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:
-
-    MATCH (node1 $propertyValue) RETURN node1
-
-To use parameters with Python driver use following syntax:
-
-    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:
-
-    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:
-
-    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:
-
-    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:
-* `id()` - Memgraph does not expose a public unique node identifier.
-* `exists(n.property)` - This can be expressed using `n.property IS NOT NULL`.
-* `length()` is named `size()` in Memgraph.
-
-Path functions:
-* `extract()`
-
-Aggregation functions:
-* `count(DISTINCT variable)` - This can be expressed using `WITH DISTINCT variable RETURN count(variable)`.
-
-Mathematical functions:
-* `percentileDisc()`
-* `stDev()`
-* `point()`
-* `distance()`
-* `degrees()`
-
-String functions:
-* `replace()`
-* `substring()`
-* `left()`
-* `trim()`
-* `toupper()`
-* `tolower()`
-* `split()`
-* `reverse()`
-
-List functions:
-* `any()`
-* `none()`
-* `single()`
-* `head()`
-* `last()`
-* `tail()`

docs/user_technical/quick-start.md

@@ -1,148 +0,0 @@
-## 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) and
-  * Docker image.
-
-After downloading the binary, proceed to the corresponding section below.
-
-#### 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.
-
-```
-docker load -i /path/to/memgraph-<version>-docker.tar.gz
-```
-
-Memgraph is then started with another docker command.
-
-```
-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.
-
-```
-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.
-
-#### Debian Package Installation
-
-After downloading Memgraph as a Debian package, install it by running the
-following.
-
-```
-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:
-
-```
-systemctl start memgraph
-```
-
-To verify that Memgraph is running, run the following command.
-
-```
-journalctl --unit memgraph
-```
-
-It is expected to see something like the following output.
-
-```
-Nov 23 13:40:13 hostname memgraph[14654]: Starting 8 workers
-Nov 23 13:40:13 hostname memgraph[14654]: Server is fully armed and operational
-Nov 23 13:40:13 hostname memgraph[14654]: 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.
-
-```
-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.
-
-```
-neo4j-client --insecure -u "" -p ""  localhost 7687
-```
-
-After the client has started it should present a command prompt similar to:
-
-```
-neo4j-client 2.1.3
-Enter `:help` for usage hints.
-Connected to 'neo4j://@localhost:7687' (insecure)
-neo4j>
-```
-
-At this point it is possible to execute openCypher queries on Memgraph. Each
-query needs to end with the `;` (*semicolon*) character. For example:
-
-```
-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:
-
-```
-MATCH (u:User)-[r]->(x) RETURN u, r, x;
-```
-
-### Where to Next
-
-To learn more about the openCypher language, visit **openCypher Query
-Language** chapter in this document. For real-world examples of how to use
-Memgraph visit **Examples** chapter. If you wish to use a programming language
-to execute queries on Memgraph, go to the **Drivers** chapter. Details on what
-can be stored in Memgraph are in **Storable Data Types** chapter.
-
-We *welcome and encourage* your feedback!
-

docs/user_technical/run

@@ -1,20 +0,0 @@
-#!/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/upcoming-features.md

@@ -1,56 +0,0 @@
-## 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:
-
-    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:
-
-    MATCH (n :Person) WHERE n.age < 42 RETURN collect(n)
-
-Using list comprehensions, the same can be done with the query:
-
-    MATCH (n :Person) RETURN [n IN collect(n) WHERE n.age < 42]
-

environment/.gitignore

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

environment/README.md

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

environment/os/.gitignore

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

environment/os/centos-7.sh

@@ -0,0 +1,134 @@
+#!/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

@@ -0,0 +1,152 @@
+#!/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://mirror.centos.org/centos/8/PowerTools/x86_64/os/Packages/libbabeltrace-devel-1.5.4-3.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

@@ -0,0 +1,93 @@
+#!/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 --allow-releaseinfo-change 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-11.sh

@@ -0,0 +1,95 @@
+#!/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 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 bullseye main
+deb-src http://deb.debian.org/debian bullseye main
+
+deb http://deb.debian.org/debian-security/ bullseye-security main
+deb-src http://deb.debian.org/debian-security/ bullseye-security main
+
+deb http://deb.debian.org/debian bullseye-updates main
+deb-src http://deb.debian.org/debian bullseye-updates main
+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

@@ -0,0 +1,62 @@
+#!/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

@@ -0,0 +1,36 @@
+#!/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

@@ -0,0 +1,63 @@
+#!/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

@@ -0,0 +1,85 @@
+#!/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

@@ -0,0 +1,651 @@
+#!/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

@@ -0,0 +1,533 @@
+#!/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/toolchain/v3.sh

@@ -0,0 +1,556 @@
+#!/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=3
+
+# package versions used
+GCC_VERSION=11.1.0
+BINUTILS_VERSION=2.36.1
+case "$DISTRO" in
+    centos-7) # because GDB >= 9 does NOT compile with readline6.
+        GDB_VERSION=8.3
+    ;;
+    *)
+        GDB_VERSION=10.2
+    ;;
+esac
+CMAKE_VERSION=3.20.5
+CPPCHECK_VERSION=2.4.1
+LLVM_VERSION=12.0.1rc4
+LLVM_VERSION_LONG=12.0.1-rc4
+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_LONG/llvm-$LLVM_VERSION.src.tar.xz
+    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION_LONG/clang-$LLVM_VERSION.src.tar.xz
+    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION_LONG/lld-$LLVM_VERSION.src.tar.xz
+    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION_LONG/clang-tools-extra-$LLVM_VERSION.src.tar.xz
+    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION_LONG/compiler-rt-$LLVM_VERSION.src.tar.xz
+    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION_LONG/libunwind-$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 0x6C35B99309B5FA62
+$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_LONG/llvm-$LLVM_VERSION.src.tar.xz.sig
+    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION_LONG/clang-$LLVM_VERSION.src.tar.xz.sig
+    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION_LONG/lld-$LLVM_VERSION.src.tar.xz.sig
+    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION_LONG/clang-tools-extra-$LLVM_VERSION.src.tar.xz.sig
+    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION_LONG/compiler-rt-$LLVM_VERSION.src.tar.xz.sig
+    wget https://github.com/llvm/llvm-project/releases/download/llvmorg-$LLVM_VERSION_LONG/libunwind-$LLVM_VERSION.src.tar.xz.sig
+fi
+# list of valid llvm gnupg keys: https://releases.llvm.org/download.html
+$GPG --keyserver $KEYSERVER --recv-keys 0x474E22316ABF4785A88C6E8EA2C794A986419D8A
+$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
+$GPG --verify libunwind-$LLVM_VERSION.src.tar.xz.sig libunwind-$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
+    # this was fixed in cppcheck 2.5, remove this in toolchain-v4 after the lib is updated
+    # to 2.5+ version.
+    sed -i '/#include <iostream>/ a #include <limits>' lib/symboldatabase.cpp
+    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
+    tar -xvf ../archives/libunwind-$LLVM_VERSION.src.tar.xz
+    mv libunwind-$LLVM_VERSION.src/include/mach-o llvm-$LLVM_VERSION/tools/lld/include
+    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!
+
+env_error="You already have an active virtual environment!"
+
+# zsh does not recognize the option -t of the command type
+# therefore we use the alternative whence -w
+if [[ "\$ZSH_NAME" == "zsh" ]]; then
+    # check for active virtual environments
+    if [ "\$( whence -w deactivate )" != "deactivate: none" ]; then
+        echo \$env_error
+        return 0;
+    fi
+# any other shell
+else
+    # check for active virtual environments
+    if [ "\$( type -t deactivate )" != "" ]; then
+        echo \$env_error
+        return 0
+    fi
+fi
+
+# check that we aren't root
+if [[ "\$USER" == "root" ]]; then
+    echo "You shouldn't use the toolchain 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

@@ -0,0 +1,50 @@
+#!/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

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

experimental/distributed/.clang-format

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

experimental/distributed/.gitignore

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

experimental/distributed/CMakeLists.txt

@@ -1,42 +0,0 @@
-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

@@ -1,35 +0,0 @@
-
-# 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

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

experimental/distributed/init

@@ -1,13 +0,0 @@
-#!/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

@@ -1,77 +0,0 @@
-#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

@@ -1,215 +0,0 @@
-#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

@@ -1,164 +0,0 @@
-#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

@@ -1,25 +0,0 @@
-#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;
-}

experimental/distributed/src/memgraph_config.hpp

@@ -1,39 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <cassert>
-#include <fstream>
-#include <utility>
-#include <vector>
-#include <string>
-
-#include <gflags/gflags.h>
-
-/**
- * About config file
- *
- * Each line contains three strings:
- *   memgraph node id, ip address of the worker, and port of the worker
- * Data on the first line is used to start master.
- * Data on the remaining lines is used to start workers.
- */
-DECLARE_string(config_filename);
-
-using MnidT = uint64_t;
-
-struct Config {
-  struct NodeConfig {
-    MnidT mnid;
-    std::string address;
-    uint16_t port;
-  };
-
-  std::vector<NodeConfig> nodes;
-};
-
-/**
- * Parse config file.
- *
- * @return config object.
- */
-Config ParseConfig(const std::string &filename = FLAGS_config_filename);

experimental/distributed/src/memgraph_distributed.hpp

@@ -1,74 +0,0 @@
-#pragma once
-
-#include "memgraph_config.hpp"
-
-#include "reactors_distributed.hpp"
-
-#include <mutex>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-class MemgraphDistributed {
- private:
-  using Location = std::pair<std::string, uint16_t>;
-
- public:
-  /**
-   * Get the (singleton) instance of MemgraphDistributed.
-   */
-  static MemgraphDistributed &GetInstance() {
-    static MemgraphDistributed memgraph;
-    return memgraph;
-  }
-
-  EventStream *FindChannel(MnidT mnid, const std::string &reactor,
-                           const std::string &channel) {
-    std::unique_lock<std::mutex> lock(mutex_);
-    const auto &location = mnodes_.at(mnid);
-    return Distributed::GetInstance().FindChannel(
-        location.first, location.second, reactor, channel);
-  }
-
-  void RegisterConfig(const Config &config) {
-    config_ = config;
-    for (auto &node : config_.nodes) {
-      RegisterMemgraphNode(node.mnid, node.address, node.port);
-    }
-  }
-
-  std::vector<MnidT> GetAllMnids() {
-    std::vector<MnidT> mnids;
-    for (auto &node : config_.nodes) {
-      mnids.push_back(node.mnid);
-    }
-    return mnids;
-  }
-
-  /**
-   * The leader is currently the first node in the config.
-   */
-  MnidT LeaderMnid() const { return config_.nodes.front().mnid; }
-
- protected:
-  MemgraphDistributed() {}
-
-  /** Register memgraph node id to the given location. */
-  void RegisterMemgraphNode(MnidT mnid, const std::string &address,
-                            uint16_t port) {
-    std::unique_lock<std::mutex> lock(mutex_);
-    mnodes_[mnid] = Location(address, port);
-  }
-
- private:
-  Config config_;
-
-  std::mutex mutex_;
-  std::unordered_map<MnidT, Location> mnodes_;
-
-  MemgraphDistributed(const MemgraphDistributed &) = delete;
-  MemgraphDistributed(MemgraphDistributed &&) = delete;
-  MemgraphDistributed &operator=(const MemgraphDistributed &) = delete;
-  MemgraphDistributed &operator=(MemgraphDistributed &&) = delete;
-};

experimental/distributed/src/memgraph_transactions.hpp

@@ -1,135 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "reactors_local.hpp"
-#include "reactors_distributed.hpp"
-
-/**
- * Message which encapsulates query.
- * It is create on Client and sent to Master which will process it.
- */
-class QueryMsg : public ReturnAddressMsg {
- public:
-  QueryMsg(std::string return_channel, std::string query)
-      : ReturnAddressMsg(return_channel), query_(query) {}
-
-  const std::string &query() const { return query_; }
-
-  template <class Archive>
-  void serialize(Archive &archive) {
-    archive(cereal::virtual_base_class<ReturnAddressMsg>(this), query_);
-  }
-
-protected:
-  // Cereal needs access to default constructor.
-  friend class cereal::access;
-  QueryMsg() = default;
-
-  std::string query_;
-};
-CEREAL_REGISTER_TYPE(QueryMsg);
-
-/**
- * Message which encapuslates result of a query.
- * Currently, result is string.
- */
-class ResultMsg : public Message {
- public:
-  ResultMsg(std::string result) : result_(result) {}
-
-  const std::string &result() const { return result_; }
-
-  template <class Archive>
-  void serialize(Archive &archive) {
-    archive(cereal::virtual_base_class<Message>(this), result_);
-  }
-
- protected:
-  friend class cereal::access;
-  ResultMsg() = default;
-
-  std::string result_;
-};
-CEREAL_REGISTER_TYPE(ResultMsg);
-
-/**
- * Below are message that are exchanged between Master and Workers.
- */
-
-class QueryCreateVertex : public ReturnAddressMsg {
-public:
-  QueryCreateVertex(std::string return_channel)
-      : ReturnAddressMsg(return_channel) {}
-
-  template <class Archive>
-  void serialize(Archive &archive) {
-    archive(cereal::virtual_base_class<ReturnAddressMsg>(this));
-  }
-
-protected:
-  // Cereal needs access to default constructor.
-  friend class cereal::access;
-  QueryCreateVertex() {}
-};
-CEREAL_REGISTER_TYPE(QueryCreateVertex);
-
-class SuccessQueryCreateVertex : public Message {
-public:
-  SuccessQueryCreateVertex() {}
-
-  template <class Archive>
-  void serialize(Archive &archive) {
-    archive(cereal::virtual_base_class<Message>(this));
-  }
-};
-CEREAL_REGISTER_TYPE(SuccessQueryCreateVertex);
-
-class FailureQueryCreateVertex : public Message {
-public:
-  FailureQueryCreateVertex() {}
-
-  template <class Archive>
-  void serialize(Archive &archive) {
-    archive(cereal::virtual_base_class<Message>(this));
-  }
-};
-CEREAL_REGISTER_TYPE(FailureQueryCreateVertex);
-
-
-class QueryVertexCount : public ReturnAddressMsg {
- public:
-  QueryVertexCount(std::string return_channel)
-      : ReturnAddressMsg(return_channel) {}
-
-  template <class Archive>
-  void serialize(Archive &archive) {
-    archive(cereal::virtual_base_class<ReturnAddressMsg>(this));
-  }
-
- protected:
-   // Cereal needs access to default constructor.
-  friend class cereal::access;
-  QueryVertexCount() {}
-};
-CEREAL_REGISTER_TYPE(QueryVertexCount);
-
-class ResultQueryVertexCount : public Message {
- public:
-  ResultQueryVertexCount(int64_t count) : count_(count) {}
-
-  int64_t count() const { return count_; }
-
-  template <class Archive>
-  void serialize(Archive &archive) {
-    archive(cereal::virtual_base_class<Message>(this), count_);
-  }
-
- protected:
-  // Cereal needs access to default constructor.
-  friend class cereal::access;
-  ResultQueryVertexCount() {}
-
-  int64_t count_;
-};
-CEREAL_REGISTER_TYPE(ResultQueryVertexCount);

experimental/distributed/src/spinner.hpp

@@ -1,147 +0,0 @@
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <experimental/tuple>
-#include <iostream>
-#include <numeric>
-#include <random>
-#include <tuple>
-#include <vector>
-
-#include "graph.hpp"
-
-namespace spinner {
-// const for balancing penalty
-double c = 2.0;
-
-/**
- * Returns the index of the maximum score in the given vector.
- * If there are multiple minimums, one is chosen at random.
- */
-auto MaxRandom(const std::vector<double> &scores) {
-  std::vector<size_t> best_indices;
-  double current_max = std::numeric_limits<double>::lowest();
-
-  for (size_t ind = 0; ind < scores.size(); ind++) {
-    if (scores[ind] > current_max) {
-      current_max = scores[ind];
-      best_indices.clear();
-    }
-    if (scores[ind] == current_max) {
-      best_indices.emplace_back(ind);
-    }
-  }
-
-  return best_indices[rand() % best_indices.size()];
-}
-
-/**
- * Returns the index of the best (highest scored) mnode
- * for the given vertex. If there are multiple mnodes with
- * the best score, vertex prefers to remain on the same mnode
- * (if among the best), or one is chosen at random.
- *
- * @param distributed - the distributed system.
- * @param vertex - the vertex which is being evaluated.
- * @param penalties - a vector of penalties (per mnode).
- * @param current_mnode - the mnode on which the given
- *  vertex is currently residing.
- * @return - std::pair<int, std::vector<double>> which is a
- * pair of (best mnode, score_per_mnode).
- */
-auto BestMnode(const Distributed &distributed, const Vertex &vertex,
-                const std::vector<double> &penalties, int current_mnode) {
-  // scores per mnode
-  std::vector<double> scores(distributed.MnodeCount(), 0.0);
-
-  for (auto &edge : vertex.edges_in()) scores[edge.cur_mnid_] += 1.0;
-  for (auto &edge : vertex.edges_out()) scores[edge.cur_mnid_] += 1.0;
-
-  for (int mnode = 0; mnode < distributed.MnodeCount(); ++mnode) {
-    // normalize contribution of mnode over neighbourhood size
-    scores[mnode] /= vertex.edges_out().size() + vertex.edges_in().size();
-    // add balancing penalty
-    scores[mnode] -= penalties[mnode];
-  }
-
-  // pick the best destination, but prefer to stay if you can
-  size_t destination = MaxRandom(scores);
-  if (scores[current_mnode] == scores[destination])
-    destination = current_mnode;
-
-  return std::make_pair(destination, scores);
-}
-
-/** Indication if Spinner mnode penality is calculated based on
- * vertex or edge mnode cardinalities */
-enum class PenaltyType { Vertex, Edge };
-
-/** Calcualtes Spinner penalties for mnodes in the given
- * distributed system. */
-auto Penalties(const Distributed &distributed,
-               PenaltyType penalty_type = PenaltyType::Edge) {
-  std::vector<double> penalties;
-  int64_t total_count{0};
-
-  for (const auto &mnode : distributed) {
-    int64_t mnode_count{0};
-    switch (penalty_type) {
-      case PenaltyType::Vertex:
-        mnode_count += mnode.VertexCount();
-        break;
-      case PenaltyType::Edge:
-        for (const auto &vertex_kv : mnode) {
-          // Spinner counts the edges on a mnode as the sum
-          // of degrees of vertices on that mnode. In that sense
-          // both incoming and outgoing edges are individually
-          // added...
-          mnode_count += vertex_kv.second.edges_out().size();
-          mnode_count += vertex_kv.second.edges_in().size();
-        }
-        break;
-    }
-    total_count += mnode_count;
-    penalties.emplace_back(mnode_count);
-  }
-
-  for (auto &penalty : penalties)
-    penalty /= c * total_count / distributed.MnodeCount();
-
-  return penalties;
-}
-
-/** Do one spinner step (modifying the given distributed) */
-void PerformSpinnerStep(Distributed &distributed) {
-  auto penalties = Penalties(distributed);
-
-  // here a strategy can be injected for limiting
-  // the number of movements performed in one step.
-  // limiting could be based on (for example):
-  //  - limiting the number of movements per mnode
-  //  - limiting only to movements that are above
-  //    a treshold (score improvement or something)
-  //  - not executing on all the mnodes (also prevents
-  //    oscilations)
-  //
-  // in the first implementation just accumulate all
-  // the movements and execute together.
-
-  // relocation info: contains the address of the Vertex
-  // that needs to relocate and it's destination mnode
-  std::vector<std::pair<GlobalVertAddress, int>> movements;
-
-  for (const ShardedStorage &mnode : distributed)
-    for (const auto &gid_vertex_pair : mnode) {
-      // (best destination, scores) pair for vertex
-      std::pair<int, std::vector<double>> destination_scores =
-          BestMnode(distributed, gid_vertex_pair.second, penalties, mnode.mnid_);
-      if (destination_scores.first != mnode.mnid_)
-        movements.emplace_back(GlobalVertAddress(mnode.mnid_, gid_vertex_pair.first),
-                               destination_scores.first);
-    }
-
-  // execute movements. it is likely that in the real system
-  // this will need to happen as a single db transaction
-  for (const auto &m : movements) distributed.MoveVertex(m.first, m.second);
-}
-}  // namespace spinner

experimental/distributed/src/storage.hpp

@@ -1,45 +0,0 @@
-#pragma once
-
-#include <string>
-#include <unordered_map>
-
-#include "uid.hpp"
-
-/**
- * Mock-up storage to test basic hardcoded queries.
- *
- * Current code is taken from graph.hpp. It will grow as needed to support
- * new queries, but not more. Once all functionality from graph.hpp is 
- * transfered here, this file will be included in graph.hpp.
- */
-
-class Vertex {};
-
-/**
- * Storage that is split over multiple nodes.
- */
-class ShardedStorage {
- public:
-  ShardedStorage(int64_t mnid) : mnid_(mnid) {}
-
-  /** Returns number of vertices on this node. */
-  int64_t VertexCount() const { return vertices_.size(); }
-
-  /** 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()));
-    return new_vertex.first->first;
-  };
-
- private:
-  // unique Memgraph node ID
-  // uniqueness is ensured by the (distributed) system
-  const int64_t mnid_;
-
-  // counter of vertices created on this node.
-  int64_t next_vertex_sequence_{0};
-
-  // vertex storage of this node
-  std::unordered_map<UniqueVid, Vertex> vertices_;
-};

experimental/distributed/src/uid.hpp

@@ -1,66 +0,0 @@
-#pragma once
-
-#include "utils/hashing/fnv.hpp"
-
-#include <cstdint>
-#include <vector>
-
-/**
- * Globally unique id (in the entire distributed system) of a vertex.
- *
- * It is identified by a pair of a (original memgraph node, local vertex id)
- */
-class UniqueVid {
- public:
-  UniqueVid(int64_t orig_mnid, int64_t vid)
-    : orig_mnid_(orig_mnid), vid_(vid) {}
-  /** Original Memgraph node the vertex was created **/
-  int64_t orig_mnid_;
-
-  /** Original vertex id it was assigned on creation. **/
-  int64_t vid_;
-
-  bool operator==(const UniqueVid &other) const {
-    return orig_mnid_ == other.orig_mnid_ &&
-           vid_ == other.vid_;
-  }
-
-  bool operator!=(const UniqueVid &other) const { return !(*this == other); }
-};
-
-/**
- * Specifies where a vertex is in the distributed system.
- */
-class GlobalVertAddress {
- public:
-  GlobalVertAddress(int64_t cur_mnid, const UniqueVid &uvid)
-      : cur_mnid_(cur_mnid), uvid_(uvid) {}
-
-  /** The current Memgraph node where the vertex is **/
-  int64_t cur_mnid_;
-  UniqueVid uvid_;
-
-  bool operator==(const GlobalVertAddress &other) const {
-    return cur_mnid_ == other.cur_mnid_ && uvid_ == other.uvid_;
-  }
-
-  bool operator!=(const GlobalVertAddress &other) const {
-    return !(*this == other);
-  }
-};
-
-namespace std {
-template <>
-struct hash<UniqueVid> {
-  size_t operator()(const UniqueVid &uid) const {
-    return HashCombine<decltype(uid.orig_mnid_), decltype(uid.vid_)>()(uid.orig_mnid_, uid.vid_);
-  }
-};
-
-template <>
-struct hash<GlobalVertAddress> {
-  size_t operator()(const GlobalVertAddress &ga) const {
-    return HashCombine<decltype(ga.cur_mnid_), decltype(ga.uvid_)>()(ga.cur_mnid_, ga.uvid_);
-  }
-};
-}

experimental/distributed/start_main.py

@@ -1,46 +0,0 @@
-#!/usr/bin/env python3
-# Automatically copied to the build/ directory during Makefile (configured by cmake)
-
-import os
-
-terminal_command = 'gnome-terminal'
-terminal_flags = ' --geometry=200x50 '  # columns x rows
-
-config_filename = 'config'
-log_dir = "logs"
-glog_flags = '--alsologtostderr --logbufsecs=0 --minloglevel=2 --log_dir="{}" '.format(log_dir)
-
-def GetMainCall(my_mnid, address, port):
-  ret = "./main {} --my_mnid {} --address {} --port {} --config_filename={}".format(
-    glog_flags, my_mnid, address, port, config_filename)
-
-  print(ret)
-  return ret
-
-
-def GetClientCall():
-  ret = "./main-client {} --address 127.0.0.1 --port 10000 --config_filename={}".format(
-    glog_flags, config_filename)
-  print(ret)
-  return ret
-
-
-def NamedGnomeTab(name, command):
-  return " --tab -e \"bash -c 'printf \\\"\\033]0;{}\\007\\\"; {}'\" ".format(name, command)
-
-
-if __name__ == "__main__":
-  command = "{} {}".format(terminal_command, terminal_flags)
-  command += NamedGnomeTab("client", GetClientCall())
-
-  f = open(config_filename, 'r')
-  for line in f:
-    data = line.strip().split(' ')
-    my_mnid = data[0]
-    address = data[1]
-    port = data[2]
-    command += NamedGnomeTab("mnid={}".format(my_mnid), GetMainCall(my_mnid, address, port))
-
-  print(command)
-  os.system('mkdir -p {}'.format(log_dir))
-  os.system(command)

experimental/distributed/tests/CMakeLists.txt

@@ -1,35 +0,0 @@
-# set current directory name as a test type
-get_filename_component(test_type ${CMAKE_CURRENT_SOURCE_DIR} NAME)
-
-# get all cpp abs file names recursively starting from current directory
-file(GLOB_RECURSE test_type_cpps *.cpp)
-message(STATUS "Available ${test_type} cpp files are: ${test_type_cpps}")
-
-include_directories(${GTEST_INCLUDE_DIR})
-
-# for each cpp file build binary and register test
-foreach(test_cpp ${test_type_cpps})
-
-    # get exec name (remove extension from the abs path)
-    get_filename_component(exec_name ${test_cpp} NAME_WE)
-
-    set(target_name memgraph__${test_type}__${exec_name})
-
-    # build exec file
-    add_executable(${target_name} ${test_cpp})
-
-    # OUTPUT_NAME sets the real name of a target when it is built and can be
-    # used to help create two targets of the same name even though CMake
-    # requires unique logical target names
-    set_target_properties(${target_name} PROPERTIES OUTPUT_NAME ${exec_name})
-
-    # link libraries
-    target_link_libraries(${target_name} distributed_lib memgraph_lib)
-    # gtest
-    target_link_libraries(${target_name} gtest gtest_main)
-
-    # register test
-    set(output_path ${CMAKE_BINARY_DIR}/test_results/unit/${target_name}.xml)
-    add_test(${target_name} ${exec_name} --gtest_output=xml:${output_path})
-
-endforeach()

experimental/distributed/tests/config

@@ -1,3 +0,0 @@
-0 127.0.0.1 10000
-2 127.0.0.1 10001
-3 127.0.0.1 10002