Refactor update vertices

Add update vertices
Add edge updating property
2022-05-16 10:32:41 +02:00 · 2022-05-13 14:12:55 +02:00 · 2022-05-13 13:30:38 +02:00 · 2022-05-12 16:22:35 +02:00 · 2022-05-02 09:09:31 +02:00 · 2022-04-29 15:48:00 +02:00
466 changed files with 4235 additions and 95575 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -6,7 +6,6 @@ Checks: '*,
         -altera-unroll-loops,
         -android-*,
         -cert-err58-cpp,
-         -cert-str34-c,
         -cppcoreguidelines-avoid-c-arrays,
         -cppcoreguidelines-avoid-goto,
         -cppcoreguidelines-avoid-magic-numbers,
@@ -50,7 +49,6 @@ Checks: '*,
         -misc-non-private-member-variables-in-classes,
         -modernize-avoid-c-arrays,
         -modernize-concat-nested-namespaces,
-         -modernize-loop-convert,
         -modernize-pass-by-value,
         -modernize-use-equals-default,
         -modernize-use-nodiscard,
@@ -63,9 +61,7 @@ Checks: '*,
         -readability-magic-numbers,
         -readability-named-parameter,
         -misc-no-recursion,
-         -concurrency-mt-unsafe,
-         -bugprone-easily-swappable-parameters'
-
+         -concurrency-mt-unsafe'
 WarningsAsErrors: ''
 HeaderFilterRegex: 'src/.*'
 AnalyzeTemporaryDtors: false
@@ -92,3 +88,4 @@ CheckOptions:
  - key:             modernize-use-nullptr.NullMacros
    value:           'NULL'
 ...
+
--- a/.githooks/pre-commit
+++ b/.githooks/pre-commit
@@ -24,6 +24,14 @@ for file in $modified_files; do

  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
+
  # Do not break header checker
  echo "Running header checker..."
  $project_folder/tools/header-checker.py $tmpdir/$file $file --amend-year
@@ -31,6 +39,7 @@ for file in $modified_files; do
  if [ $CODE -ne 0 ]; then
    FAIL=1
  fi
+
 done;

 return ${FAIL}
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -3,9 +3,7 @@
 - [ ] 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
- [ ] Provide the full content or a guide for the final git message

 [master < Task] PR
 - [ ] Check, and update documentation if necessary
 - [ ] Update [changelog](https://docs.memgraph.com/memgraph/changelog)
- [ ] Provide the full content or a guide for the final git message
--- a/.github/workflows/diff.yaml
+++ b/.github/workflows/diff.yaml
@@ -1,7 +1,4 @@
 name: Diff
-concurrency:
-  group: ${{ github.head_ref || github.sha }}
-  cancel-in-progress: true

 on:
  push:
@@ -70,11 +67,6 @@ jobs:
          # branches and tags. (default: 1)
          fetch-depth: 0

-        # This is also needed if we want do to comparison against other branches
-        # See https://github.community/t/checkout-code-fails-when-it-runs-lerna-run-test-since-master/17920
-      - name: Fetch all history for all tags and branches
-        run: git fetch
-
      - name: Build combined ASAN, UBSAN and coverage binaries
        run: |
          # Activate toolchain.
@@ -115,22 +107,12 @@ jobs:
          name: "Code coverage"
          path: tools/github/generated/code_coverage.tar.gz

-      - name: Set base branch
-        if: ${{ github.event_name == 'pull_request' }}
-        run: |
-          echo "BASE_BRANCH=origin/${{ github.base_ref }}" >> $GITHUB_ENV
-
-      - name: Set base branch # if we manually dispatch or push to master
-        if: ${{ github.event_name != 'pull_request' }}
-        run: |
-          echo "BASE_BRANCH=origin/master" >> $GITHUB_ENV
-
      - name: Run clang-tidy
        run: |
          source /opt/toolchain-v4/activate

          # Restrict clang-tidy results only to the modified parts
-          git diff -U0 ${{ env.BASE_BRANCH }}... -- src | ./tools/github/clang-tidy/clang-tidy-diff.py -p 1 -j $THREADS -extra-arg="-DMG_CLANG_TIDY_CHECK" -path build | tee ./build/clang_tidy_output.txt
+          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
@@ -171,7 +153,7 @@ jobs:

          # Run leftover CTest tests (all except unit and benchmark tests).
          cd build
-          ctest -E "(memgraph__unit|memgraph__benchmark|memgraph__simulation)" --output-on-failure
+          ctest -E "(memgraph__unit|memgraph__benchmark)" --output-on-failure

      - name: Run drivers tests
        run: |
@@ -262,15 +244,6 @@ jobs:
          cd build
          ctest -R memgraph__unit --output-on-failure -j$THREADS

-      - name: Run simulation tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__simulation --output-on-failure -j$THREADS
-
      - name: Run e2e tests
        run: |
          # TODO(gitbuda): Setup mgclient and pymgclient properly.
--- a/.github/workflows/full_clang_tidy.yaml
+++ b/.github/workflows/full_clang_tidy.yaml
@@ -39,7 +39,7 @@ jobs:
          source /opt/toolchain-v4/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 -extra-arg="-DMG_CLANG_TIDY_CHECK" -clang-tidy-binary=/opt/toolchain-v4/bin/clang-tidy "$PWD/src/*" |
+          ./tools/github/clang-tidy/run-clang-tidy.py -p build -j $THREADS -clang-tidy-binary=/opt/toolchain-v4/bin/clang-tidy "$PWD/src/*" |
            tee ./build/full_clang_tidy_output.txt

      - name: Summarize clang-tidy results
--- a/.github/workflows/package_all.yaml
+++ b/.github/workflows/package_all.yaml
@@ -6,11 +6,11 @@ on: workflow_dispatch

 jobs:
  centos-7:
-    runs-on: [self-hosted, DockerMgBuild, X64]
+    runs-on: [self-hosted, DockerMgBuild]
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
@@ -22,29 +22,29 @@ jobs:
          name: centos-7
          path: build/output/centos-7/memgraph*.rpm

-  centos-9:
-    runs-on: [self-hosted, DockerMgBuild, X64]
+  centos-8:
+    runs-on: [self-hosted, DockerMgBuild]
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v3
+        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-9
+          ./release/package/run.sh package centos-8
      - name: "Upload package"
        uses: actions/upload-artifact@v2
        with:
-          name: centos-9
-          path: build/output/centos-9/memgraph*.rpm
+          name: centos-8
+          path: build/output/centos-8/memgraph*.rpm

  debian-10:
-    runs-on: [self-hosted, DockerMgBuild, X64]
+    runs-on: [self-hosted, DockerMgBuild]
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
@@ -57,11 +57,11 @@ jobs:
          path: build/output/debian-10/memgraph*.deb

  debian-11:
-    runs-on: [self-hosted, DockerMgBuild, X64]
+    runs-on: [self-hosted, DockerMgBuild]
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
@@ -74,11 +74,11 @@ jobs:
          path: build/output/debian-11/memgraph*.deb

  docker:
-    runs-on: [self-hosted, DockerMgBuild, X64]
+    runs-on: [self-hosted, DockerMgBuild]
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
@@ -93,11 +93,11 @@ jobs:
          path: build/output/docker/memgraph*.tar.gz

  ubuntu-1804:
-    runs-on: [self-hosted, DockerMgBuild, X64]
+    runs-on: [self-hosted, DockerMgBuild]
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
@@ -110,11 +110,11 @@ jobs:
          path: build/output/ubuntu-18.04/memgraph*.deb

  ubuntu-2004:
-    runs-on: [self-hosted, DockerMgBuild, X64]
+    runs-on: [self-hosted, DockerMgBuild]
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
@@ -126,29 +126,12 @@ jobs:
          name: ubuntu-2004
          path: build/output/ubuntu-20.04/memgraph*.deb

-  ubuntu-2204:
-    runs-on: [self-hosted, DockerMgBuild, X64]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package ubuntu-22.04
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: ubuntu-2204
-          path: build/output/ubuntu-22.04/memgraph*.deb
-
  debian-11-platform:
-    runs-on: [self-hosted, DockerMgBuild, X64]
+    runs-on: [self-hosted, DockerMgBuild]
    timeout-minutes: 60
    steps:
      - name: "Set up repository"
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
        with:
          fetch-depth: 0 # Required because of release/get_version.py
      - name: "Build package"
@@ -159,20 +142,3 @@ jobs:
        with:
          name: debian-11-platform
          path: build/output/debian-11/memgraph*.deb
-
-  debian-11-arm:
-    runs-on: [self-hosted, DockerMgBuild, ARM64, strange]
-    timeout-minutes: 60
-    steps:
-      - name: "Set up repository"
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0 # Required because of release/get_version.py
-      - name: "Build package"
-        run: |
-          ./release/package/run.sh package debian-11-arm
-      - name: "Upload package"
-        uses: actions/upload-artifact@v2
-        with:
-          name: debian-11-arm
-          path: build/output/debian-11-arm/memgraph*.deb
--- a/.github/workflows/release_docker.yaml
+++ b/.github/workflows/release_docker.yaml
@@ -4,12 +4,8 @@ on:
  workflow_dispatch:
    inputs:
      version:
-        description: "Memgraph binary version to publish on DockerHub."
+        description: "Memgraph binary version to publish on Dockerhub."
        required: true
-      force_release:
-        type: boolean
-        required: false
-        default: false

 jobs:
  docker_publish:
@@ -40,22 +36,6 @@ jobs:
          curl -L https://download.memgraph.com/memgraph/v${{ github.event.inputs.version }}/debian-11/memgraph_${{ github.event.inputs.version }}-1_amd64.deb > memgraph-amd64.deb
          curl -L https://download.memgraph.com/memgraph/v${{ github.event.inputs.version }}/debian-11-aarch64/memgraph_${{ github.event.inputs.version }}-1_arm64.deb > memgraph-arm64.deb

-      - name: Check if specified version is already pushed
-        run: |
-          EXISTS=$(docker manifest inspect $DOCKER_ORGANIZATION_NAME/$DOCKER_REPOSITORY_NAME:${{ github.event.inputs.version }} > /dev/null; echo $?)
-          echo $EXISTS
-          if [[ ${EXISTS} -eq 0 ]]; then
-              echo 'The specified version has been already released to DockerHub.'
-              if [[ ${{ github.event.inputs.force_release }} = true ]]; then
-                echo 'Forcing the release!'
-              else
-                echo 'Stopping the release!'
-                exit 1
-              fi
-          else
-              echo 'All good the specified version has not been release to DockerHub.'
-          fi
-
      - name: Build & push docker images
        run: |
          cd release/docker
--- a/.gitignore
+++ b/.gitignore
@@ -23,8 +23,6 @@ cmake-build-*
 cmake/DownloadProject/
 dist/
 src/query/frontend/opencypher/generated/
-src/query/v2/frontend/opencypher/generated/
-src/parser/opencypher/generated
 tags
 ve/
 ve3/
@@ -52,25 +50,15 @@ 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/v2/frontend/ast/ast.hpp
 src/query/frontend/ast/ast.hpp
-src/storage/v3/bindings/ast/ast.hpp
 src/query/distributed/frontend/ast/ast_serialization.hpp
-src/query/v2/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/v2/frontend/semantic/symbol.hpp
-src/expr/semantic/symbol.hpp
 src/query/distributed/frontend/semantic/symbol_serialization.hpp
-src/query/v2/distributed/frontend/semantic/symbol_serialization.hpp
 src/query/distributed/plan/ops.hpp
-src/query/v2/distributed/plan/ops.hpp
 src/query/plan/operator.hpp
-src/query/v2/plan/operator.hpp
-src/parser/opencypher/generated
-src/expr/semantic/symbol.hpp
 src/raft/log_entry.hpp
 src/raft/raft_rpc_messages.hpp
 src/raft/snapshot_metadata.hpp
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,24 +0,0 @@
-repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v2.3.0
-    hooks:
-      - id: check-yaml
-      - id: end-of-file-fixer
-      - id: trailing-whitespace
-  - repo: https://github.com/psf/black
-    rev: 22.3.0
-    hooks:
-      - id: black
-        args: # arguments to configure black
-          - --line-length=120
-          - --include='\.pyi?$'
-          # these folders wont be formatted by black
-          - --exclude="""\.git |
-            \.__pycache__|
-            build|
-            libs|
-            .cache"""
-  - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v13.0.0
-    hooks:
-      - id: clang-format
--- a/1
+++ b/1
@@ -0,0 +1 @@
+* @antaljanosbenjamin @kostasrim
--- a/cmake/FindSodium.cmake
+++ b/cmake/FindSodium.cmake
@@ -0,0 +1,297 @@
+# Written in 2016 by Henrik Steffen Gaßmann <henrik@gassmann.onl>
+#
+# To the extent possible under law, the author(s) have dedicated all
+# copyright and related and neighboring rights to this software to the
+# public domain worldwide. This software is distributed without any warranty.
+#
+# You should have received a copy of the CC0 Public Domain Dedication
+# along with this software. If not, see
+#
+#     http://creativecommons.org/publicdomain/zero/1.0/
+#
+########################################################################
+# Tries to find the local libsodium installation.
+#
+# On Windows the sodium_DIR environment variable is used as a default
+# hint which can be overridden by setting the corresponding cmake variable.
+#
+# Once done the following variables will be defined:
+#
+#   sodium_FOUND
+#   sodium_INCLUDE_DIR
+#   sodium_LIBRARY_DEBUG
+#   sodium_LIBRARY_RELEASE
+#
+#
+# Furthermore an imported "sodium" target is created.
+#
+
+if (CMAKE_C_COMPILER_ID STREQUAL "GNU"
+    OR CMAKE_C_COMPILER_ID STREQUAL "Clang")
+    set(_GCC_COMPATIBLE 1)
+endif()
+
+# static library option
+if (NOT DEFINED sodium_USE_STATIC_LIBS)
+    option(sodium_USE_STATIC_LIBS "enable to statically link against sodium" OFF)
+endif()
+if(NOT (sodium_USE_STATIC_LIBS EQUAL sodium_USE_STATIC_LIBS_LAST))
+    unset(sodium_LIBRARY CACHE)
+    unset(sodium_LIBRARY_DEBUG CACHE)
+    unset(sodium_LIBRARY_RELEASE CACHE)
+    unset(sodium_DLL_DEBUG CACHE)
+    unset(sodium_DLL_RELEASE CACHE)
+    set(sodium_USE_STATIC_LIBS_LAST ${sodium_USE_STATIC_LIBS} CACHE INTERNAL "internal change tracking variable")
+endif()
+
+
+########################################################################
+# UNIX
+if (UNIX)
+    # import pkg-config
+    find_package(PkgConfig QUIET)
+    if (PKG_CONFIG_FOUND)
+        pkg_check_modules(sodium_PKG QUIET libsodium)
+    endif()
+
+    if(sodium_USE_STATIC_LIBS)
+        foreach(_libname ${sodium_PKG_STATIC_LIBRARIES})
+            if (NOT _libname MATCHES "^lib.*\\.a$") # ignore strings already ending with .a
+                list(INSERT sodium_PKG_STATIC_LIBRARIES 0 "lib${_libname}.a")
+            endif()
+        endforeach()
+        list(REMOVE_DUPLICATES sodium_PKG_STATIC_LIBRARIES)
+
+        # if pkgconfig for libsodium doesn't provide
+        # static lib info, then override PKG_STATIC here..
+        if (NOT sodium_PKG_STATIC_FOUND)
+            set(sodium_PKG_STATIC_LIBRARIES libsodium.a)
+        endif()
+
+        set(XPREFIX sodium_PKG_STATIC)
+    else()
+        if (NOT sodium_PKG_FOUND)
+            set(sodium_PKG_LIBRARIES sodium)
+        endif()
+
+        set(XPREFIX sodium_PKG)
+    endif()
+
+    find_path(sodium_INCLUDE_DIR sodium.h
+        HINTS ${${XPREFIX}_INCLUDE_DIRS}
+    )
+    find_library(sodium_LIBRARY_DEBUG NAMES ${${XPREFIX}_LIBRARIES}
+        HINTS ${${XPREFIX}_LIBRARY_DIRS}
+    )
+    find_library(sodium_LIBRARY_RELEASE NAMES ${${XPREFIX}_LIBRARIES}
+        HINTS ${${XPREFIX}_LIBRARY_DIRS}
+    )
+
+
+########################################################################
+# Windows
+elseif (WIN32)
+    set(sodium_DIR "$ENV{sodium_DIR}" CACHE FILEPATH "sodium install directory")
+    mark_as_advanced(sodium_DIR)
+
+    find_path(sodium_INCLUDE_DIR sodium.h
+        HINTS ${sodium_DIR}
+        PATH_SUFFIXES include
+    )
+
+    if (MSVC)
+        # detect target architecture
+        file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/arch.cpp" [=[
+            #if defined _M_IX86
+            #error ARCH_VALUE x86_32
+            #elif defined _M_X64
+            #error ARCH_VALUE x86_64
+            #endif
+            #error ARCH_VALUE unknown
+        ]=])
+        try_compile(_UNUSED_VAR "${CMAKE_CURRENT_BINARY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/arch.cpp"
+            OUTPUT_VARIABLE _COMPILATION_LOG
+        )
+        string(REGEX REPLACE ".*ARCH_VALUE ([a-zA-Z0-9_]+).*" "\\1" _TARGET_ARCH "${_COMPILATION_LOG}")
+
+        # construct library path
+        if (_TARGET_ARCH STREQUAL "x86_32")
+            string(APPEND _PLATFORM_PATH "Win32")
+        elseif(_TARGET_ARCH STREQUAL "x86_64")
+            string(APPEND _PLATFORM_PATH "x64")
+        else()
+            message(FATAL_ERROR "the ${_TARGET_ARCH} architecture is not supported by Findsodium.cmake.")
+        endif()
+        string(APPEND _PLATFORM_PATH "/$$CONFIG$$")
+
+        if (MSVC_VERSION LESS 1900)
+            math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 60")
+        else()
+            math(EXPR _VS_VERSION "${MSVC_VERSION} / 10 - 50")
+        endif()
+        string(APPEND _PLATFORM_PATH "/v${_VS_VERSION}")
+
+        if (sodium_USE_STATIC_LIBS)
+            string(APPEND _PLATFORM_PATH "/static")
+        else()
+            string(APPEND _PLATFORM_PATH "/dynamic")
+        endif()
+
+        string(REPLACE "$$CONFIG$$" "Debug" _DEBUG_PATH_SUFFIX "${_PLATFORM_PATH}")
+        string(REPLACE "$$CONFIG$$" "Release" _RELEASE_PATH_SUFFIX "${_PLATFORM_PATH}")
+
+        find_library(sodium_LIBRARY_DEBUG libsodium.lib
+            HINTS ${sodium_DIR}
+            PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX}
+        )
+        find_library(sodium_LIBRARY_RELEASE libsodium.lib
+            HINTS ${sodium_DIR}
+            PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX}
+        )
+        if (NOT sodium_USE_STATIC_LIBS)
+            set(CMAKE_FIND_LIBRARY_SUFFIXES_BCK ${CMAKE_FIND_LIBRARY_SUFFIXES})
+            set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll")
+            find_library(sodium_DLL_DEBUG libsodium
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES ${_DEBUG_PATH_SUFFIX}
+            )
+            find_library(sodium_DLL_RELEASE libsodium
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES ${_RELEASE_PATH_SUFFIX}
+            )
+            set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_BCK})
+        endif()
+
+    elseif(_GCC_COMPATIBLE)
+        if (sodium_USE_STATIC_LIBS)
+            find_library(sodium_LIBRARY_DEBUG libsodium.a
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES lib
+            )
+            find_library(sodium_LIBRARY_RELEASE libsodium.a
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES lib
+            )
+        else()
+            find_library(sodium_LIBRARY_DEBUG libsodium.dll.a
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES lib
+            )
+            find_library(sodium_LIBRARY_RELEASE libsodium.dll.a
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES lib
+            )
+
+            file(GLOB _DLL
+                LIST_DIRECTORIES false
+                RELATIVE "${sodium_DIR}/bin"
+                "${sodium_DIR}/bin/libsodium*.dll"
+            )
+            find_library(sodium_DLL_DEBUG ${_DLL} libsodium
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES bin
+            )
+            find_library(sodium_DLL_RELEASE ${_DLL} libsodium
+                HINTS ${sodium_DIR}
+                PATH_SUFFIXES bin
+            )
+        endif()
+    else()
+        message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
+    endif()
+
+
+########################################################################
+# unsupported
+else()
+    message(FATAL_ERROR "this platform is not supported by FindSodium.cmake")
+endif()
+
+
+########################################################################
+# common stuff
+
+# extract sodium version
+if (sodium_INCLUDE_DIR)
+    set(_VERSION_HEADER "${_INCLUDE_DIR}/sodium/version.h")
+    if (EXISTS _VERSION_HEADER)
+        file(READ "${_VERSION_HEADER}" _VERSION_HEADER_CONTENT)
+        string(REGEX REPLACE ".*#[ \t]*define[ \t]*SODIUM_VERSION_STRING[ \t]*\"([^\n]*)\".*" "\\1"
+            sodium_VERSION "${_VERSION_HEADER_CONTENT}")
+        set(sodium_VERSION "${sodium_VERSION}" PARENT_SCOPE)
+    endif()
+endif()
+
+# communicate results
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+    Sodium # The name must be either uppercase or match the filename case.
+    REQUIRED_VARS
+        sodium_LIBRARY_RELEASE
+        sodium_LIBRARY_DEBUG
+        sodium_INCLUDE_DIR
+    VERSION_VAR
+        sodium_VERSION
+)
+
+if(Sodium_FOUND)
+    set(sodium_LIBRARIES
+        optimized ${sodium_LIBRARY_RELEASE} debug ${sodium_LIBRARY_DEBUG})
+endif()
+
+# mark file paths as advanced
+mark_as_advanced(sodium_INCLUDE_DIR)
+mark_as_advanced(sodium_LIBRARY_DEBUG)
+mark_as_advanced(sodium_LIBRARY_RELEASE)
+if (WIN32)
+    mark_as_advanced(sodium_DLL_DEBUG)
+    mark_as_advanced(sodium_DLL_RELEASE)
+endif()
+
+# create imported target
+if(sodium_USE_STATIC_LIBS)
+    set(_LIB_TYPE STATIC)
+else()
+    set(_LIB_TYPE SHARED)
+endif()
+
+if(NOT TARGET sodium)
+    add_library(sodium ${_LIB_TYPE} IMPORTED)
+endif()
+
+set_target_properties(sodium PROPERTIES
+    INTERFACE_INCLUDE_DIRECTORIES "${sodium_INCLUDE_DIR}"
+    IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+)
+
+if (sodium_USE_STATIC_LIBS)
+    set_target_properties(sodium PROPERTIES
+        INTERFACE_COMPILE_DEFINITIONS "SODIUM_STATIC"
+        IMPORTED_LOCATION "${sodium_LIBRARY_RELEASE}"
+        IMPORTED_LOCATION_DEBUG "${sodium_LIBRARY_DEBUG}"
+    )
+else()
+    if (UNIX)
+        set_target_properties(sodium PROPERTIES
+            IMPORTED_LOCATION "${sodium_LIBRARY_RELEASE}"
+            IMPORTED_LOCATION_DEBUG "${sodium_LIBRARY_DEBUG}"
+        )
+    elseif (WIN32)
+        set_target_properties(sodium PROPERTIES
+            IMPORTED_IMPLIB "${sodium_LIBRARY_RELEASE}"
+            IMPORTED_IMPLIB_DEBUG "${sodium_LIBRARY_DEBUG}"
+        )
+        if (NOT (sodium_DLL_DEBUG MATCHES ".*-NOTFOUND"))
+            set_target_properties(sodium PROPERTIES
+                IMPORTED_LOCATION_DEBUG "${sodium_DLL_DEBUG}"
+            )
+        endif()
+        if (NOT (sodium_DLL_RELEASE MATCHES ".*-NOTFOUND"))
+            set_target_properties(sodium PROPERTIES
+                IMPORTED_LOCATION_RELWITHDEBINFO "${sodium_DLL_RELEASE}"
+                IMPORTED_LOCATION_MINSIZEREL "${sodium_DLL_RELEASE}"
+                IMPORTED_LOCATION_RELEASE "${sodium_DLL_RELEASE}"
+            )
+        endif()
+    endif()
+endif()
--- a/cmake/MgThrift.cmake
+++ b/cmake/MgThrift.cmake
@@ -0,0 +1,169 @@
+find_package(Gflags)
+find_package(Folly)
+find_package(wangle)
+find_package(fizz)
+find_package(proxygen)
+find_package(FBThrift)
+set(THRIFTCPP2 "FBThrift::thriftcpp2")
+set(THRIFT1 ${FBTHRIFT_COMPILER})
+
+include(${FBTHRIFT_INCLUDE_DIR}/thrift/ThriftLibrary.cmake)
+
+set(MG_INTERFACE_TARGET_NAME_PREFIX "mg-interface")
+
+function(_mg_thrift_generate
+  file_name
+  services
+  language
+  options
+  file_path
+  output_path
+  include_prefix
+)
+  cmake_parse_arguments(THRIFT_GENERATE   # Prefix
+    "" # Options
+    "" # One Value args
+    "THRIFT_INCLUDE_DIRECTORIES" # Multi-value args
+    "${ARGN}")
+
+  set(thrift_include_directories)
+  foreach(dir ${THRIFT_GENERATE_THRIFT_INCLUDE_DIRECTORIES})
+    list(APPEND thrift_include_directories "-I" "${dir}")
+  endforeach()
+
+  set("${file_name}-${language}-HEADERS"
+    ${output_path}/gen-${language}/${file_name}_constants.h
+    ${output_path}/gen-${language}/${file_name}_data.h
+    ${output_path}/gen-${language}/${file_name}_metadata.h
+    ${output_path}/gen-${language}/${file_name}_types.h
+    ${output_path}/gen-${language}/${file_name}_types.tcc
+  )
+  set("${file_name}-${language}-SOURCES"
+    ${output_path}/gen-${language}/${file_name}_constants.cpp
+    ${output_path}/gen-${language}/${file_name}_data.cpp
+    ${output_path}/gen-${language}/${file_name}_types.cpp
+  )
+  if(NOT "${options}" MATCHES "no_metadata")
+    set("${file_name}-${language}-SOURCES"
+      ${${file_name}-${language}-SOURCES}
+      ${output_path}/gen-${language}/${file_name}_metadata.cpp
+    )
+  endif()
+  foreach(service ${services})
+    set("${file_name}-${language}-HEADERS"
+      ${${file_name}-${language}-HEADERS}
+      ${output_path}/gen-${language}/${service}.h
+      ${output_path}/gen-${language}/${service}.tcc
+      ${output_path}/gen-${language}/${service}AsyncClient.h
+      ${output_path}/gen-${language}/${service}_custom_protocol.h
+    )
+    set("${file_name}-${language}-SOURCES"
+      ${${file_name}-${language}-SOURCES}
+      ${output_path}/gen-${language}/${service}.cpp
+      ${output_path}/gen-${language}/${service}AsyncClient.cpp
+    )
+  endforeach()
+  if("${include_prefix}" STREQUAL "")
+    set(include_prefix_text "")
+  else()
+    set(include_prefix_text "include_prefix=${include_prefix}")
+    if(NOT "${options}" STREQUAL "")
+      set(include_prefix_text ",${include_prefix_text}")
+    endif()
+  endif()
+  set(gen_language ${language})
+  if("${language}" STREQUAL "cpp2")
+    set(gen_language "mstch_cpp2")
+  elseif("${language}" STREQUAL "py3")
+    set(gen_language "mstch_py3")
+    file(WRITE "${output_path}/gen-${language}/${file_name}/__init__.py")
+  endif()
+  add_custom_command(
+    OUTPUT ${${file_name}-${language}-HEADERS}
+      ${${file_name}-${language}-SOURCES}
+    COMMAND ${THRIFT1}
+      --gen "${gen_language}:${options}${include_prefix_text}"
+      -o ${output_path}
+      ${thrift_include_directories}
+      "${file_path}/${file_name}.thrift"
+    DEPENDS
+      ${THRIFT1}
+      "${file_path}/${file_name}.thrift"
+    COMMENT "Generating ${MG_INTERFACE_TARGET_NAME_PREFIX}-${file_name}-${language} files. Output: ${output_path}"
+  )
+  add_custom_target(
+    ${MG_INTERFACE_TARGET_NAME_PREFIX}-${file_name}-${language}-target ALL
+    DEPENDS ${${language}-${language}-HEADERS}
+      ${${file_name}-${language}-SOURCES}
+  )
+
+  set("${file_name}-${language}-SOURCES" ${${file_name}-${language}-SOURCES} PARENT_SCOPE)
+  install(
+    DIRECTORY gen-${language}
+    DESTINATION include/${include_prefix}
+    FILES_MATCHING PATTERN "*.h")
+  install(
+    DIRECTORY gen-${language}
+    DESTINATION include/${include_prefix}
+    FILES_MATCHING PATTERN "*.tcc")
+endfunction()
+
+
+function(_mg_thrift_object
+  file_name
+  services
+  language
+  options
+  file_path
+  output_path
+  include_prefix
+)
+  _mg_thrift_generate(
+    "${file_name}"
+    "${services}"
+    "${language}"
+    "${options}"
+    "${file_path}"
+    "${output_path}"
+    "${include_prefix}"
+    "${ARGN}"
+  )
+  bypass_source_check(${${file_name}-${language}-SOURCES})
+  add_library(
+    "${MG_INTERFACE_TARGET_NAME_PREFIX}-${file_name}-${language}-obj"
+    OBJECT
+    ${${file_name}-${language}-SOURCES}
+  )
+  add_dependencies(
+    "${MG_INTERFACE_TARGET_NAME_PREFIX}-${file_name}-${language}-obj"
+    "${MG_INTERFACE_TARGET_NAME_PREFIX}-${file_name}-${language}-target"
+  )
+  target_include_directories(${MG_INTERFACE_TARGET_NAME_PREFIX}-${file_name}-${language}-obj PUBLIC ${output_path})
+  message(STATUS "MgThrift will create the Object file : ${MG_INTERFACE_TARGET_NAME_PREFIX}-${file_name}-${language}-obj")
+endfunction()
+
+function(mg_thrift_library
+  file_name
+  services
+  file_path
+  output_path
+  include_prefix
+)
+  _mg_thrift_object(
+    "${file_name}"
+    "${services}"
+    "cpp2"
+    "stack_arguments" # options
+    "${file_path}"
+    "${output_path}"
+    "${include_prefix}"
+    THRIFT_INCLUDE_DIRECTORIES "${FBTHRIFT_INCLUDE_DIR}"
+  )
+  set(LIBRARY_NAME "${MG_INTERFACE_TARGET_NAME_PREFIX}-${file_name}-cpp2")
+  add_library(
+    "${LIBRARY_NAME}"
+    $<TARGET_OBJECTS:${LIBRARY_NAME}-obj>
+  )
+  target_link_libraries("${LIBRARY_NAME}" ${THRIFTCPP2})
+  message("MgThrift will create the library file : ${LIBRARY_NAME}")
+endfunction()
--- a/config/flags.yaml
+++ b/config/flags.yaml
@@ -47,14 +47,6 @@ modifications:
    value: ""
    override: false

-  - name: "bolt_cert_file"
-    value: "/etc/memgraph/ssl/cert.pem"
-    override: false
-
-  - name: "bolt_key_file"
-    value: "/etc/memgraph/ssl/key.pem"
-    override: false
-
  - name: "storage_properties_on_edges"
    value: "true"
    override: true
--- a/environment/os/centos-7.sh
+++ b/environment/os/centos-7.sh
@@ -5,9 +5,6 @@ set -Eeuo pipefail
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 source "$DIR/../util.sh"

-check_operating_system "centos-7"
-check_architecture "x86_64"
-
 TOOLCHAIN_BUILD_DEPS=(
    coreutils gcc gcc-c++ make # generic build tools
    wget # used for archive download
--- a/environment/os/centos-8.sh
+++ b/environment/os/centos-8.sh
@@ -0,0 +1,161 @@
+#!/bin/bash
+
+set -Eeuo pipefail
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+source "$DIR/../util.sh"
+
+TOOLCHAIN_BUILD_DEPS=(
+    coreutils-common 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 libipt-devel libbabeltrace-devel xz-devel python36-devel texinfo # for gdb
+    libcurl-devel # for cmake
+    curl # snappy
+    readline-devel # for cmake and llvm
+    libffi-devel libxml2-devel # for llvm
+    libedit-devel pcre-devel automake bison # for swig
+    file
+    openssl-devel
+    gmp-devel
+    gperf
+    patch
+)
+
+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
+    openssl-devel
+)
+
+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
+    libtool  # for protobuf 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).
+        # http://mirror.centos.org/centos/8/PowerTools/x86_64/os/Packages/libbabeltrace-devel-1.5.4-3.el8.x86_64.rpm not working
+        if [ "$pkg" == libbabeltrace-devel ]; then
+            if ! dnf list installed libbabeltrace-devel >/dev/null 2>/dev/null; then
+                dnf install -y https://rpmfind.net/linux/centos/8-stream/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}"
--- a/environment/os/centos-9.sh
+++ b/environment/os/centos-9.sh
@@ -5,16 +5,15 @@ set -Eeuo pipefail
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 source "$DIR/../util.sh"

-check_operating_system "centos-9"
-check_architecture "x86_64"
-
 TOOLCHAIN_BUILD_DEPS=(
-    coreutils-common gcc gcc-c++ make # generic build tools
+    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 xz-devel python3-devel texinfo libbabeltrace-devel # for gdb
+    expat-devel xz-devel python3-devel texinfo # for gdb
+    libcurl-devel # for cmake
+    curl # snappy
    readline-devel # for cmake and llvm
    libffi-devel libxml2-devel # for llvm
    libedit-devel pcre-devel automake bison # for swig
@@ -22,9 +21,6 @@ TOOLCHAIN_BUILD_DEPS=(
    openssl-devel
    gmp-devel
    gperf
-    diffutils
-    libipt libipt-devel # intel
-    patch
 )

 TOOLCHAIN_RUN_DEPS=(
@@ -35,19 +31,18 @@ TOOLCHAIN_RUN_DEPS=(
    readline # for cmake and llvm
    libffi libxml2 # for llvm
    openssl-devel
-    perl # for openssl
 )

 MEMGRAPH_BUILD_DEPS=(
    git # source code control
    make pkgconf-pkg-config # build system
-    wget # for downloading libs
+    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 python3-pip python3-virtualenv nmap-ncat # for qa, macro_benchmark and stress tests
+    python3 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`
@@ -78,6 +73,12 @@ check() {
        if [ "$pkg" == "python3-virtualenv" ]; then
            continue
        fi
+        if [ "$pkg" == sbcl ]; then
+            if ! sbcl --version &> /dev/null; then
+	        missing="$pkg $missing"
+            fi
+            continue
+        fi
        if ! yum list installed "$pkg" >/dev/null 2>/dev/null; then
            missing="$pkg $missing"
        fi
@@ -104,37 +105,13 @@ install() {
    yum update -y
    yum install -y wget git python3 python3-pip
    for pkg in $1; do
-        # Since there is no support for libipt-devel for CentOS 9 we install
-        # Fedoras version of same libs, they are the same version but released
-        # for different OS
-        # TODO Update when libipt-devel releases for CentOS 9
-        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 ! dnf 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
-        if [ "$pkg" == libbabeltrace-devel ]; then
-            if ! dnf list installed libbabeltrace-devel >/dev/null 2>/dev/null; then
-                dnf install -y http://mirror.stream.centos.org/9-stream/CRB/x86_64/os/Packages/libbabeltrace-devel-1.5.8-10.el9.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
+            if ! sbcl --version &> /dev/null; then
+	        curl -s https://altushost-swe.dl.sourceforge.net/project/sbcl/sbcl/1.4.2/sbcl-1.4.2-arm64-linux-binary.tar.bz2 -o /tmp/sbcl-arm64.tar.bz2
+		tar xvjf /tmp/sbcl-arm64.tar.bz2 -C /tmp
+		pushd /tmp/sbcl-1.4.2-arm64-linux
+		INSTALL_ROOT=/usr/local sh install.sh
+		popd
            fi
            continue
        fi
@@ -148,11 +125,9 @@ install() {
        fi
        if [ "$pkg" == python3-virtualenv ]; then
            if [ -z ${SUDO_USER+x} ]; then # Running as root (e.g. Docker).
-                pip3 install virtualenv
-                pip3 install virtualenvwrapper
+                pip3 install --user virtualenv
            else # Running using sudo.
-                sudo -H -u "$SUDO_USER" bash -c "pip3 install virtualenv"
-                sudo -H -u "$SUDO_USER" bash -c "pip3 install virtualenvwrapper"
+                sudo -H -u "$SUDO_USER" bash -c "pip3 install --user virtualenv"
            fi
            continue
        fi
--- a/environment/os/debian-10.sh
+++ b/environment/os/debian-10.sh
@@ -5,9 +5,6 @@ set -Eeuo pipefail
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 source "$DIR/../util.sh"

-check_operating_system "debian-10"
-check_architecture "x86_64"
-
 TOOLCHAIN_BUILD_DEPS=(
    coreutils gcc g++ build-essential make # generic build tools
    wget # used for archive download
--- a/environment/os/debian-11-arm.sh
+++ b/environment/os/debian-11-arm.sh
@@ -5,9 +5,6 @@ set -Eeuo pipefail
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 source "$DIR/../util.sh"

-check_operating_system "debian-11"
-check_architecture "arm64"
-
 TOOLCHAIN_BUILD_DEPS=(
    coreutils gcc g++ build-essential make # generic build tools
    wget # used for archive download
@@ -90,6 +87,15 @@ EOF
    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
 }
--- a/environment/os/debian-11.sh
+++ b/environment/os/debian-11.sh
@@ -5,9 +5,6 @@ set -Eeuo pipefail
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 source "$DIR/../util.sh"

-check_operating_system "debian-11"
-check_architecture "x86_64"
-
 TOOLCHAIN_BUILD_DEPS=(
    coreutils gcc g++ build-essential make # generic build tools
    wget # used for archive download
@@ -90,7 +87,7 @@ EOF
    fi
    apt install -y wget
    for pkg in $1; do
-        if [ "$pkg" == dotnet-sdk-3.1  ]; then
+        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
--- a/environment/os/template.sh
+++ b/environment/os/template.sh
@@ -5,8 +5,6 @@ set -Eeuo pipefail
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 source "$DIR/../util.sh"

-check_operating_system "todo-os-name"
-
 TOOLCHAIN_BUILD_DEPS=(
    pkg
 )
--- a/environment/os/ubuntu-18.04.sh
+++ b/environment/os/ubuntu-18.04.sh
@@ -5,9 +5,6 @@ set -Eeuo pipefail
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 source "$DIR/../util.sh"

-check_operating_system "ubuntu-18.04"
-check_architecture "x86_64"
-
 TOOLCHAIN_BUILD_DEPS=(
    coreutils gcc g++ build-essential make # generic build tools
    wget # archive download
--- a/environment/os/ubuntu-20.04.sh
+++ b/environment/os/ubuntu-20.04.sh
@@ -5,9 +5,6 @@ set -Eeuo pipefail
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 source "$DIR/../util.sh"

-check_operating_system "ubuntu-20.04"
-check_architecture "x86_64"
-
 TOOLCHAIN_BUILD_DEPS=(
    coreutils gcc g++ build-essential make # generic build tools
    wget # used for archive download
--- a/environment/os/ubuntu-22.04.sh
+++ b/environment/os/ubuntu-22.04.sh
@@ -1,96 +0,0 @@
-#!/bin/bash
-
-set -Eeuo pipefail
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-source "$DIR/../util.sh"
-
-check_operating_system "ubuntu-22.04"
-check_architecture "x86_64"
-
-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
-    curl # snappy
-    file
-    git # for thrift
-    libgmp-dev # for gdb
-    gperf # for proxygen
-    libssl-dev
-    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
-    libssl-dev # for libevent
-)
-
-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-6.0 golang nodejs npm
-    autoconf # for jemalloc code generation
-    libtool  # for protobuf 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-6.0 ]; then
-            if ! dpkg -s dotnet-sdk-6.0 2>/dev/null >/dev/null; then
-                wget -nv https://packages.microsoft.com/config/ubuntu/22.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-6.0
-            fi
-            continue
-        fi
-        apt install -y "$pkg"
-    done
-}
-
-deps=$2"[*]"
-"$1" "${!deps}"
--- a/environment/toolchain/v4.sh
+++ b/environment/toolchain/v4.sh
@@ -675,7 +675,7 @@ PROXYGEN_SHA256=5360a8ccdfb2f5a6c7b3eed331ec7ab0e2c792d579c6fff499c85c516c11fe14
 SNAPPY_SHA256=75c1fbb3d618dd3a0483bff0e26d0a92b495bbe5059c8b4f1c962b478b6e06e7
 SNAPPY_VERSION=1.1.9
 XZ_VERSION=5.2.5 # for LZMA
-ZLIB_VERSION=1.2.12
+ZLIB_VERSION=1.2.11
 ZSTD_VERSION=1.5.0
 WANGLE_SHA256=1002e9c32b6f4837f6a760016e3b3e22f3509880ef3eaad191c80dc92655f23f

@@ -1178,21 +1178,12 @@ popd

 # create toolchain archive
 if [ ! -f $NAME-binaries-$DISTRO.tar.gz ]; then
-    DISTRO_FULL_NAME=${DISTRO}
-    if [[ "${DISTRO}" == centos* ]]; then
-        if [[ "$for_arm" = "true" ]]; then
-            DISTRO_FULL_NAME="$DISTRO_FULL_NAME-aarch64"
-        else
-            DISTRO_FULL_NAME="$DISTRO_FULL_NAME-x86_64"
-        fi
+    DISTRO_FULL_NAME=$DISTRO
+    if [ "$for_arm" = true ]; then
+        DISTRO_FULL_NAME="$DISTRO_FULL_NAME-aarch64"
    else
-        if [[ "$for_arm" = "true" ]]; then
-            DISTRO_FULL_NAME="$DISTRO_FULL_NAME-arm64"
-        else
-            DISTRO_FULL_NAME="$DISTRO_FULL_NAME-amd64"
-        fi
+        DISTRO_FULL_NAME="$DISTRO_FULL_NAME-x86_64"
    fi
-
    tar --owner=root --group=root -cpvzf $NAME-binaries-$DISTRO_FULL_NAME.tar.gz -C /opt $NAME
 fi

--- a/environment/util.sh
+++ b/environment/util.sh
@@ -5,28 +5,10 @@ operating_system() {
    sort | cut -d '=' -f 2- | sed 's/"//g' | paste -s -d '-'
 }

-check_operating_system() {
-    if [ "$(operating_system)" != "$1" ]; then
-        echo "Not the right operating system!"
-        exit 1
-    else
-        echo "The right operating system."
-    fi
-}
-
 architecture() {
    uname -m
 }

-check_architecture() {
-    if [ "$(architecture)" != "$1" ]; then
-        echo "Not the right architecture!"
-        exit 1
-    else
-        echo "The right architecture."
-    fi
-}
-
 check_all_yum() {
    local missing=""
    for pkg in $1; do
--- a/include/mg_procedure.h
+++ b/include/mg_procedure.h
--- a/include/mgp.py
+++ b/include/mgp.py
--- a/11
+++ b/11
@@ -24,7 +24,7 @@ function setup_virtualenv () {
    fi

    # create new virtualenv
-    python3 -m virtualenv -p python3 ve3 || exit 1
+    virtualenv -p python3 ve3 || exit 1
    source ve3/bin/activate
    pip --timeout 1000 install -r requirements.txt || exit 1
    deactivate
@@ -66,7 +66,7 @@ fi

 DISTRO=$(operating_system)
 ARCHITECTURE=$(architecture)
-if [ "${ARCHITECTURE}" = "arm64" ] || [ "${ARCHITECTURE}" = "aarch64" ]; then
+if [ "${ARCHITECTURE}" = "arm64" ]; then
  OS_SCRIPT=$DIR/environment/os/$DISTRO-arm.sh
 else
  OS_SCRIPT=$DIR/environment/os/$DISTRO.sh
@@ -135,10 +135,3 @@ for hook in $(find $DIR/.githooks -type f -printf "%f\n"); do
  ln -s -f "$DIR/.githooks/$hook" "$DIR/.git/hooks/$hook"
  echo "Added $hook hook"
 done;
-
-# Install precommit hook
-python3 -m pip install pre-commit
-python3 -m pre_commit install
-
-# Link `include/mgp.py` with `release/mgp/mgp.py`
-ln -v -f include/mgp.py release/mgp/mgp.py
--- a/libs/.gitignore
+++ b/libs/.gitignore
@@ -4,5 +4,5 @@
 !cleanup.sh
 !CMakeLists.txt
 !__main.cpp
+!jemalloc.cmake
 !pulsar.patch
-!antlr4.10.1.patch
--- a/libs/CMakeLists.txt
+++ b/libs/CMakeLists.txt
@@ -106,7 +106,6 @@ import_external_library(antlr4 STATIC
             -DWITH_LIBCXX=OFF # because of debian bug
             -DCMAKE_SKIP_INSTALL_ALL_DEPENDENCY=true
             -DCMAKE_CXX_STANDARD=20
-             -DANTLR_BUILD_CPP_TESTS=OFF
  BUILD_COMMAND $(MAKE) antlr4_static
  INSTALL_COMMAND $(MAKE) install)

--- a/libs/antlr4.10.1.patch
+++ b/libs/antlr4.10.1.patch
@@ -1,13 +0,0 @@
-diff --git a/runtime/Cpp/runtime/CMakeLists.txt b/runtime/Cpp/runtime/CMakeLists.txt
-index baf46cac9..2e7756de8 100644
--- a/runtime/Cpp/runtime/CMakeLists.txt
-+++ b/runtime/Cpp/runtime/CMakeLists.txt
-@@ -134,7 +134,7 @@ set_target_properties(antlr4_static
-                                  ARCHIVE_OUTPUT_DIRECTORY ${LIB_OUTPUT_DIR}
-                                  COMPILE_FLAGS "${disabled_compile_warnings} ${extra_static_compile_flags}")
-
-install(TARGETS antlr4_shared
-+install(TARGETS antlr4_shared OPTIONAL
-         EXPORT antlr4-targets
-         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
--- a/libs/antlr4.patch
+++ b/libs/antlr4.patch
@@ -0,0 +1,43 @@
+diff --git a/runtime/Cpp/runtime/CMakeLists.txt b/runtime/Cpp/runtime/CMakeLists.txt
+index a8503bb..11362cf 100644
+--- a/runtime/Cpp/runtime/CMakeLists.txt
+++ b/runtime/Cpp/runtime/CMakeLists.txt
+@@ -5,8 +5,8 @@ set(THIRDPARTY_DIR ${CMAKE_BINARY_DIR}/runtime/thirdparty)
+ set(UTFCPP_DIR ${THIRDPARTY_DIR}/utfcpp)
+ ExternalProject_Add(
+   utfcpp
+-  GIT_REPOSITORY        "git://github.com/nemtrif/utfcpp"
+-  GIT_TAG               "v3.1.1"
+  GIT_REPOSITORY        "https://github.com/nemtrif/utfcpp"
+  GIT_TAG               "v3.2.1"
+   SOURCE_DIR            ${UTFCPP_DIR}
+   UPDATE_DISCONNECTED   1
+   CMAKE_ARGS            -DCMAKE_INSTALL_PREFIX=${UTFCPP_DIR}/install -Dgtest_force_shared_crt=ON
+@@ -118,7 +118,7 @@ set_target_properties(antlr4_static
+                                  ARCHIVE_OUTPUT_DIRECTORY ${LIB_OUTPUT_DIR}
+                                  COMPILE_FLAGS "${disabled_compile_warnings} ${extra_static_compile_flags}")
+ 
+-install(TARGETS antlr4_shared
+install(TARGETS antlr4_shared OPTIONAL
+         DESTINATION lib
+         EXPORT antlr4-targets)
+ install(TARGETS antlr4_static
+diff --git a/runtime/Cpp/runtime/src/support/Any.h b/runtime/Cpp/runtime/src/support/Any.h
+index 468db98..65a473b 100644
+--- a/runtime/Cpp/runtime/src/support/Any.h
+++ b/runtime/Cpp/runtime/src/support/Any.h
+@@ -122,12 +122,12 @@ private:
+     }
+ 
+   private:
+-    template<int N = 0, typename std::enable_if<N == N && std::is_nothrow_copy_constructible<T>::value, int>::type = 0>
+    template<int N = 0, typename std::enable_if<N == N && std::is_copy_constructible<T>::value, int>::type = 0>
+     Base* clone() const {
+       return new Derived<T>(value);
+     }
+ 
+-    template<int N = 0, typename std::enable_if<N == N && !std::is_nothrow_copy_constructible<T>::value, int>::type = 0>
+    template<int N = 0, typename std::enable_if<N == N && !std::is_copy_constructible<T>::value, int>::type = 0>
+     Base* clone() const {
+       return nullptr;
+     }
--- a/libs/jemalloc.cmake
+++ b/libs/jemalloc.cmake
@@ -0,0 +1,55 @@
+set(JEMALLOC_DIR "${LIB_DIR}/jemalloc")
+
+set(JEMALLOC_SRCS
+    ${JEMALLOC_DIR}/src/arena.c
+    ${JEMALLOC_DIR}/src/background_thread.c
+    ${JEMALLOC_DIR}/src/base.c
+    ${JEMALLOC_DIR}/src/bin.c
+    ${JEMALLOC_DIR}/src/bitmap.c
+    ${JEMALLOC_DIR}/src/ckh.c
+    ${JEMALLOC_DIR}/src/ctl.c
+    ${JEMALLOC_DIR}/src/div.c
+    ${JEMALLOC_DIR}/src/extent.c
+    ${JEMALLOC_DIR}/src/extent_dss.c
+    ${JEMALLOC_DIR}/src/extent_mmap.c
+    ${JEMALLOC_DIR}/src/hash.c
+    ${JEMALLOC_DIR}/src/hook.c
+    ${JEMALLOC_DIR}/src/jemalloc.c
+    ${JEMALLOC_DIR}/src/large.c
+    ${JEMALLOC_DIR}/src/log.c
+    ${JEMALLOC_DIR}/src/malloc_io.c
+    ${JEMALLOC_DIR}/src/mutex.c
+    ${JEMALLOC_DIR}/src/mutex_pool.c
+    ${JEMALLOC_DIR}/src/nstime.c
+    ${JEMALLOC_DIR}/src/pages.c
+    ${JEMALLOC_DIR}/src/prng.c
+    ${JEMALLOC_DIR}/src/prof.c
+    ${JEMALLOC_DIR}/src/rtree.c
+    ${JEMALLOC_DIR}/src/sc.c
+    ${JEMALLOC_DIR}/src/stats.c
+    ${JEMALLOC_DIR}/src/sz.c
+    ${JEMALLOC_DIR}/src/tcache.c
+    ${JEMALLOC_DIR}/src/test_hooks.c
+    ${JEMALLOC_DIR}/src/ticker.c
+    ${JEMALLOC_DIR}/src/tsd.c
+    ${JEMALLOC_DIR}/src/witness.c
+    ${JEMALLOC_DIR}/src/safety_check.c
+)
+
+add_library(jemalloc ${JEMALLOC_SRCS})
+target_include_directories(jemalloc PUBLIC "${JEMALLOC_DIR}/include")
+
+find_package(Threads REQUIRED)
+target_link_libraries(jemalloc PUBLIC Threads::Threads)
+
+target_compile_definitions(jemalloc PRIVATE -DJEMALLOC_NO_PRIVATE_NAMESPACE)
+
+if (CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+    target_compile_definitions(jemalloc PRIVATE -DJEMALLOC_DEBUG=1 -DJEMALLOC_PROF=1)
+endif()
+
+target_compile_options(jemalloc PRIVATE -Wno-redundant-decls)
+# for RTLD_NEXT
+target_compile_definitions(jemalloc PRIVATE _GNU_SOURCE)
+
+set_property(TARGET jemalloc APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS USE_JEMALLOC=1)
--- a/libs/setup.sh
+++ b/libs/setup.sh
@@ -105,7 +105,7 @@ repo_clone_try_double () {
 # Download from primary_urls might fail because the cache is not installed.
 declare -A primary_urls=(
  ["antlr4-code"]="http://$local_cache_host/git/antlr4.git"
-  ["antlr4-generator"]="http://$local_cache_host/file/antlr-4.10.1-complete.jar"
+  ["antlr4-generator"]="http://$local_cache_host/file/antlr-4.9.2-complete.jar"
  ["cppitertools"]="http://$local_cache_host/git/cppitertools.git"
  ["rapidcheck"]="http://$local_cache_host/git/rapidcheck.git"
  ["gbenchmark"]="http://$local_cache_host/git/benchmark.git"
@@ -130,7 +130,7 @@ declare -A primary_urls=(
 # should fail.
 declare -A secondary_urls=(
  ["antlr4-code"]="https://github.com/antlr/antlr4.git"
-  ["antlr4-generator"]="https://www.antlr.org/download/antlr-4.10.1-complete.jar"
+  ["antlr4-generator"]="http://www.antlr.org/download/antlr-4.9.2-complete.jar"
  ["cppitertools"]="https://github.com/ryanhaining/cppitertools.git"
  ["rapidcheck"]="https://github.com/emil-e/rapidcheck.git"
  ["gbenchmark"]="https://github.com/google/benchmark.git"
@@ -152,10 +152,10 @@ declare -A secondary_urls=(
 # antlr
 file_get_try_double "${primary_urls[antlr4-generator]}" "${secondary_urls[antlr4-generator]}"

-antlr4_tag="4.10.1" # v4.10.1
+antlr4_tag="4.9.2" # v4.9.2
 repo_clone_try_double "${primary_urls[antlr4-code]}" "${secondary_urls[antlr4-code]}" "antlr4" "$antlr4_tag" true
 pushd antlr4
-git apply ../antlr4.10.1.patch
+git apply ../antlr4.patch
 popd

 # cppitertools v2.0 2019-12-23
@@ -199,7 +199,7 @@ git apply ../rocksdb.patch
 popd

 # mgclient
-mgclient_tag="v1.4.0" # (2022-06-14)
+mgclient_tag="96e95c6845463cbe88948392be58d26da0d5ffd3" # (2022-02-08)
 repo_clone_try_double "${primary_urls[mgclient]}" "${secondary_urls[mgclient]}" "mgclient" "$mgclient_tag"
 sed -i 's/\${CMAKE_INSTALL_LIBDIR}/lib/' mgclient/src/CMakeLists.txt

--- a/release/CMakeLists.txt
+++ b/release/CMakeLists.txt
@@ -41,7 +41,7 @@ set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}
 applications driver by real-time connected data.")
 # Add `openssl` package to dependencies list. Used to generate SSL certificates.
 # We also depend on `python3` because we embed it in Memgraph.
-set(CPACK_DEBIAN_PACKAGE_DEPENDS "openssl (>= 1.1.0), python3 (>= 3.5.0), libstdc++6")
+set(CPACK_DEBIAN_PACKAGE_DEPENDS "openssl (>= 1.1.0), python3 (>= 3.5.0)")

 # Setting arhitecture extension for rpm packages
 set(MG_ARCH_EXTENSION_RPM "noarch")
@@ -67,7 +67,7 @@ It aims to deliver developers the speed, simplicity and scale required to build
 the next generation of applications driver by real-time connected data.")
 # Add `openssl` package to dependencies list. Used to generate SSL certificates.
 # We also depend on `python3` because we embed it in Memgraph.
-set(CPACK_RPM_PACKAGE_REQUIRES "openssl >= 1.0.0, curl >= 7.29.0, python3 >= 3.5.0, libstdc >= 6, logrotate")
+set(CPACK_RPM_PACKAGE_REQUIRES "openssl >= 1.0.0, curl >= 7.29.0, python3 >= 3.5.0")

 # All variables must be set before including.
 include(CPack)
--- a/release/docker/memgraph_rpm.dockerfile
+++ b/release/docker/memgraph_rpm.dockerfile
@@ -0,0 +1,31 @@
+FROM dokken/centos-stream-9
+# NOTE: If you change the base distro update release/package as well.
+
+ARG release
+
+RUN yum update && yum install -y \
+    openssl libcurl libseccomp python3 python3-pip \
+    --nobest --allowerasing \
+  && rm -rf /tmp/* \
+  && yum clean all
+
+RUN pip3 install networkx==2.4 numpy==1.21.4 scipy==1.7.3
+
+COPY ${release} /
+
+# Install memgraph package
+RUN rpm -i ${release}
+
+# Memgraph listens for Bolt Protocol on this port by default.
+EXPOSE 7687
+# Snapshots and logging volumes
+VOLUME /var/log/memgraph
+VOLUME /var/lib/memgraph
+# Configuration volume
+VOLUME /etc/memgraph
+
+USER memgraph
+WORKDIR /usr/lib/memgraph
+
+ENTRYPOINT ["/usr/lib/memgraph/memgraph"]
+CMD [""]
--- a/release/mgp/.gitignore
+++ b/release/mgp/.gitignore
@@ -1,3 +0,0 @@
-.venv
-dist
-mgp.py
--- a/release/mgp/LICENSE
+++ b/release/mgp/LICENSE
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
--- a/release/mgp/README.md
+++ b/release/mgp/README.md
@@ -1,4 +0,0 @@
-# mgp
-
-PyPi package used for type hinting when creating MAGE modules. The get started
-using MAGE repository checkout the repository here: https://github.com/memgraph/mage.
--- a/release/mgp/_mgp.py
+++ b/release/mgp/_mgp.py
@@ -1,255 +0,0 @@
-from typing import Any
-
-
-class MgpIterable:
-    def get() -> Any:
-        pass
-
-    def next() -> Any:
-        pass
-
-
-class Vertex:
-    def is_valid() -> bool:  # type: ignore
-        pass
-
-    def underlying_graph_is_mutable() -> bool:  # type: ignore
-        pass
-
-    def iter_properties() -> MgpIterable:  # type: ignore
-        pass
-
-    def get_property(self, property_name: str) -> "Property":  # type: ignore
-        pass
-
-    def set_property(self, property_name: str, value: Any) -> "Property":  # type: ignore
-        pass
-
-    def get_id() -> "VertexId":  # type: ignore
-        pass
-
-    def label_at(self, index: int) -> "Label":  # type: ignore
-        pass
-
-    def labels_count() -> int:  # type: ignore
-        pass
-
-    def add_label(self, label: Any):
-        pass
-
-    def remove_label(self, label: Any):
-        pass
-
-    def iter_in_edges() -> MgpIterable:  # type: ignore
-        pass
-
-    def iter_out_edges() -> MgpIterable:  # type: ignore
-        pass
-
-
-class Edge:
-    def is_valid() -> bool:  # type: ignore
-        pass
-
-    def underlying_graph_is_mutable() -> bool:  # type: ignore
-        pass
-
-    def iter_properties() -> MgpIterable:  # type: ignore
-        pass
-
-    def get_property(self, property_name: str) -> "Property":  # type: ignore
-        pass
-
-    def set_property(self, property_name: str, valuse: Any) -> "Property":  # type: ignore
-        pass
-
-    def get_type_name() -> str:  # type: ignore
-        pass
-
-    def get_id() -> "EdgeId":  # type: ignore
-        pass
-
-    def from_vertex() -> Vertex:  # type: ignore
-        pass
-
-    def to_vertex() -> Vertex:  # type: ignore
-        pass
-
-
-class Path:
-    def is_valid() -> bool:  # type: ignore
-        pass
-
-    @staticmethod
-    def make_with_start(vertex: Vertex) -> "Path":  # type: ignore
-        pass
-
-
-class Graph:
-    def is_valid() -> bool:  # type: ignore
-        pass
-
-
-class CypherType:
-    pass
-
-
-class Message:
-    def is_valid() -> bool:  # type: ignore
-        pass
-
-    def source_type() -> str:  # type: ignore
-        pass
-
-    def topic_name() -> str:  # type: ignore
-        pass
-
-    def key() -> bytes:  # type: ignore
-        pass
-
-    def timestamp() -> int:  # type: ignore
-        pass
-
-    def offset() -> int:  # type: ignore
-        pass
-
-    def payload() -> bytes:  # type: ignore
-        pass
-
-
-class Messages:
-    def is_valid() -> bool:  # type: ignore
-        pass
-
-    def message_at(self, id: int) -> Message:  # type: ignore
-        pass
-
-    def total_messages() -> int:  # type: ignore
-        pass
-
-
-class UnknownError(Exception):
-    pass
-
-
-class UnableToAllocateError(Exception):
-    pass
-
-
-class InsufficientBufferError(Exception):
-    pass
-
-
-class OutOfRangeError(Exception):
-    pass
-
-
-class LogicErrorError(Exception):
-
-    pass
-
-
-class DeletedObjectError(Exception):
-    pass
-
-
-class InvalidArgumentError(Exception):
-    pass
-
-
-class KeyAlreadyExistsError(Exception):
-    pass
-
-
-class ImmutableObjectError(Exception):
-    pass
-
-
-class ValueConversionError(Exception):
-    pass
-
-
-class SerializationError(Exception):
-    pass
-
-
-def type_nullable(elem: Any):
-    pass
-
-
-def type_list(elem: Any):
-    pass
-
-
-def type_bool():
-    pass
-
-
-def type_string():
-    pass
-
-
-def type_int():
-    pass
-
-
-def type_float():
-    pass
-
-
-def type_number():
-    pass
-
-
-def type_map():
-    pass
-
-
-def type_node():
-    pass
-
-
-def type_relationship():
-    pass
-
-
-def type_path():
-    pass
-
-
-def type_date():
-    pass
-
-
-def type_local_time():
-    pass
-
-
-def type_local_date_time():
-    pass
-
-
-def type_duration():
-    pass
-
-
-def type_any():
-    pass
-
-
-class _MODULE:
-    @staticmethod
-    def add_read_procedure(wrapper):
-        pass
-
-    @staticmethod
-    def add_write_procedure(wrapper):
-        pass
-
-    @staticmethod
-    def add_transformation(wrapper):
-        pass
-
-    @staticmethod
-    def add_function(wrapper):
-        pass
--- a/release/mgp/instructions.md
+++ b/release/mgp/instructions.md
@@ -1,22 +0,0 @@
-# How to publish new versions
-## Prerequisites
-1. Installed poetry
-```
-pip install poetry
-```
-2. Set up [API tokens](https://pypi.org/help/#apitoken)
-3. Be a collaborator on [pypi](https://pypi.org/project/mgp/)
-
-## Making changes
-1. Make changes to the package
-2. Bump version in `pyproject.tml`
-3. `poetry build`
-4. `poetry publish`
-
-## Why is this not automatized?
-
-Because someone always has to manually bump up the version in `pyproject.toml`
-
-## Why does `_mgp.py` exists?
-Because we are mocking here all the types that are created by Memgraph
-in order to fix typing errors in `mgp.py`.
--- a/release/mgp/pyproject.toml
+++ b/release/mgp/pyproject.toml
@@ -1,23 +0,0 @@
-[tool.poetry]
-name = "mgp"
-version = "1.0.0"
-description = "Memgraph's module for developing MAGE modules. Used only for type hinting!"
-authors = [
-    "MasterMedo <mislav.vuletic@gmail.com>",
-    "jbajic <jure.bajic@memgraph.io>",
-    "katarinasupe <katarina.supe@memgraph.io>",
-    "antejavor <ante.javor@memgraph.io>",
-    "antaljanosbenjamin <benjamin.antal@memgraph.io>",
-]
-license = "Apache-2.0"
-readme = "README.md"
-include = ["mgp.py", "_mgp.py"]
-
-[tool.poetry.dependencies]
-python = "^3.7"
-
-[tool.poetry.dev-dependencies]
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
--- a/release/package/centos-7/Dockerfile
+++ b/release/package/centos-7/Dockerfile
@@ -7,8 +7,8 @@ RUN yum -y update \
 # Do NOT be smart here and clean the cache because the container is used in the
 # stateful context.

-RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-centos-7-x86_64.tar.gz \
-    -O ${TOOLCHAIN_VERSION}-binaries-centos-7-x86_64.tar.gz \
-    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-centos-7-x86_64.tar.gz -C /opt
+RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-centos-7.tar.gz \
+    -O ${TOOLCHAIN_VERSION}-binaries-centos-7.tar.gz \
+    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-centos-7.tar.gz -C /opt

 ENTRYPOINT ["sleep", "infinity"]
--- a/release/package/centos-8/Dockerfile
+++ b/release/package/centos-8/Dockerfile
@@ -0,0 +1,14 @@
+FROM centos:8
+
+ARG TOOLCHAIN_VERSION
+
+RUN dnf -y update \
+    && dnf install -y wget git
+# Do NOT be smart here and clean the cache because the container is used in the
+# stateful context.
+
+RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-centos-8.tar.gz \
+    -O ${TOOLCHAIN_VERSION}-binaries-centos-8.tar.gz \
+    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-centos-8.tar.gz -C /opt
+
+ENTRYPOINT ["sleep", "infinity"]
--- a/release/package/centos-9/Dockerfile
+++ b/release/package/centos-9/Dockerfile
@@ -1,14 +0,0 @@
-FROM quay.io/centos/centos:stream9
-
-ARG TOOLCHAIN_VERSION
-
-RUN yum -y update \
-    && yum install -y wget git
-# Do NOT be smart here and clean the cache because the container is used in the
-# stateful context.
-
-RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-centos-9-x86_64.tar.gz \
-    -O ${TOOLCHAIN_VERSION}-binaries-centos-9-x86_64.tar.gz \
-    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-centos-9-x86_64.tar.gz -C /opt
-
-ENTRYPOINT ["sleep", "infinity"]
--- a/release/package/debian-10/Dockerfile
+++ b/release/package/debian-10/Dockerfile
@@ -10,8 +10,8 @@ RUN apt update && apt install -y \
 # Do NOT be smart here and clean the cache because the container is used in the
 # stateful context.

-RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-debian-10-amd64.tar.gz \
-    -O ${TOOLCHAIN_VERSION}-binaries-debian-10-amd64.tar.gz \
-    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-debian-10-amd64.tar.gz -C /opt
+RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-debian-10.tar.gz \
+    -O ${TOOLCHAIN_VERSION}-binaries-debian-10.tar.gz \
+    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-debian-10.tar.gz -C /opt

 ENTRYPOINT ["sleep", "infinity"]
--- a/release/package/debian-11-arm/Dockerfile
+++ b/release/package/debian-11-arm/Dockerfile
@@ -1,17 +0,0 @@
-FROM debian:11
-
-ARG TOOLCHAIN_VERSION
-
-# Stops tzdata interactive configuration.
-ENV DEBIAN_FRONTEND=noninteractive
-
-RUN apt update && apt install -y \
-    ca-certificates wget git
-# Do NOT be smart here and clean the cache because the container is used in the
-# stateful context.
-
-RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-debian-11-arm64.tar.gz \
-    -O ${TOOLCHAIN_VERSION}-binaries-debian-11-arm64.tar.gz \
-    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-debian-11-arm64.tar.gz -C /opt
-
-ENTRYPOINT ["sleep", "infinity"]
--- a/release/package/debian-11/Dockerfile
+++ b/release/package/debian-11/Dockerfile
@@ -10,8 +10,8 @@ RUN apt update && apt install -y \
 # Do NOT be smart here and clean the cache because the container is used in the
 # stateful context.

-RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-debian-11-amd64.tar.gz \
-    -O ${TOOLCHAIN_VERSION}-binaries-debian-11-amd64.tar.gz \
-    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-debian-11-amd64.tar.gz -C /opt
+RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-debian-11.tar.gz \
+    -O ${TOOLCHAIN_VERSION}-binaries-debian-11.tar.gz \
+    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-debian-11.tar.gz -C /opt

 ENTRYPOINT ["sleep", "infinity"]
--- a/release/package/docker-compose.yml
+++ b/release/package/docker-compose.yml
@@ -4,10 +4,10 @@ services:
    build:
      context: centos-7
    container_name: "mgbuild_centos-7"
-  mgbuild_centos-9:
+  mgbuild_centos-8:
    build:
-      context: centos-9
-    container_name: "mgbuild_centos-9"
+      context: centos-8
+    container_name: "mgbuild_centos-8"
  mgbuild_debian-10:
    build:
      context: debian-10
@@ -24,7 +24,3 @@ services:
    build:
      context: ubuntu-20.04
    container_name: "mgbuild_ubuntu-20.04"
-  mgbuild_ubuntu-22.04:
-    build:
-      context: ubuntu-22.04
-    container_name: "mgbuild_ubuntu-22.04"
--- a/release/package/run.sh
+++ b/release/package/run.sh
@@ -3,7 +3,7 @@
 set -Eeuo pipefail

 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-SUPPORTED_OS=(centos-7 centos-9 debian-10 debian-11 ubuntu-18.04 ubuntu-20.04 ubuntu-22.04 debian-11-arm)
+SUPPORTED_OS=(centos-7 centos-8 debian-10 debian-11 ubuntu-18.04 ubuntu-20.04)
 PROJECT_ROOT="$SCRIPT_DIR/../.."
 TOOLCHAIN_VERSION="toolchain-v4"
 ACTIVATE_TOOLCHAIN="source /opt/${TOOLCHAIN_VERSION}/activate"
@@ -67,18 +67,14 @@ make_package () {
    # environment/os/{os}.sh does not come within the toolchain package. When
    # migrating to the next version of toolchain do that, and remove the
    # TOOLCHAIN_RUN_DEPS installation from here.
-    echo "Installing dependencies using '/memgraph/environment/os/$os.sh' script..."
+    echo "Installing dependencies..."
    docker exec "$build_container" bash -c "/memgraph/environment/os/$os.sh install TOOLCHAIN_RUN_DEPS"
    docker exec "$build_container" bash -c "/memgraph/environment/os/$os.sh install MEMGRAPH_BUILD_DEPS"

    echo "Building targeted package..."
    docker exec "$build_container" bash -c "cd /memgraph && $ACTIVATE_TOOLCHAIN && ./init"
    docker exec "$build_container" bash -c "cd $container_build_dir && rm -rf ./*"
-    if [[ "$os" == "debian-11-arm" ]]; then
-        docker exec "$build_container" bash -c "cd $container_build_dir && $ACTIVATE_TOOLCHAIN && cmake -DCMAKE_BUILD_TYPE=release -DMG_ARCH="ARM64" $telemetry_id_override_flag .."
-    else
-        docker exec "$build_container" bash -c "cd $container_build_dir && $ACTIVATE_TOOLCHAIN && cmake -DCMAKE_BUILD_TYPE=release $telemetry_id_override_flag .."
-    fi
+    docker exec "$build_container" bash -c "cd $container_build_dir && $ACTIVATE_TOOLCHAIN && cmake -DCMAKE_BUILD_TYPE=release $telemetry_id_override_flag .."
    # ' is used instead of " because we need to run make within the allowed
    # container resources.
    # shellcheck disable=SC2016
--- a/release/package/ubuntu-18.04/Dockerfile
+++ b/release/package/ubuntu-18.04/Dockerfile
@@ -10,8 +10,8 @@ RUN apt update && apt install -y \
 # Do NOT be smart here and clean the cache because the container is used in the
 # stateful context.

-RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-ubuntu-18.04-amd64.tar.gz \
-    -O ${TOOLCHAIN_VERSION}-binaries-ubuntu-18.04-amd64.tar.gz \
-    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-ubuntu-18.04-amd64.tar.gz -C /opt
+RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-ubuntu-18.04.tar.gz \
+    -O ${TOOLCHAIN_VERSION}-binaries-ubuntu-18.04.tar.gz \
+    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-ubuntu-18.04.tar.gz -C /opt

 ENTRYPOINT ["sleep", "infinity"]
--- a/release/package/ubuntu-20.04/Dockerfile
+++ b/release/package/ubuntu-20.04/Dockerfile
@@ -10,8 +10,8 @@ RUN apt update && apt install -y \
 # Do NOT be smart here and clean the cache because the container is used in the
 # stateful context.

-RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-ubuntu-20.04-amd64.tar.gz \
-    -O ${TOOLCHAIN_VERSION}-binaries-ubuntu-20.04-amd64.tar.gz \
-    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-ubuntu-20.04-amd64.tar.gz -C /opt
+RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-ubuntu-20.04.tar.gz \
+    -O ${TOOLCHAIN_VERSION}-binaries-ubuntu-20.04.tar.gz \
+    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-ubuntu-20.04.tar.gz -C /opt

 ENTRYPOINT ["sleep", "infinity"]
--- a/release/package/ubuntu-22.04/Dockerfile
+++ b/release/package/ubuntu-22.04/Dockerfile
@@ -1,17 +0,0 @@
-FROM ubuntu:22.04
-
-ARG TOOLCHAIN_VERSION
-
-# Stops tzdata interactive configuration.
-ENV DEBIAN_FRONTEND=noninteractive
-
-RUN apt update && apt install -y \
-    ca-certificates wget git
-# Do NOT be smart here and clean the cache because the container is used in the
-# stateful context.
-
-RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-ubuntu-22.04-amd64.tar.gz \
-    -O ${TOOLCHAIN_VERSION}-binaries-ubuntu-22.04-amd64.tar.gz \
-    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-ubuntu-22.04-amd64.tar.gz -C /opt
-
-ENTRYPOINT ["sleep", "infinity"]
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,26 +1,21 @@
 # CMake configuration for the main memgraph library and executable

 # add memgraph sub libraries, ordered by dependency
+add_subdirectory(interface)
 add_subdirectory(lisp)
 add_subdirectory(utils)
 add_subdirectory(requests)
 add_subdirectory(io)
-add_subdirectory(io/simulator)
 add_subdirectory(kvstore)
 add_subdirectory(telemetry)
 add_subdirectory(communication)
 add_subdirectory(memory)
 add_subdirectory(storage/v2)
-add_subdirectory(storage/v3)
 add_subdirectory(integrations)
 add_subdirectory(query)
-add_subdirectory(query/v2)
 add_subdirectory(slk)
 add_subdirectory(rpc)
 add_subdirectory(auth)
-add_subdirectory(parser)
-add_subdirectory(expr)
-add_subdirectory(coordinator)

 if (MG_ENTERPRISE)
  add_subdirectory(audit)
@@ -43,7 +38,7 @@ set(mg_single_node_v2_sources
 )

 set(mg_single_node_v2_libs stdc++fs Threads::Threads
-    telemetry_lib mg-query mg-communication mg-memory mg-utils mg-auth mg-license mg-settings)
+    telemetry_lib mg-query mg-communication mg-memory mg-utils mg-auth mg-license mg-settings mg-interface-storage-cpp2)
 if (MG_ENTERPRISE)
  # These are enterprise subsystems
  set(mg_single_node_v2_libs ${mg_single_node_v2_libs} mg-audit)
--- a/src/auth/models.cpp
+++ b/src/auth/models.cpp
@@ -37,7 +37,7 @@ const std::vector<Permission> kPermissionsAll = {
    Permission::CONSTRAINT, Permission::DUMP,      Permission::AUTH,        Permission::REPLICATION,
    Permission::DURABILITY, Permission::READ_FILE, Permission::FREE_MEMORY, Permission::TRIGGER,
    Permission::CONFIG,     Permission::STREAM,    Permission::MODULE_READ, Permission::MODULE_WRITE,
-    Permission::WEBSOCKET,  Permission::SCHEMA};
+    Permission::WEBSOCKET};
 }  // namespace

 std::string PermissionToString(Permission permission) {
@@ -84,8 +84,6 @@ std::string PermissionToString(Permission permission) {
      return "MODULE_WRITE";
    case Permission::WEBSOCKET:
      return "WEBSOCKET";
-    case Permission::SCHEMA:
-      return "SCHEMA";
  }
 }

--- a/src/auth/models.hpp
+++ b/src/auth/models.hpp
@@ -38,8 +38,7 @@ enum class Permission : uint64_t {
  STREAM       = 1U << 17U,
  MODULE_READ  = 1U << 18U,
  MODULE_WRITE = 1U << 19U,
-  WEBSOCKET    = 1U << 20U,
-  SCHEMA       = 1U << 21U
+  WEBSOCKET    = 1U << 20U
 };
 // clang-format on

--- a/src/common/types.hpp
+++ b/src/common/types.hpp
@@ -1,19 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <cstdint>
-
-namespace memgraph::common {
-enum class SchemaType : uint8_t { BOOL, INT, STRING, DATE, LOCALTIME, LOCALDATETIME, DURATION };
-
-}  // namespace memgraph::common
--- a/src/communication/bolt/v1/session.hpp
+++ b/src/communication/bolt/v1/session.hpp
@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2021 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
--- a/src/communication/bolt/v1/states/error.hpp
+++ b/src/communication/bolt/v1/states/error.hpp
@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2021 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
--- a/src/communication/bolt/v1/states/executing.hpp
+++ b/src/communication/bolt/v1/states/executing.hpp
@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2021 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
--- a/src/communication/bolt/v1/states/handshake.hpp
+++ b/src/communication/bolt/v1/states/handshake.hpp
@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2021 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
--- a/src/communication/bolt/v1/states/init.hpp
+++ b/src/communication/bolt/v1/states/init.hpp
@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2021 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
--- a/src/communication/v2/session.hpp
+++ b/src/communication/v2/session.hpp
@@ -105,16 +105,9 @@ class WebsocketSession : public std::enable_shared_from_this<WebsocketSession<TS
    boost::asio::socket_base::keep_alive option(true);

    // Set a decorator to change the Server of the handshake
-    ws_.set_option(boost::beast::websocket::stream_base::decorator([&req](boost::beast::websocket::response_type &res) {
+    ws_.set_option(boost::beast::websocket::stream_base::decorator([](boost::beast::websocket::response_type &res) {
      res.set(boost::beast::http::field::server, std::string("Memgraph Bolt WS"));
-
-      // We need to do this to support WASM clients, which explicitly send this flag
-      // in their upgrade request
-      // Neo4j client breaks when this flag is sent
-      if (const auto secondary_protocol = req.base().find(boost::beast::http::field::sec_websocket_protocol);
-          secondary_protocol != res.base().end() && secondary_protocol->value() == "binary") {
-        res.set(boost::beast::http::field::sec_websocket_protocol, "binary");
-      }
+      res.set(boost::beast::http::field::sec_websocket_protocol, "binary");
    }));
    ws_.binary(true);

@@ -169,7 +162,7 @@ class WebsocketSession : public std::enable_shared_from_this<WebsocketSession<TS
        boost::asio::bind_executor(strand_, std::bind_front(&WebsocketSession::OnRead, shared_from_this())));
  }

-  void OnRead(const boost::system::error_code &ec, const size_t bytes_transferred) {
+  void OnRead(const boost::system::error_code &ec, [[maybe_unused]] const size_t bytes_transferred) {
    // This indicates that the WebsocketSession was closed
    if (ec == boost::beast::websocket::error::closed) {
      return;
@@ -253,7 +246,11 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
  Session(Session &&) = delete;
  Session &operator=(const Session &) = delete;
  Session &operator=(Session &&) = delete;
-  ~Session() = default;
+  ~Session() {
+    if (IsConnected()) {
+      spdlog::error("Session: Destructor called while execution is active");
+    }
+  }

  bool Start() {
    if (execution_active_) {
@@ -329,8 +326,7 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
      socket.lowest_layer().non_blocking(false);
    });
    timeout_timer_.expires_at(boost::asio::steady_timer::time_point::max());
-    spdlog::info("Accepted a connection from {}: {}:{}", service_name_, remote_endpoint_.address(),
-                 remote_endpoint_.port());
+    spdlog::info("Accepted a connection from {}:", service_name_, remote_endpoint_.address(), remote_endpoint_.port());
  }

  void DoRead() {
@@ -404,6 +400,7 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
    if (ec == boost::asio::error::operation_aborted) {
      return;
    }
+    execution_active_ = false;

    if (ec == boost::asio::error::eof) {
      spdlog::info("Session closed by peer");
--- a/src/coordinator/CMakeLists.txt
+++ b/src/coordinator/CMakeLists.txt
@@ -1,9 +0,0 @@
-set(coordinator_src_files
-    coordinator.cpp
-    shard_map.cpp)
-
-find_package(fmt REQUIRED)
-find_package(Threads REQUIRED)
-
-add_library(mg-coordinator STATIC ${coordinator_src_files})
-target_link_libraries(mg-coordinator stdc++fs Threads::Threads fmt::fmt mg-utils mg-storage-v3)
--- a/src/coordinator/coordinator.cpp
+++ b/src/coordinator/coordinator.cpp
@@ -1,129 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include <coordinator/coordinator.hpp>
-
-namespace memgraph::coordinator {
-
-CoordinatorWriteResponses Coordinator::ApplyWrite(HeartbeatRequest &&heartbeat_request) {
-  spdlog::info("Coordinator handling HeartbeatRequest");
-
-  // add this storage engine to any under-replicated shards that it is not already a part of
-
-  auto initializing_rsms_for_shard_manager =
-      shard_map_.AssignShards(heartbeat_request.from_storage_manager, heartbeat_request.initialized_rsms);
-
-  return HeartbeatResponse{
-      .shards_to_initialize = initializing_rsms_for_shard_manager,
-  };
-}
-
-CoordinatorWriteResponses Coordinator::ApplyWrite(HlcRequest &&hlc_request) {
-  HlcResponse res{};
-
-  auto hlc_shard_map = shard_map_.GetHlc();
-
-  MG_ASSERT(!(hlc_request.last_shard_map_version.logical_id > hlc_shard_map.logical_id));
-
-  res.new_hlc = Hlc{
-      .logical_id = ++highest_allocated_timestamp_,
-      // TODO(tyler) probably pass some more context to the Coordinator here
-      // so that we can use our wall clock and enforce monotonicity.
-      // .coordinator_wall_clock = io_.Now(),
-  };
-
-  // Allways return fresher shard_map for now.
-  res.fresher_shard_map = std::make_optional(shard_map_);
-
-  return res;
-}
-
-CoordinatorWriteResponses Coordinator::ApplyWrite(AllocateEdgeIdBatchRequest &&ahr) {
-  AllocateEdgeIdBatchResponse res{};
-
-  uint64_t low = highest_allocated_edge_id_;
-
-  highest_allocated_edge_id_ += ahr.batch_size;
-
-  uint64_t high = highest_allocated_edge_id_;
-
-  res.low = low;
-  res.high = high;
-
-  return res;
-}
-
-/// This splits the shard immediately beneath the provided
-/// split key, keeping the assigned peers identical for now,
-/// but letting them be gradually migrated over time.
-CoordinatorWriteResponses Coordinator::ApplyWrite(SplitShardRequest &&split_shard_request) {
-  SplitShardResponse res{};
-
-  if (split_shard_request.previous_shard_map_version != shard_map_.shard_map_version) {
-    res.success = false;
-  } else {
-    res.success = shard_map_.SplitShard(split_shard_request.previous_shard_map_version, split_shard_request.label_id,
-                                        split_shard_request.split_key);
-  }
-
-  return res;
-}
-
-/// This adds the provided storage engine to the standby storage engine pool,
-/// which can be used to rebalance storage over time.
-CoordinatorWriteResponses Coordinator::ApplyWrite(
-    RegisterStorageEngineRequest && /* register_storage_engine_request */) {
-  RegisterStorageEngineResponse res{};
-  // TODO
-
-  return res;
-}
-
-/// This begins the process of draining the provided storage engine from all raft
-/// clusters that it might be participating in.
-CoordinatorWriteResponses Coordinator::ApplyWrite(
-    DeregisterStorageEngineRequest && /* register_storage_engine_request */) {
-  DeregisterStorageEngineResponse res{};
-  // TODO
-
-  return res;
-}
-
-CoordinatorWriteResponses Coordinator::ApplyWrite(InitializeLabelRequest &&initialize_label_request) {
-  InitializeLabelResponse res{};
-
-  std::optional<LabelId> new_label_id = shard_map_.InitializeNewLabel(
-      initialize_label_request.label_name, initialize_label_request.schema, initialize_label_request.replication_factor,
-      initialize_label_request.last_shard_map_version);
-
-  if (new_label_id) {
-    res.new_label_id = new_label_id.value();
-    res.fresher_shard_map = std::nullopt;
-    res.success = true;
-  } else {
-    res.fresher_shard_map = shard_map_;
-    res.success = false;
-  }
-
-  return res;
-}
-
-CoordinatorWriteResponses Coordinator::ApplyWrite(AllocatePropertyIdsRequest &&allocate_property_ids_request) {
-  AllocatePropertyIdsResponse res{};
-
-  auto property_ids = shard_map_.AllocatePropertyIds(allocate_property_ids_request.property_names);
-
-  res.property_ids = property_ids;
-
-  return res;
-}
-
-}  // namespace memgraph::coordinator
--- a/src/coordinator/coordinator.hpp
+++ b/src/coordinator/coordinator.hpp
@@ -1,196 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <optional>
-#include <set>
-#include <string>
-#include <unordered_set>
-#include <variant>
-#include <vector>
-
-#include <boost/uuid/uuid.hpp>
-
-#include <coordinator/hybrid_logical_clock.hpp>
-#include <coordinator/shard_map.hpp>
-#include <io/simulator/simulator.hpp>
-#include <io/time.hpp>
-#include <io/transport.hpp>
-#include <storage/v3/id_types.hpp>
-#include <storage/v3/schemas.hpp>
-
-namespace memgraph::coordinator {
-
-using memgraph::io::Address;
-using memgraph::storage::v3::LabelId;
-using memgraph::storage::v3::PropertyId;
-using memgraph::storage::v3::SchemaProperty;
-using SimT = memgraph::io::simulator::SimulatorTransport;
-using PrimaryKey = std::vector<PropertyValue>;
-
-struct HlcRequest {
-  Hlc last_shard_map_version;
-};
-
-struct HlcResponse {
-  Hlc new_hlc;
-  std::optional<ShardMap> fresher_shard_map;
-};
-
-struct GetShardMapRequest {
-  // No state
-};
-
-struct GetShardMapResponse {
-  ShardMap shard_map;
-};
-
-struct AllocateHlcBatchRequest {
-  Hlc low;
-  Hlc high;
-};
-
-struct AllocateHlcBatchResponse {
-  bool success;
-  Hlc low;
-  Hlc high;
-};
-
-struct AllocateEdgeIdBatchRequest {
-  size_t batch_size;
-};
-
-struct AllocateEdgeIdBatchResponse {
-  uint64_t low;
-  uint64_t high;
-};
-
-struct AllocatePropertyIdsRequest {
-  std::vector<std::string> property_names;
-};
-
-struct AllocatePropertyIdsResponse {
-  std::map<std::string, PropertyId> property_ids;
-};
-
-struct SplitShardRequest {
-  Hlc previous_shard_map_version;
-  LabelId label_id;
-  PrimaryKey split_key;
-};
-
-struct SplitShardResponse {
-  bool success;
-};
-
-struct RegisterStorageEngineRequest {
-  Address address;
-};
-
-struct RegisterStorageEngineResponse {
-  bool success;
-};
-
-struct DeregisterStorageEngineRequest {
-  Address address;
-};
-
-struct DeregisterStorageEngineResponse {
-  bool success;
-};
-
-struct InitializeLabelRequest {
-  std::string label_name;
-  std::vector<SchemaProperty> schema;
-  size_t replication_factor;
-  Hlc last_shard_map_version;
-};
-
-struct InitializeLabelResponse {
-  bool success;
-  LabelId new_label_id;
-  std::optional<ShardMap> fresher_shard_map;
-};
-
-struct HeartbeatRequest {
-  Address from_storage_manager;
-  std::set<boost::uuids::uuid> initialized_rsms;
-};
-
-struct HeartbeatResponse {
-  std::vector<ShardToInitialize> shards_to_initialize;
-};
-
-using CoordinatorWriteRequests =
-    std::variant<HlcRequest, AllocateEdgeIdBatchRequest, SplitShardRequest, RegisterStorageEngineRequest,
-                 DeregisterStorageEngineRequest, InitializeLabelRequest, AllocatePropertyIdsRequest, HeartbeatRequest>;
-using CoordinatorWriteResponses = std::variant<HlcResponse, AllocateEdgeIdBatchResponse, SplitShardResponse,
-                                               RegisterStorageEngineResponse, DeregisterStorageEngineResponse,
-                                               InitializeLabelResponse, AllocatePropertyIdsResponse, HeartbeatResponse>;
-
-using CoordinatorReadRequests = std::variant<GetShardMapRequest>;
-using CoordinatorReadResponses = std::variant<GetShardMapResponse>;
-
-class Coordinator {
- public:
-  explicit Coordinator(ShardMap sm) : shard_map_{std::move(sm)} {}
-
-  // NOLINTNEXTLINE(readability-convert-member-functions-to-static
-  CoordinatorReadResponses Read(CoordinatorReadRequests requests) {
-    return std::visit([&](auto &&request) { return HandleRead(std::forward<decltype(request)>(request)); },
-                      std::move(requests));  // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
-  }
-
-  // NOLINTNEXTLINE(readability-convert-member-functions-to-static
-  CoordinatorWriteResponses Apply(CoordinatorWriteRequests requests) {
-    return std::visit([&](auto &&request) mutable { return ApplyWrite(std::forward<decltype(request)>(request)); },
-                      std::move(requests));
-  }
-
- private:
-  ShardMap shard_map_;
-  uint64_t highest_allocated_timestamp_;
-
-  /// Query engines need to periodically request batches of unique edge IDs.
-  uint64_t highest_allocated_edge_id_;
-
-  CoordinatorReadResponses HandleRead(GetShardMapRequest && /* get_shard_map_request */) {
-    GetShardMapResponse res;
-    res.shard_map = shard_map_;
-    return res;
-  }
-
-  CoordinatorWriteResponses ApplyWrite(HeartbeatRequest &&heartbeat_request);
-
-  CoordinatorWriteResponses ApplyWrite(HlcRequest &&hlc_request);
-
-  CoordinatorWriteResponses ApplyWrite(AllocateEdgeIdBatchRequest &&ahr);
-
-  /// This splits the shard immediately beneath the provided
-  /// split key, keeping the assigned peers identical for now,
-  /// but letting them be gradually migrated over time.
-  CoordinatorWriteResponses ApplyWrite(SplitShardRequest &&split_shard_request);
-
-  /// This adds the provided storage engine to the standby storage engine pool,
-  /// which can be used to rebalance storage over time.
-  static CoordinatorWriteResponses ApplyWrite(RegisterStorageEngineRequest && /* register_storage_engine_request */);
-
-  /// This begins the process of draining the provided storage engine from all raft
-  /// clusters that it might be participating in.
-  static CoordinatorWriteResponses ApplyWrite(DeregisterStorageEngineRequest && /* register_storage_engine_request */);
-
-  CoordinatorWriteResponses ApplyWrite(InitializeLabelRequest &&initialize_label_request);
-
-  CoordinatorWriteResponses ApplyWrite(AllocatePropertyIdsRequest &&allocate_property_ids_request);
-};
-
-}  // namespace memgraph::coordinator
--- a/src/coordinator/coordinator_client.hpp
+++ b/src/coordinator/coordinator_client.hpp
@@ -1,24 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include "coordinator/coordinator.hpp"
-#include "io/rsm/rsm_client.hpp"
-
-namespace memgraph::coordinator {
-
-using memgraph::io::rsm::RsmClient;
-
-template <typename IoImpl>
-using CoordinatorClient = RsmClient<IoImpl, CoordinatorWriteRequests, CoordinatorWriteResponses,
-                                    CoordinatorReadRequests, CoordinatorReadResponses>;
-}  // namespace memgraph::coordinator
--- a/src/coordinator/coordinator_rsm.hpp
+++ b/src/coordinator/coordinator_rsm.hpp
@@ -1,23 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include "coordinator/coordinator.hpp"
-#include "io/rsm/raft.hpp"
-
-namespace memgraph::coordinator {
-
-template <typename IoImpl>
-using CoordinatorRsm = memgraph::io::rsm::Raft<IoImpl, Coordinator, CoordinatorWriteRequests, CoordinatorWriteResponses,
-                                               CoordinatorReadRequests, CoordinatorReadResponses>;
-
-}  // namespace memgraph::coordinator
--- a/src/coordinator/hybrid_logical_clock.hpp
+++ b/src/coordinator/hybrid_logical_clock.hpp
@@ -1,36 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <compare>
-
-#include "io/time.hpp"
-
-namespace memgraph::coordinator {
-
-using Time = memgraph::io::Time;
-
-/// Hybrid-logical clock
-struct Hlc {
-  uint64_t logical_id;
-  Time coordinator_wall_clock;
-
-  auto operator<=>(const Hlc &other) const { return logical_id <=> other.logical_id; }
-
-  bool operator==(const Hlc &other) const = default;
-  bool operator<(const Hlc &other) const = default;
-  bool operator==(const uint64_t other) const { return logical_id == other; }
-  bool operator<(const uint64_t other) const { return logical_id < other; }
-  bool operator>=(const uint64_t other) const { return logical_id >= other; }
-};
-
-}  // namespace memgraph::coordinator
--- a/src/coordinator/shard_map.cpp
+++ b/src/coordinator/shard_map.cpp
@@ -1,90 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "coordinator/shard_map.hpp"
-#include "storage/v3/temporal.hpp"
-
-namespace memgraph::coordinator {
-
-using memgraph::common::SchemaType;
-using memgraph::storage::v3::TemporalData;
-using memgraph::storage::v3::TemporalType;
-
-PrimaryKey SchemaToMinKey(const std::vector<SchemaProperty> &schema) {
-  PrimaryKey ret{};
-
-  const int64_t min_int = std::numeric_limits<int64_t>::min();
-
-  const TemporalData date{TemporalType::Date, min_int};
-  const TemporalData local_time{TemporalType::LocalTime, min_int};
-  const TemporalData local_date_time{TemporalType::LocalDateTime, min_int};
-  const TemporalData duration{TemporalType::Duration, min_int};
-
-  for (const auto &schema_property : schema) {
-    switch (schema_property.type) {
-      case SchemaType::BOOL:
-        ret.emplace_back(PropertyValue(false));
-        break;
-      case SchemaType::INT:
-        ret.emplace_back(PropertyValue(min_int));
-        break;
-      case SchemaType::STRING:
-        ret.emplace_back(PropertyValue(""));
-        break;
-      case SchemaType::DATE:
-        ret.emplace_back(PropertyValue(date));
-        break;
-      case SchemaType::LOCALTIME:
-        ret.emplace_back(PropertyValue(local_time));
-        break;
-      case SchemaType::LOCALDATETIME:
-        ret.emplace_back(PropertyValue(local_date_time));
-        break;
-      case SchemaType::DURATION:
-        ret.emplace_back(PropertyValue(duration));
-        break;
-    }
-  }
-
-  return ret;
-}
-
-std::optional<LabelId> ShardMap::InitializeNewLabel(std::string label_name, std::vector<SchemaProperty> schema,
-                                                    size_t replication_factor, Hlc last_shard_map_version) {
-  if (shard_map_version != last_shard_map_version || labels.contains(label_name)) {
-    return std::nullopt;
-  }
-
-  const LabelId label_id = LabelId::FromUint(++max_label_id);
-
-  labels.emplace(std::move(label_name), label_id);
-
-  PrimaryKey initial_key = SchemaToMinKey(schema);
-  Shard empty_shard = {};
-
-  Shards shards = {
-      {initial_key, empty_shard},
-  };
-
-  LabelSpace label_space{
-      .schema = std::move(schema),
-      .shards = shards,
-      .replication_factor = replication_factor,
-  };
-
-  label_spaces.emplace(label_id, label_space);
-
-  IncrementShardMapVersion();
-
-  return label_id;
-}
-
-}  // namespace memgraph::coordinator
--- a/src/coordinator/shard_map.hpp
+++ b/src/coordinator/shard_map.hpp
@@ -1,276 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <limits>
-#include <map>
-#include <set>
-#include <vector>
-
-#include <boost/uuid/uuid.hpp>
-#include <boost/uuid/uuid_generators.hpp>
-
-#include "common/types.hpp"
-#include "coordinator/hybrid_logical_clock.hpp"
-#include "io/address.hpp"
-#include "storage/v3/config.hpp"
-#include "storage/v3/id_types.hpp"
-#include "storage/v3/property_value.hpp"
-#include "storage/v3/schemas.hpp"
-#include "storage/v3/temporal.hpp"
-
-namespace memgraph::coordinator {
-
-using memgraph::io::Address;
-using memgraph::storage::v3::Config;
-using memgraph::storage::v3::LabelId;
-using memgraph::storage::v3::PropertyId;
-using memgraph::storage::v3::PropertyValue;
-using memgraph::storage::v3::SchemaProperty;
-
-enum class Status : uint8_t {
-  CONSENSUS_PARTICIPANT,
-  INITIALIZING,
-  // TODO(tyler) this will possibly have more states,
-  // depending on the reconfiguration protocol that we
-  // implement.
-};
-
-struct AddressAndStatus {
-  memgraph::io::Address address;
-  Status status;
-  friend bool operator<(const AddressAndStatus &lhs, const AddressAndStatus &rhs) { return lhs.address < rhs.address; }
-};
-
-using PrimaryKey = std::vector<PropertyValue>;
-using Shard = std::vector<AddressAndStatus>;
-using Shards = std::map<PrimaryKey, Shard>;
-using LabelName = std::string;
-using PropertyName = std::string;
-using PropertyMap = std::map<PropertyName, PropertyId>;
-
-struct ShardToInitialize {
-  boost::uuids::uuid uuid;
-  LabelId label_id;
-  PrimaryKey min_key;
-  std::optional<PrimaryKey> max_key;
-  Config config;
-};
-
-PrimaryKey SchemaToMinKey(const std::vector<SchemaProperty> &schema);
-
-struct LabelSpace {
-  std::vector<SchemaProperty> schema;
-  std::map<PrimaryKey, Shard> shards;
-  size_t replication_factor;
-};
-
-struct ShardMap {
-  Hlc shard_map_version;
-  uint64_t max_property_id;
-  std::map<PropertyName, PropertyId> properties;
-  uint64_t max_label_id;
-  std::map<LabelName, LabelId> labels;
-  std::map<LabelId, LabelSpace> label_spaces;
-  std::map<LabelId, std::vector<SchemaProperty>> schemas;
-
-  Shards GetShards(const LabelName &label) {
-    const auto id = labels.at(label);
-    auto &shards = label_spaces.at(id).shards;
-    return shards;
-  }
-
-  // TODO(gabor) later we will want to update the wallclock time with
-  // the given Io<impl>'s time as well
-  Hlc IncrementShardMapVersion() noexcept {
-    ++shard_map_version.logical_id;
-    return shard_map_version;
-  }
-
-  Hlc GetHlc() const noexcept { return shard_map_version; }
-
-  // Returns the shard UUIDs that have been assigned but not yet acknowledged for this storage manager
-  std::vector<ShardToInitialize> AssignShards(Address storage_manager, std::set<boost::uuids::uuid> initialized) {
-    std::vector<ShardToInitialize> ret{};
-
-    bool mutated = false;
-
-    for (auto &[label_id, label_space] : label_spaces) {
-      for (auto &[low_key, shard] : label_space.shards) {
-        // TODO(tyler) avoid these triple-nested loops by having the heartbeat include better info
-        bool machine_contains_shard = false;
-
-        for (auto &aas : shard) {
-          if (initialized.contains(aas.address.unique_id)) {
-            spdlog::info("marking shard as full consensus participant: {}", aas.address.unique_id);
-            aas.status = Status::CONSENSUS_PARTICIPANT;
-            machine_contains_shard = true;
-          } else {
-            const bool same_machine = aas.address.last_known_ip == storage_manager.last_known_ip &&
-                                      aas.address.last_known_port == storage_manager.last_known_port;
-            if (same_machine) {
-              machine_contains_shard = true;
-              ret.push_back(ShardToInitialize{
-                  .uuid = aas.address.unique_id,
-                  .label_id = label_id,
-                  .min_key = low_key,
-                  .max_key = std::nullopt,
-                  .config = Config{},
-              });
-            }
-          }
-        }
-
-        if (!machine_contains_shard && shard.size() < label_space.replication_factor) {
-          Address address = storage_manager;
-
-          // TODO(tyler) use deterministic UUID so that coordinators don't diverge here
-          address.unique_id = boost::uuids::uuid{boost::uuids::random_generator()()},
-
-          ret.push_back(ShardToInitialize{
-              .uuid = address.unique_id,
-              .label_id = label_id,
-              .min_key = low_key,
-              .max_key = std::nullopt,
-              .config = Config{},
-          });
-
-          AddressAndStatus aas = {
-              .address = address,
-              .status = Status::INITIALIZING,
-          };
-
-          shard.emplace_back(aas);
-        }
-      }
-    }
-
-    if (mutated) {
-      IncrementShardMapVersion();
-    }
-
-    return ret;
-  }
-
-  bool SplitShard(Hlc previous_shard_map_version, LabelId label_id, const PrimaryKey &key) {
-    if (previous_shard_map_version != shard_map_version) {
-      return false;
-    }
-
-    auto &label_space = label_spaces.at(label_id);
-    auto &shards_in_map = label_space.shards;
-
-    MG_ASSERT(!shards_in_map.empty());
-    MG_ASSERT(!shards_in_map.contains(key));
-    MG_ASSERT(label_spaces.contains(label_id));
-
-    // Finding the Shard that the new PrimaryKey should map to.
-    auto prev = std::prev(shards_in_map.upper_bound(key));
-    Shard duplicated_shard = prev->second;
-
-    // Apply the split
-    shards_in_map[key] = duplicated_shard;
-
-    return true;
-  }
-
-  std::optional<LabelId> InitializeNewLabel(std::string label_name, std::vector<SchemaProperty> schema,
-                                            size_t replication_factor, Hlc last_shard_map_version);
-
-  void AddServer(Address server_address) {
-    // Find a random place for the server to plug in
-  }
-
-  LabelId GetLabelId(const std::string &label) const { return labels.at(label); }
-
-  Shards GetShardsForRange(const LabelName &label_name, const PrimaryKey &start_key, const PrimaryKey &end_key) const {
-    MG_ASSERT(start_key <= end_key);
-    MG_ASSERT(labels.contains(label_name));
-
-    LabelId label_id = labels.at(label_name);
-
-    const auto &label_space = label_spaces.at(label_id);
-
-    const auto &shards_for_label = label_space.shards;
-
-    MG_ASSERT(shards_for_label.begin()->first <= start_key,
-              "the ShardMap must always contain a minimal key that is less than or equal to any requested key");
-
-    auto it = std::prev(shards_for_label.upper_bound(start_key));
-    const auto end_it = shards_for_label.upper_bound(end_key);
-
-    Shards shards{};
-
-    std::copy(it, end_it, std::inserter(shards, shards.end()));
-
-    return shards;
-  }
-
-  Shard GetShardForKey(const LabelName &label_name, const PrimaryKey &key) const {
-    MG_ASSERT(labels.contains(label_name));
-
-    LabelId label_id = labels.at(label_name);
-
-    const auto &label_space = label_spaces.at(label_id);
-
-    MG_ASSERT(label_space.shards.begin()->first <= key,
-              "the ShardMap must always contain a minimal key that is less than or equal to any requested key");
-
-    return std::prev(label_space.shards.upper_bound(key))->second;
-  }
-
-  Shard GetShardForKey(const LabelId &label_id, const PrimaryKey &key) const {
-    MG_ASSERT(label_spaces.contains(label_id));
-
-    const auto &label_space = label_spaces.at(label_id);
-
-    MG_ASSERT(label_space.shards.begin()->first <= key,
-              "the ShardMap must always contain a minimal key that is less than or equal to any requested key");
-
-    return std::prev(label_space.shards.upper_bound(key))->second;
-  }
-
-  PropertyMap AllocatePropertyIds(const std::vector<PropertyName> &new_properties) {
-    PropertyMap ret{};
-
-    bool mutated = false;
-
-    for (const auto &property_name : new_properties) {
-      if (properties.contains(property_name)) {
-        auto property_id = properties.at(property_name);
-        ret.emplace(property_name, property_id);
-      } else {
-        mutated = true;
-
-        const PropertyId property_id = PropertyId::FromUint(++max_property_id);
-        ret.emplace(property_name, property_id);
-        properties.emplace(property_name, property_id);
-      }
-    }
-
-    if (mutated) {
-      IncrementShardMapVersion();
-    }
-
-    return ret;
-  }
-
-  std::optional<PropertyId> GetPropertyId(const std::string &property_name) const {
-    if (properties.contains(property_name)) {
-      return properties.at(property_name);
-    }
-
-    return std::nullopt;
-  }
-};
-
-}  // namespace memgraph::coordinator
--- a/src/expr/CMakeLists.txt
+++ b/src/expr/CMakeLists.txt
@@ -1,20 +0,0 @@
-define_add_lcp(add_lcp_expr lcp_expr_cpp_files generated_lcp_expr_files)
-
-add_lcp_expr(semantic/symbol.lcp)
-
-add_custom_target(generate_lcp_expr DEPENDS ${generated_lcp_expr_files})
-
-set(mg_expr_sources
-    ${lcp_expr_cpp_files}
-    parsing.cpp)
-
-find_package(Boost REQUIRED)
-
-add_library(mg-expr STATIC ${mg_expr_sources})
-add_dependencies(mg-expr generate_lcp_expr)
-target_include_directories(mg-expr PUBLIC ${CMAKE_SOURCE_DIR}/include)
-target_include_directories(mg-expr PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
-target_include_directories(mg-expr PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/ast)
-target_include_directories(mg-expr PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/interpret)
-target_include_directories(mg-expr PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/semantic)
-target_link_libraries(mg-expr cppitertools Boost::headers mg-utils mg-parser)
--- a/src/expr/ast.hpp
+++ b/src/expr/ast.hpp
@@ -1,35 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-#pragma once
-
-#ifndef MG_AST_INCLUDE_PATH
-#ifdef MG_CLANG_TIDY_CHECK
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define MG_AST_INCLUDE_PATH "query/v2/frontend/ast/ast.hpp"
-#else
-#error Missing AST include path
-#endif
-#endif
-
-#ifndef MG_INJECTED_NAMESPACE_NAME
-#ifdef MG_CLANG_TIDY_CHECK
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define MG_INJECTED_NAMESPACE_NAME memgraph::query::v2
-#else
-#error Missing AST namespace
-#endif
-#endif
-
-#include MG_AST_INCLUDE_PATH
-
-namespace memgraph::expr {
-using namespace MG_INJECTED_NAMESPACE_NAME;  // NOLINT(google-build-using-namespace)
-}  // namespace memgraph::expr
--- a/src/expr/ast/ast_visitor.hpp
+++ b/src/expr/ast/ast_visitor.hpp
@@ -1,135 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include "utils/visitor.hpp"
-
-namespace MG_INJECTED_NAMESPACE_NAME {
-
-// Forward declares for Tree visitors.
-class CypherQuery;
-class SingleQuery;
-class CypherUnion;
-class NamedExpression;
-class Identifier;
-class PropertyLookup;
-class LabelsTest;
-class Aggregation;
-class Function;
-class Reduce;
-class Coalesce;
-class Extract;
-class All;
-class Single;
-class Any;
-class None;
-class ParameterLookup;
-class CallProcedure;
-class Create;
-class Match;
-class Return;
-class With;
-class Pattern;
-class NodeAtom;
-class EdgeAtom;
-class PrimitiveLiteral;
-class ListLiteral;
-class MapLiteral;
-class OrOperator;
-class XorOperator;
-class AndOperator;
-class NotOperator;
-class AdditionOperator;
-class SubtractionOperator;
-class MultiplicationOperator;
-class DivisionOperator;
-class ModOperator;
-class UnaryPlusOperator;
-class UnaryMinusOperator;
-class IsNullOperator;
-class NotEqualOperator;
-class EqualOperator;
-class LessOperator;
-class GreaterOperator;
-class LessEqualOperator;
-class GreaterEqualOperator;
-class InListOperator;
-class SubscriptOperator;
-class ListSlicingOperator;
-class IfOperator;
-class Delete;
-class Where;
-class SetProperty;
-class SetProperties;
-class SetLabels;
-class RemoveProperty;
-class RemoveLabels;
-class Merge;
-class Unwind;
-class AuthQuery;
-class ExplainQuery;
-class ProfileQuery;
-class IndexQuery;
-class InfoQuery;
-class ConstraintQuery;
-class RegexMatch;
-class DumpQuery;
-class ReplicationQuery;
-class LockPathQuery;
-class LoadCsv;
-class FreeMemoryQuery;
-class TriggerQuery;
-class IsolationLevelQuery;
-class CreateSnapshotQuery;
-class StreamQuery;
-class SettingQuery;
-class VersionQuery;
-class Foreach;
-class SchemaQuery;
-
-using TreeCompositeVisitor = memgraph::utils::CompositeVisitor<
-    SingleQuery, CypherUnion, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator, AdditionOperator,
-    SubtractionOperator, MultiplicationOperator, DivisionOperator, ModOperator, NotEqualOperator, EqualOperator,
-    LessOperator, GreaterOperator, LessEqualOperator, GreaterEqualOperator, InListOperator, SubscriptOperator,
-    ListSlicingOperator, IfOperator, UnaryPlusOperator, UnaryMinusOperator, IsNullOperator, ListLiteral, MapLiteral,
-    PropertyLookup, LabelsTest, Aggregation, Function, Reduce, Coalesce, Extract, All, Single, Any, None, CallProcedure,
-    Create, Match, Return, With, Pattern, NodeAtom, EdgeAtom, Delete, Where, SetProperty, SetProperties, SetLabels,
-    RemoveProperty, RemoveLabels, Merge, Unwind, RegexMatch, LoadCsv, Foreach>;
-
-using TreeLeafVisitor = memgraph::utils::LeafVisitor<Identifier, PrimitiveLiteral, ParameterLookup>;
-
-class HierarchicalTreeVisitor : public TreeCompositeVisitor, public TreeLeafVisitor {
- public:
-  using TreeCompositeVisitor::PostVisit;
-  using TreeCompositeVisitor::PreVisit;
-  using TreeLeafVisitor::Visit;
-  using typename TreeLeafVisitor::ReturnType;
-};
-
-template <class TResult>
-class ExpressionVisitor
-    : public memgraph::utils::Visitor<
-          TResult, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator, AdditionOperator,
-          SubtractionOperator, MultiplicationOperator, DivisionOperator, ModOperator, NotEqualOperator, EqualOperator,
-          LessOperator, GreaterOperator, LessEqualOperator, GreaterEqualOperator, InListOperator, SubscriptOperator,
-          ListSlicingOperator, IfOperator, UnaryPlusOperator, UnaryMinusOperator, IsNullOperator, ListLiteral,
-          MapLiteral, PropertyLookup, LabelsTest, Aggregation, Function, Reduce, Coalesce, Extract, All, Single, Any,
-          None, ParameterLookup, Identifier, PrimitiveLiteral, RegexMatch> {};
-
-template <class TResult>
-class QueryVisitor
-    : public memgraph::utils::Visitor<TResult, CypherQuery, ExplainQuery, ProfileQuery, IndexQuery, AuthQuery,
-                                      InfoQuery, ConstraintQuery, DumpQuery, ReplicationQuery, LockPathQuery,
-                                      FreeMemoryQuery, TriggerQuery, IsolationLevelQuery, CreateSnapshotQuery,
-                                      StreamQuery, SettingQuery, VersionQuery, SchemaQuery> {};
-
-}  // namespace MG_INJECTED_NAMESPACE_NAME
--- a/src/expr/ast/cypher_main_visitor.hpp
+++ b/src/expr/ast/cypher_main_visitor.hpp
--- a/src/expr/ast/pretty_print.hpp
+++ b/src/expr/ast/pretty_print.hpp
@@ -1,271 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <iostream>
-#include <type_traits>
-
-#include "expr/ast.hpp"
-#include "expr/typed_value.hpp"
-#include "utils/algorithm.hpp"
-#include "utils/logging.hpp"
-#include "utils/string.hpp"
-
-namespace memgraph::expr {
-namespace detail {
-template <typename T>
-void PrintObject(std::ostream *out, const T &arg) {
-  static_assert(!std::is_convertible<T, Expression *>::value,
-                "This overload shouldn't be called with pointers convertible "
-                "to Expression *. This means your other PrintObject overloads aren't "
-                "being called for certain AST nodes when they should (or perhaps such "
-                "overloads don't exist yet).");
-  *out << arg;
-}
-
-inline void PrintObject(std::ostream *out, const std::string &str) { *out << utils::Escape(str); }
-
-inline void PrintObject(std::ostream *out, Aggregation::Op op) { *out << Aggregation::OpToString(op); }
-
-inline void PrintObject(std::ostream *out, Expression *expr);
-
-inline void PrintObject(std::ostream *out, Identifier *expr) { PrintObject(out, static_cast<Expression *>(expr)); }
-
-template <typename T>
-void PrintObject(std::ostream *out, const std::vector<T> &vec) {
-  *out << "[";
-  utils::PrintIterable(*out, vec, ", ", [](auto &stream, const auto &item) { PrintObject(&stream, item); });
-  *out << "]";
-}
-
-template <typename T>
-void PrintObject(std::ostream *out, const std::vector<T, utils::Allocator<T>> &vec) {
-  *out << "[";
-  utils::PrintIterable(*out, vec, ", ", [](auto &stream, const auto &item) { PrintObject(&stream, item); });
-  *out << "]";
-}
-
-template <typename K, typename V>
-void PrintObject(std::ostream *out, const std::map<K, V> &map) {
-  *out << "{";
-  utils::PrintIterable(*out, map, ", ", [](auto &stream, const auto &item) {
-    PrintObject(&stream, item.first);
-    stream << ": ";
-    PrintObject(&stream, item.second);
-  });
-  *out << "}";
-}
-
-template <typename T>
-void PrintObject(std::ostream *out, const utils::pmr::map<utils::pmr::string, T> &map) {
-  *out << "{";
-  utils::PrintIterable(*out, map, ", ", [](auto &stream, const auto &item) {
-    PrintObject(&stream, item.first);
-    stream << ": ";
-    PrintObject(&stream, item.second);
-  });
-  *out << "}";
-}
-
-template <typename T1, typename T2, typename T3>
-inline void PrintObject(std::ostream *out, const TypedValueT<T1, T2, T3> &value) {
-  using TypedValue = TypedValueT<T1, T2, T3>;
-  switch (value.type()) {
-    case TypedValue::Type::Null:
-      *out << "null";
-      break;
-    case TypedValue::Type::String:
-      PrintObject(out, value.ValueString());
-      break;
-    case TypedValue::Type::Bool:
-      *out << (value.ValueBool() ? "true" : "false");
-      break;
-    case TypedValue::Type::Int:
-      PrintObject(out, value.ValueInt());
-      break;
-    case TypedValue::Type::Double:
-      PrintObject(out, value.ValueDouble());
-      break;
-    case TypedValue::Type::List:
-      PrintObject(out, value.ValueList());
-      break;
-    case TypedValue::Type::Map:
-      PrintObject(out, value.ValueMap());
-      break;
-    case TypedValue::Type::Date:
-      PrintObject(out, value.ValueDate());
-      break;
-    case TypedValue::Type::Duration:
-      PrintObject(out, value.ValueDuration());
-      break;
-    case TypedValue::Type::LocalTime:
-      PrintObject(out, value.ValueLocalTime());
-      break;
-    case TypedValue::Type::LocalDateTime:
-      PrintObject(out, value.ValueLocalDateTime());
-      break;
-    default:
-      MG_ASSERT(false, "PrintObject(std::ostream *out, const TypedValue &value) should not reach here");
-  }
-}
-
-template <typename T>
-void PrintOperatorArgs(std::ostream *out, const T &arg) {
-  *out << " ";
-  PrintObject(out, arg);
-  *out << ")";
-}
-
-template <typename T, typename... Ts>
-void PrintOperatorArgs(std::ostream *out, const T &arg, const Ts &...args) {
-  *out << " ";
-  PrintObject(out, arg);
-  PrintOperatorArgs(out, args...);
-}
-
-template <typename... Ts>
-void PrintOperator(std::ostream *out, const std::string &name, const Ts &...args) {
-  *out << "(" << name;
-  PrintOperatorArgs(out, args...);
-}
-}  // namespace detail
-
-class ExpressionPrettyPrinter : public ExpressionVisitor<void> {
- public:
-  explicit ExpressionPrettyPrinter(std::ostream *out) : out_(out) {}
-
-  // Unary operators
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define UNARY_OPERATOR_VISIT(OP_NODE, OP_STR)      \
-  /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \
-  void Visit(OP_NODE &op) override { detail::PrintOperator(out_, OP_STR, op.expression_); }
-
-  UNARY_OPERATOR_VISIT(NotOperator, "Not");
-  UNARY_OPERATOR_VISIT(UnaryPlusOperator, "+");
-  UNARY_OPERATOR_VISIT(UnaryMinusOperator, "-");
-  UNARY_OPERATOR_VISIT(IsNullOperator, "IsNull");
-
-#undef UNARY_OPERATOR_VISIT
-
-  // Binary operators
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define BINARY_OPERATOR_VISIT(OP_NODE, OP_STR)     \
-  /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \
-  void Visit(OP_NODE &op) override { detail::PrintOperator(out_, OP_STR, op.expression1_, op.expression2_); }
-
-  BINARY_OPERATOR_VISIT(OrOperator, "Or");
-  BINARY_OPERATOR_VISIT(XorOperator, "Xor");
-  BINARY_OPERATOR_VISIT(AndOperator, "And");
-  BINARY_OPERATOR_VISIT(AdditionOperator, "+");
-  BINARY_OPERATOR_VISIT(SubtractionOperator, "-");
-  BINARY_OPERATOR_VISIT(MultiplicationOperator, "*");
-  BINARY_OPERATOR_VISIT(DivisionOperator, "/");
-  BINARY_OPERATOR_VISIT(ModOperator, "%");
-  BINARY_OPERATOR_VISIT(NotEqualOperator, "!=");
-  BINARY_OPERATOR_VISIT(EqualOperator, "==");
-  BINARY_OPERATOR_VISIT(LessOperator, "<");
-  BINARY_OPERATOR_VISIT(GreaterOperator, ">");
-  BINARY_OPERATOR_VISIT(LessEqualOperator, "<=");
-  BINARY_OPERATOR_VISIT(GreaterEqualOperator, ">=");
-  BINARY_OPERATOR_VISIT(InListOperator, "In");
-  BINARY_OPERATOR_VISIT(SubscriptOperator, "Subscript");
-
-#undef BINARY_OPERATOR_VISIT
-
-  // Other
-  void Visit(ListSlicingOperator &op) override {
-    detail::PrintOperator(out_, "ListSlicing", op.list_, op.lower_bound_, op.upper_bound_);
-  }
-
-  void Visit(IfOperator &op) override {
-    detail::PrintOperator(out_, "If", op.condition_, op.then_expression_, op.else_expression_);
-  }
-
-  void Visit(ListLiteral &op) override { detail::PrintOperator(out_, "ListLiteral", op.elements_); }
-
-  void Visit(MapLiteral &op) override {
-    std::map<std::string, Expression *> map;
-    for (const auto &kv : op.elements_) {
-      map[kv.first.name] = kv.second;
-    }
-    detail::PrintObject(out_, map);
-  }
-
-  void Visit(LabelsTest &op) override { detail::PrintOperator(out_, "LabelsTest", op.expression_); }
-
-  void Visit(Aggregation &op) override { detail::PrintOperator(out_, "Aggregation", op.op_); }
-
-  void Visit(Function &op) override { detail::PrintOperator(out_, "Function", op.function_name_, op.arguments_); }
-
-  void Visit(Reduce &op) override {
-    detail::PrintOperator(out_, "Reduce", op.accumulator_, op.initializer_, op.identifier_, op.list_, op.expression_);
-  }
-
-  void Visit(Coalesce &op) override { detail::PrintOperator(out_, "Coalesce", op.expressions_); }
-
-  void Visit(Extract &op) override { detail::PrintOperator(out_, "Extract", op.identifier_, op.list_, op.expression_); }
-
-  void Visit(All &op) override {
-    detail::PrintOperator(out_, "All", op.identifier_, op.list_expression_, op.where_->expression_);
-  }
-
-  void Visit(Single &op) override {
-    detail::PrintOperator(out_, "Single", op.identifier_, op.list_expression_, op.where_->expression_);
-  }
-
-  void Visit(Any &op) override {
-    detail::PrintOperator(out_, "Any", op.identifier_, op.list_expression_, op.where_->expression_);
-  }
-
-  void Visit(None &op) override {
-    detail::PrintOperator(out_, "None", op.identifier_, op.list_expression_, op.where_->expression_);
-  }
-
-  void Visit(Identifier &op) override { detail::PrintOperator(out_, "Identifier", op.name_); }
-
-  void Visit(PrimitiveLiteral &op) override { detail::PrintObject(out_, op.value_); }
-
-  void Visit(PropertyLookup &op) override {
-    detail::PrintOperator(out_, "PropertyLookup", op.expression_, op.property_.name);
-  }
-
-  void Visit(ParameterLookup &op) override { detail::PrintOperator(out_, "ParameterLookup", op.token_position_); }
-
-  void Visit(NamedExpression &op) override { detail::PrintOperator(out_, "NamedExpression", op.name_, op.expression_); }
-
-  void Visit(RegexMatch &op) override { detail::PrintOperator(out_, "=~", op.string_expr_, op.regex_); }
-
- private:
-  std::ostream *out_;
-};
-
-namespace detail {
-inline void PrintObject(std::ostream *out, Expression *expr) {
-  if (expr) {
-    ExpressionPrettyPrinter printer{out};
-    expr->Accept(printer);
-  } else {
-    *out << "<null>";
-  }
-}
-}  // namespace detail
-
-inline void PrintExpression(Expression *expr, std::ostream *out) {
-  ExpressionPrettyPrinter printer{out};
-  expr->Accept(printer);
-}
-
-inline void PrintExpression(NamedExpression *expr, std::ostream *out) {
-  ExpressionPrettyPrinter printer{out};
-  expr->Accept(printer);
-}
-}  // namespace memgraph::expr
--- a/src/expr/exceptions.hpp
+++ b/src/expr/exceptions.hpp
@@ -1,52 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include "utils/exceptions.hpp"
-
-namespace memgraph::expr {
-
-class SyntaxException : public utils::BasicException {
- public:
-  using utils::BasicException::BasicException;
-  SyntaxException() : SyntaxException("") {}
-};
-
-class SemanticException : public utils::BasicException {
- public:
-  using utils::BasicException::BasicException;
-  SemanticException() : BasicException("") {}
-};
-
-class ExpressionRuntimeException : public utils::BasicException {
- public:
-  using utils::BasicException::BasicException;
-};
-
-class RedeclareVariableError : public SemanticException {
- public:
-  explicit RedeclareVariableError(const std::string &name) : SemanticException("Redeclaring variable: " + name + ".") {}
-};
-
-class UnboundVariableError : public SemanticException {
- public:
-  explicit UnboundVariableError(const std::string &name) : SemanticException("Unbound variable: " + name + ".") {}
-};
-
-class TypeMismatchError : public SemanticException {
- public:
-  TypeMismatchError(const std::string &name, const std::string &datum, const std::string &expected)
-      : SemanticException(fmt::format("Type mismatch: {} already defined as {}, expected {}.", name, datum, expected)) {
-  }
-};
-
-}  // namespace memgraph::expr
--- a/src/expr/interpret/eval.hpp
+++ b/src/expr/interpret/eval.hpp
@@ -1,826 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-/// @file
-#pragma once
-
-#include <algorithm>
-#include <limits>
-#include <map>
-#include <optional>
-#include <regex>
-#include <type_traits>
-#include <vector>
-
-#include "expr/ast.hpp"
-#include "expr/exceptions.hpp"
-#include "expr/interpret/frame.hpp"
-#include "expr/semantic/symbol_table.hpp"
-#include "utils/exceptions.hpp"
-
-namespace memgraph::expr {
-
-struct StorageTag {};
-struct QueryEngineTag {};
-
-template <typename TypedValue, typename EvaluationContext, typename DbAccessor, typename StorageView, typename LabelId,
-          typename PropertyValue, typename ConvFunctor, typename Error, typename Tag = StorageTag>
-class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
- public:
-  ExpressionEvaluator(Frame<TypedValue> *frame, const SymbolTable &symbol_table, const EvaluationContext &ctx,
-                      DbAccessor *dba, StorageView view)
-      : frame_(frame), symbol_table_(&symbol_table), ctx_(&ctx), dba_(dba), view_(view) {}
-
-  using ExpressionVisitor<TypedValue>::Visit;
-
-  utils::MemoryResource *GetMemoryResource() const { return ctx_->memory; }
-
-  TypedValue Visit(NamedExpression &named_expression) override {
-    const auto &symbol = symbol_table_->at(named_expression);
-    auto value = named_expression.expression_->Accept(*this);
-    frame_->at(symbol) = value;
-    return value;
-  }
-
-  TypedValue Visit(Identifier &ident) override {
-    return TypedValue(frame_->at(symbol_table_->at(ident)), ctx_->memory);
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define BINARY_OPERATOR_VISITOR(OP_NODE, CPP_OP, CYPHER_OP)                                                         \
-  /* NOLINTNEXTLINE(bugprone-macro-parentheses) */                                                                  \
-  TypedValue Visit(OP_NODE &op) override {                                                                          \
-    auto val1 = op.expression1_->Accept(*this);                                                                     \
-    auto val2 = op.expression2_->Accept(*this);                                                                     \
-    try {                                                                                                           \
-      return val1 CPP_OP val2;                                                                                      \
-    } catch (const TypedValueException &) {                                                                         \
-      throw ExpressionRuntimeException("Invalid types: {} and {} for '{}'.", val1.type(), val2.type(), #CYPHER_OP); \
-    }                                                                                                               \
-  }
-
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define UNARY_OPERATOR_VISITOR(OP_NODE, CPP_OP, CYPHER_OP)                                   \
-  /* NOLINTNEXTLINE(bugprone-macro-parentheses) */                                           \
-  TypedValue Visit(OP_NODE &op) override {                                                   \
-    auto val = op.expression_->Accept(*this);                                                \
-    try {                                                                                    \
-      return CPP_OP val;                                                                     \
-    } catch (const TypedValueException &) {                                                  \
-      throw ExpressionRuntimeException("Invalid type {} for '{}'.", val.type(), #CYPHER_OP); \
-    }                                                                                        \
-  }
-
-  BINARY_OPERATOR_VISITOR(OrOperator, ||, OR);
-  BINARY_OPERATOR_VISITOR(XorOperator, ^, XOR);
-  BINARY_OPERATOR_VISITOR(AdditionOperator, +, +);
-  BINARY_OPERATOR_VISITOR(SubtractionOperator, -, -);
-  BINARY_OPERATOR_VISITOR(MultiplicationOperator, *, *);
-  BINARY_OPERATOR_VISITOR(DivisionOperator, /, /);
-  BINARY_OPERATOR_VISITOR(ModOperator, %, %);
-  BINARY_OPERATOR_VISITOR(NotEqualOperator, !=, <>);
-  BINARY_OPERATOR_VISITOR(EqualOperator, ==, =);
-  BINARY_OPERATOR_VISITOR(LessOperator, <, <);
-  BINARY_OPERATOR_VISITOR(GreaterOperator, >, >);
-  BINARY_OPERATOR_VISITOR(LessEqualOperator, <=, <=);
-  BINARY_OPERATOR_VISITOR(GreaterEqualOperator, >=, >=);
-
-  UNARY_OPERATOR_VISITOR(NotOperator, !, NOT);
-  UNARY_OPERATOR_VISITOR(UnaryPlusOperator, +, +);
-  UNARY_OPERATOR_VISITOR(UnaryMinusOperator, -, -);
-
-#undef BINARY_OPERATOR_VISITOR
-#undef UNARY_OPERATOR_VISITOR
-
-  TypedValue Visit(AndOperator &op) override {
-    auto value1 = op.expression1_->Accept(*this);
-    if (value1.IsBool() && !value1.ValueBool()) {
-      // If first expression is false, don't evaluate the second one.
-      return value1;
-    }
-    auto value2 = op.expression2_->Accept(*this);
-    try {
-      return value1 && value2;
-    } catch (const TypedValueException &) {
-      throw ExpressionRuntimeException("Invalid types: {} and {} for AND.", value1.type(), value2.type());
-    }
-  }
-
-  TypedValue Visit(IfOperator &if_operator) override {
-    auto condition = if_operator.condition_->Accept(*this);
-    if (condition.IsNull()) {
-      return if_operator.else_expression_->Accept(*this);
-    }
-    if (condition.type() != TypedValue::Type::Bool) {
-      // At the moment IfOperator is used only in CASE construct.
-      throw ExpressionRuntimeException("CASE expected boolean expression, got {}.", condition.type());
-    }
-    if (condition.ValueBool()) {
-      return if_operator.then_expression_->Accept(*this);
-    }
-    return if_operator.else_expression_->Accept(*this);
-  }
-
-  TypedValue Visit(InListOperator &in_list) override {
-    auto literal = in_list.expression1_->Accept(*this);
-    auto _list = in_list.expression2_->Accept(*this);
-    if (_list.IsNull()) {
-      return TypedValue(ctx_->memory);
-    }
-    // Exceptions have higher priority than returning nulls when list expression
-    // is not null.
-    if (_list.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("IN expected a list, got {}.", _list.type());
-    }
-    const auto &list = _list.ValueList();
-
-    // If literal is NULL there is no need to try to compare it with every
-    // element in the list since result of every comparison will be NULL. There
-    // is one special case that we must test explicitly: if list is empty then
-    // result is false since no comparison will be performed.
-    if (list.empty()) return TypedValue(false, ctx_->memory);
-    if (literal.IsNull()) return TypedValue(ctx_->memory);
-
-    auto has_null = false;
-    for (const auto &element : list) {
-      auto result = literal == element;
-      if (result.IsNull()) {
-        has_null = true;
-      } else if (result.ValueBool()) {
-        return TypedValue(true, ctx_->memory);
-      }
-    }
-    if (has_null) {
-      return TypedValue(ctx_->memory);
-    }
-    return TypedValue(false, ctx_->memory);
-  }
-
-  TypedValue Visit(SubscriptOperator &list_indexing) override {
-    auto lhs = list_indexing.expression1_->Accept(*this);
-    auto index = list_indexing.expression2_->Accept(*this);
-    if (!lhs.IsList() && !lhs.IsMap() && !lhs.IsVertex() && !lhs.IsEdge() && !lhs.IsNull())
-      throw ExpressionRuntimeException(
-          "Expected a list, a map, a node or an edge to index with '[]', got "
-          "{}.",
-          lhs.type());
-    if (lhs.IsNull() || index.IsNull()) return TypedValue(ctx_->memory);
-    if (lhs.IsList()) {
-      if (!index.IsInt())
-        throw ExpressionRuntimeException("Expected an integer as a list index, got {}.", index.type());
-      auto index_int = index.ValueInt();
-      // NOTE: Take non-const reference to list, so that we can move out the
-      // indexed element as the result.
-      auto &list = lhs.ValueList();
-      if (index_int < 0) {
-        index_int += static_cast<int64_t>(list.size());
-      }
-      if (index_int >= static_cast<int64_t>(list.size()) || index_int < 0) return TypedValue(ctx_->memory);
-      // NOTE: Explicit move is needed, so that we return the move constructed
-      // value and preserve the correct MemoryResource.
-      return std::move(list[index_int]);
-    }
-
-    if (lhs.IsMap()) {
-      if (!index.IsString())
-        throw ExpressionRuntimeException("Expected a string as a map index, got {}.", index.type());
-      // NOTE: Take non-const reference to map, so that we can move out the
-      // looked-up element as the result.
-      auto &map = lhs.ValueMap();
-      auto found = map.find(index.ValueString());
-      if (found == map.end()) return TypedValue(ctx_->memory);
-      // NOTE: Explicit move is needed, so that we return the move constructed
-      // value and preserve the correct MemoryResource.
-      return std::move(found->second);
-    }
-
-    if (lhs.IsVertex()) {
-      if (!index.IsString())
-        throw ExpressionRuntimeException("Expected a string as a property name, got {}.", index.type());
-      return TypedValue(GetProperty(lhs.ValueVertex(), index.ValueString()), ctx_->memory);
-    }
-
-    if (lhs.IsEdge()) {
-      if (!index.IsString())
-        throw ExpressionRuntimeException("Expected a string as a property name, got {}.", index.type());
-      return TypedValue(GetProperty(lhs.ValueEdge(), index.ValueString()), ctx_->memory);
-    }
-
-    // lhs is Null
-    return TypedValue(ctx_->memory);
-  }
-
-  TypedValue Visit(ListSlicingOperator &op) override {
-    // If some type is null we can't return null, because throwing exception
-    // on illegal type has higher priority.
-    auto is_null = false;
-    auto get_bound = [&](Expression *bound_expr, int64_t default_value) {
-      if (bound_expr) {
-        auto bound = bound_expr->Accept(*this);
-        if (bound.type() == TypedValue::Type::Null) {
-          is_null = true;
-        } else if (bound.type() != TypedValue::Type::Int) {
-          throw ExpressionRuntimeException("Expected an integer for a bound in list slicing, got {}.", bound.type());
-        }
-        return bound;
-      }
-      return TypedValue(default_value, ctx_->memory);
-    };
-    auto _upper_bound = get_bound(op.upper_bound_, std::numeric_limits<int64_t>::max());
-    auto _lower_bound = get_bound(op.lower_bound_, 0);
-
-    auto _list = op.list_->Accept(*this);
-    if (_list.type() == TypedValue::Type::Null) {
-      is_null = true;
-    } else if (_list.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("Expected a list to slice, got {}.", _list.type());
-    }
-
-    if (is_null) {
-      return TypedValue(ctx_->memory);
-    }
-    const auto &list = _list.ValueList();
-    auto normalise_bound = [&](int64_t bound) {
-      if (bound < 0) {
-        bound = static_cast<int64_t>(list.size()) + bound;
-      }
-      return std::max(static_cast<int64_t>(0), std::min(bound, static_cast<int64_t>(list.size())));
-    };
-    auto lower_bound = normalise_bound(_lower_bound.ValueInt());
-    auto upper_bound = normalise_bound(_upper_bound.ValueInt());
-    if (upper_bound <= lower_bound) {
-      return TypedValue(typename TypedValue::TVector(ctx_->memory), ctx_->memory);
-    }
-    return TypedValue(
-        typename TypedValue::TVector(list.begin() + lower_bound, list.begin() + upper_bound, ctx_->memory));
-  }
-
-  TypedValue Visit(IsNullOperator &is_null) override {
-    auto value = is_null.expression_->Accept(*this);
-    return TypedValue(value.IsNull(), ctx_->memory);
-  }
-
-  TypedValue Visit(PropertyLookup &property_lookup) override {
-    auto expression_result = property_lookup.expression_->Accept(*this);
-    auto maybe_date = [this](const auto &date, const auto &prop_name) -> std::optional<TypedValue> {
-      if (prop_name == "year") {
-        return TypedValue(date.year, ctx_->memory);
-      }
-      if (prop_name == "month") {
-        return TypedValue(date.month, ctx_->memory);
-      }
-      if (prop_name == "day") {
-        return TypedValue(date.day, ctx_->memory);
-      }
-      return std::nullopt;
-    };
-    auto maybe_local_time = [this](const auto &lt, const auto &prop_name) -> std::optional<TypedValue> {
-      if (prop_name == "hour") {
-        return TypedValue(lt.hour, ctx_->memory);
-      }
-      if (prop_name == "minute") {
-        return TypedValue(lt.minute, ctx_->memory);
-      }
-      if (prop_name == "second") {
-        return TypedValue(lt.second, ctx_->memory);
-      }
-      if (prop_name == "millisecond") {
-        return TypedValue(lt.millisecond, ctx_->memory);
-      }
-      if (prop_name == "microsecond") {
-        return TypedValue(lt.microsecond, ctx_->memory);
-      }
-      return std::nullopt;
-    };
-    auto maybe_duration = [this](const auto &dur, const auto &prop_name) -> std::optional<TypedValue> {
-      if (prop_name == "day") {
-        return TypedValue(dur.Days(), ctx_->memory);
-      }
-      if (prop_name == "hour") {
-        return TypedValue(dur.SubDaysAsHours(), ctx_->memory);
-      }
-      if (prop_name == "minute") {
-        return TypedValue(dur.SubDaysAsMinutes(), ctx_->memory);
-      }
-      if (prop_name == "second") {
-        return TypedValue(dur.SubDaysAsSeconds(), ctx_->memory);
-      }
-      if (prop_name == "millisecond") {
-        return TypedValue(dur.SubDaysAsMilliseconds(), ctx_->memory);
-      }
-      if (prop_name == "microsecond") {
-        return TypedValue(dur.SubDaysAsMicroseconds(), ctx_->memory);
-      }
-      if (prop_name == "nanosecond") {
-        return TypedValue(dur.SubDaysAsNanoseconds(), ctx_->memory);
-      }
-      return std::nullopt;
-    };
-    switch (expression_result.type()) {
-      case TypedValue::Type::Null:
-        return TypedValue(ctx_->memory);
-      case TypedValue::Type::Vertex:
-        return GetProperty(expression_result.ValueVertex(), property_lookup.property_);
-      case TypedValue::Type::Edge:
-        return GetProperty(expression_result.ValueEdge(), property_lookup.property_);
-      case TypedValue::Type::Map: {
-        // NOTE: Take non-const reference to map, so that we can move out the
-        // looked-up element as the result.
-        auto &map = expression_result.ValueMap();
-        auto found = map.find(property_lookup.property_.name.c_str());
-        if (found == map.end()) return TypedValue(ctx_->memory);
-        // NOTE: Explicit move is needed, so that we return the move constructed
-        // value and preserve the correct MemoryResource.
-        return std::move(found->second);
-      }
-      case TypedValue::Type::Duration: {
-        const auto &prop_name = property_lookup.property_.name;
-        const auto &dur = expression_result.ValueDuration();
-        if (auto dur_field = maybe_duration(dur, prop_name); dur_field) {
-          return std::move(*dur_field);
-        }
-        throw ExpressionRuntimeException("Invalid property name {} for Duration", prop_name);
-      }
-      case TypedValue::Type::Date: {
-        const auto &prop_name = property_lookup.property_.name;
-        const auto &date = expression_result.ValueDate();
-        if (auto date_field = maybe_date(date, prop_name); date_field) {
-          return std::move(*date_field);
-        }
-        throw ExpressionRuntimeException("Invalid property name {} for Date", prop_name);
-      }
-      case TypedValue::Type::LocalTime: {
-        const auto &prop_name = property_lookup.property_.name;
-        const auto &lt = expression_result.ValueLocalTime();
-        if (auto lt_field = maybe_local_time(lt, prop_name); lt_field) {
-          return std::move(*lt_field);
-        }
-        throw ExpressionRuntimeException("Invalid property name {} for LocalTime", prop_name);
-      }
-      case TypedValue::Type::LocalDateTime: {
-        const auto &prop_name = property_lookup.property_.name;
-        const auto &ldt = expression_result.ValueLocalDateTime();
-        if (auto date_field = maybe_date(ldt.date, prop_name); date_field) {
-          return std::move(*date_field);
-        }
-        if (auto lt_field = maybe_local_time(ldt.local_time, prop_name); lt_field) {
-          return std::move(*lt_field);
-        }
-        throw ExpressionRuntimeException("Invalid property name {} for LocalDateTime", prop_name);
-      }
-      default:
-        throw ExpressionRuntimeException("Only nodes, edges, maps and temporal types have properties to be looked-up.");
-    }
-  }
-
-  template <typename VertexAccessor, typename TTag = Tag,
-            typename TReturnType = std::enable_if_t<std::is_same_v<TTag, StorageTag>, bool>>
-  TReturnType HasLabelImpl(const VertexAccessor &vertex, const LabelIx &label, StorageTag /*tag*/) {
-    auto has_label = vertex.HasLabel(view_, GetLabel(label));
-    if (has_label.HasError() && has_label.GetError() == Error::NONEXISTENT_OBJECT) {
-      // This is a very nasty and temporary hack in order to make MERGE
-      // work. The old storage had the following logic when returning an
-      // `OLD` view: `return old ? old : new`. That means that if the
-      // `OLD` view didn't exist, it returned the NEW view. With this hack
-      // we simulate that behavior.
-      // TODO (mferencevic, teon.banek): Remove once MERGE is
-      // reimplemented.
-      has_label = vertex.HasLabel(StorageView::NEW, GetLabel(label));
-    }
-    if (has_label.HasError()) {
-      switch (has_label.GetError()) {
-        case Error::DELETED_OBJECT:
-          throw ExpressionRuntimeException("Trying to access labels on a deleted node.");
-        case Error::NONEXISTENT_OBJECT:
-          throw ExpressionRuntimeException("Trying to access labels from a node that doesn't exist.");
-        case Error::SERIALIZATION_ERROR:
-        case Error::VERTEX_HAS_EDGES:
-        case Error::PROPERTIES_DISABLED:
-          throw ExpressionRuntimeException("Unexpected error when accessing labels.");
-      }
-    }
-    return *has_label;
-  }
-
-  template <typename VertexAccessor, typename TTag = Tag,
-            typename TReturnType = std::enable_if_t<std::is_same_v<TTag, QueryEngineTag>, bool>>
-  TReturnType HasLabelImpl(const VertexAccessor &vertex, const LabelIx &label_ix, QueryEngineTag /*tag*/) {
-    auto label = typename VertexAccessor::Label{LabelId::FromUint(label_ix.ix)};
-    auto has_label = vertex.HasLabel(label);
-    return !has_label;
-  }
-
-  TypedValue Visit(LabelsTest &labels_test) override {
-    auto expression_result = labels_test.expression_->Accept(*this);
-    switch (expression_result.type()) {
-      case TypedValue::Type::Null:
-        return TypedValue(ctx_->memory);
-      case TypedValue::Type::Vertex: {
-        const auto &vertex = expression_result.ValueVertex();
-        if (std::ranges::all_of(labels_test.labels_, [&vertex, this](const auto label_test) {
-              return this->HasLabelImpl(vertex, label_test, Tag{});
-            })) {
-          return TypedValue(true, ctx_->memory);
-        }
-        return TypedValue(false, ctx_->memory);
-      }
-      default:
-        throw ExpressionRuntimeException("Only nodes have labels.");
-    }
-  }
-
-  TypedValue Visit(PrimitiveLiteral &literal) override {
-    // TODO: no need to evaluate constants, we can write it to frame in one
-    // of the previous phases.
-    return TypedValue(literal.value_, ctx_->memory);
-  }
-
-  TypedValue Visit(ListLiteral &literal) override {
-    typename TypedValue::TVector result(ctx_->memory);
-    result.reserve(literal.elements_.size());
-    for (const auto &expression : literal.elements_) result.emplace_back(expression->Accept(*this));
-    return TypedValue(result, ctx_->memory);
-  }
-
-  TypedValue Visit(MapLiteral &literal) override {
-    typename TypedValue::TMap result(ctx_->memory);
-    for (const auto &pair : literal.elements_) result.emplace(pair.first.name, pair.second->Accept(*this));
-    return TypedValue(result, ctx_->memory);
-  }
-
-  TypedValue Visit(Aggregation &aggregation) override {
-    return TypedValue(frame_->at(symbol_table_->at(aggregation)), ctx_->memory);
-  }
-
-  TypedValue Visit(Coalesce &coalesce) override {
-    auto &exprs = coalesce.expressions_;
-
-    if (exprs.size() == 0) {
-      throw ExpressionRuntimeException("'coalesce' requires at least one argument.");
-    }
-
-    for (int64_t i = 0; i < exprs.size(); ++i) {
-      TypedValue val(exprs[i]->Accept(*this), ctx_->memory);
-      if (!val.IsNull()) {
-        return val;
-      }
-    }
-
-    return TypedValue(ctx_->memory);
-  }
-
-  TypedValue Visit(Function &function) override {
-    FunctionContext function_ctx{dba_, ctx_->memory, ctx_->timestamp, &ctx_->counters, view_};
-    // Stack allocate evaluated arguments when there's a small number of them.
-    if (function.arguments_.size() <= 8) {
-      TypedValue arguments[8] = {TypedValue(ctx_->memory), TypedValue(ctx_->memory), TypedValue(ctx_->memory),
-                                 TypedValue(ctx_->memory), TypedValue(ctx_->memory), TypedValue(ctx_->memory),
-                                 TypedValue(ctx_->memory), TypedValue(ctx_->memory)};
-      for (size_t i = 0; i < function.arguments_.size(); ++i) {
-        arguments[i] = function.arguments_[i]->Accept(*this);
-      }
-      auto res = function.function_(arguments, function.arguments_.size(), function_ctx);
-      MG_ASSERT(res.GetMemoryResource() == ctx_->memory);
-      return res;
-    } else {
-      typename TypedValue::TVector arguments(ctx_->memory);
-      arguments.reserve(function.arguments_.size());
-      for (const auto &argument : function.arguments_) {
-        arguments.emplace_back(argument->Accept(*this));
-      }
-      auto res = function.function_(arguments.data(), arguments.size(), function_ctx);
-      MG_ASSERT(res.GetMemoryResource() == ctx_->memory);
-      return res;
-    }
-  }
-
-  TypedValue Visit(Reduce &reduce) override {
-    auto list_value = reduce.list_->Accept(*this);
-    if (list_value.IsNull()) {
-      return TypedValue(ctx_->memory);
-    }
-    if (list_value.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("REDUCE expected a list, got {}.", list_value.type());
-    }
-    const auto &list = list_value.ValueList();
-    const auto &element_symbol = symbol_table_->at(*reduce.identifier_);
-    const auto &accumulator_symbol = symbol_table_->at(*reduce.accumulator_);
-    auto accumulator = reduce.initializer_->Accept(*this);
-    for (const auto &element : list) {
-      frame_->at(accumulator_symbol) = accumulator;
-      frame_->at(element_symbol) = element;
-      accumulator = reduce.expression_->Accept(*this);
-    }
-    return accumulator;
-  }
-
-  TypedValue Visit(Extract &extract) override {
-    auto list_value = extract.list_->Accept(*this);
-    if (list_value.IsNull()) {
-      return TypedValue(ctx_->memory);
-    }
-    if (list_value.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("EXTRACT expected a list, got {}.", list_value.type());
-    }
-    const auto &list = list_value.ValueList();
-    const auto &element_symbol = symbol_table_->at(*extract.identifier_);
-    typename TypedValue::TVector result(ctx_->memory);
-    result.reserve(list.size());
-    for (const auto &element : list) {
-      if (element.IsNull()) {
-        result.emplace_back();
-      } else {
-        frame_->at(element_symbol) = element;
-        result.emplace_back(extract.expression_->Accept(*this));
-      }
-    }
-    return TypedValue(result, ctx_->memory);
-  }
-
-  TypedValue Visit(All &all) override {
-    auto list_value = all.list_expression_->Accept(*this);
-    if (list_value.IsNull()) {
-      return TypedValue(ctx_->memory);
-    }
-    if (list_value.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("ALL expected a list, got {}.", list_value.type());
-    }
-    const auto &list = list_value.ValueList();
-    const auto &symbol = symbol_table_->at(*all.identifier_);
-    bool has_null_elements = false;
-    bool has_value = false;
-    for (const auto &element : list) {
-      frame_->at(symbol) = element;
-      auto result = all.where_->expression_->Accept(*this);
-      if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
-        throw ExpressionRuntimeException("Predicate of ALL must evaluate to boolean, got {}.", result.type());
-      }
-      if (!result.IsNull()) {
-        has_value = true;
-        if (!result.ValueBool()) {
-          return TypedValue(false, ctx_->memory);
-        }
-      } else {
-        has_null_elements = true;
-      }
-    }
-    if (!has_value) {
-      return TypedValue(ctx_->memory);
-    }
-    if (has_null_elements) {
-      return TypedValue(false, ctx_->memory);
-    } else {
-      return TypedValue(true, ctx_->memory);
-    }
-  }
-
-  TypedValue Visit(Single &single) override {
-    auto list_value = single.list_expression_->Accept(*this);
-    if (list_value.IsNull()) {
-      return TypedValue(ctx_->memory);
-    }
-    if (list_value.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("SINGLE expected a list, got {}.", list_value.type());
-    }
-    const auto &list = list_value.ValueList();
-    const auto &symbol = symbol_table_->at(*single.identifier_);
-    bool has_value = false;
-    bool predicate_satisfied = false;
-    for (const auto &element : list) {
-      frame_->at(symbol) = element;
-      auto result = single.where_->expression_->Accept(*this);
-      if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
-        throw ExpressionRuntimeException("Predicate of SINGLE must evaluate to boolean, got {}.", result.type());
-      }
-      if (result.type() == TypedValue::Type::Bool) {
-        has_value = true;
-      }
-      if (result.IsNull() || !result.ValueBool()) {
-        continue;
-      }
-      // Return false if more than one element satisfies the predicate.
-      if (predicate_satisfied) {
-        return TypedValue(false, ctx_->memory);
-      } else {
-        predicate_satisfied = true;
-      }
-    }
-    if (!has_value) {
-      return TypedValue(ctx_->memory);
-    } else {
-      return TypedValue(predicate_satisfied, ctx_->memory);
-    }
-  }
-
-  TypedValue Visit(Any &any) override {
-    auto list_value = any.list_expression_->Accept(*this);
-    if (list_value.IsNull()) {
-      return TypedValue(ctx_->memory);
-    }
-    if (list_value.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("ANY expected a list, got {}.", list_value.type());
-    }
-    const auto &list = list_value.ValueList();
-    const auto &symbol = symbol_table_->at(*any.identifier_);
-    bool has_value = false;
-    for (const auto &element : list) {
-      frame_->at(symbol) = element;
-      auto result = any.where_->expression_->Accept(*this);
-      if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
-        throw ExpressionRuntimeException("Predicate of ANY must evaluate to boolean, got {}.", result.type());
-      }
-      if (!result.IsNull()) {
-        has_value = true;
-        if (result.ValueBool()) {
-          return TypedValue(true, ctx_->memory);
-        }
-      }
-    }
-    // Return Null if all elements are Null
-    if (!has_value) {
-      return TypedValue(ctx_->memory);
-    } else {
-      return TypedValue(false, ctx_->memory);
-    }
-  }
-
-  TypedValue Visit(None &none) override {
-    auto list_value = none.list_expression_->Accept(*this);
-    if (list_value.IsNull()) {
-      return TypedValue(ctx_->memory);
-    }
-    if (list_value.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("NONE expected a list, got {}.", list_value.type());
-    }
-    const auto &list = list_value.ValueList();
-    const auto &symbol = symbol_table_->at(*none.identifier_);
-    bool has_value = false;
-    for (const auto &element : list) {
-      frame_->at(symbol) = element;
-      auto result = none.where_->expression_->Accept(*this);
-      if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
-        throw ExpressionRuntimeException("Predicate of NONE must evaluate to boolean, got {}.", result.type());
-      }
-      if (!result.IsNull()) {
-        has_value = true;
-        if (result.ValueBool()) {
-          return TypedValue(false, ctx_->memory);
-        }
-      }
-    }
-    // Return Null if all elements are Null
-    if (!has_value) {
-      return TypedValue(ctx_->memory);
-    } else {
-      return TypedValue(true, ctx_->memory);
-    }
-  }
-
-  TypedValue Visit(ParameterLookup &param_lookup) override {
-    return TypedValue(conv_(ctx_->parameters.AtTokenPosition(param_lookup.token_position_)), ctx_->memory);
-  }
-
-  TypedValue Visit(RegexMatch &regex_match) override {
-    auto target_string_value = regex_match.string_expr_->Accept(*this);
-    auto regex_value = regex_match.regex_->Accept(*this);
-    if (target_string_value.IsNull() || regex_value.IsNull()) {
-      return TypedValue(ctx_->memory);
-    }
-    if (regex_value.type() != TypedValue::Type::String) {
-      throw ExpressionRuntimeException("Regular expression must evaluate to a string, got {}.", regex_value.type());
-    }
-    if (target_string_value.type() != TypedValue::Type::String) {
-      // Instead of error, we return Null which makes it compatible in case we
-      // use indexed lookup which filters out any non-string properties.
-      // Assuming a property lookup is the target_string_value.
-      return TypedValue(ctx_->memory);
-    }
-    const auto &target_string = target_string_value.ValueString();
-    try {
-      std::regex regex(regex_value.ValueString());
-      return TypedValue(std::regex_match(target_string, regex), ctx_->memory);
-    } catch (const std::regex_error &e) {
-      throw ExpressionRuntimeException("Regex error in '{}': {}", regex_value.ValueString(), e.what());
-    }
-  }
-
- private:
-  template <class TRecordAccessor, class TTag = Tag,
-            class TReturnType = std::enable_if_t<std::is_same_v<TTag, QueryEngineTag>, TypedValue>>
-  TReturnType GetProperty(const TRecordAccessor &record_accessor, PropertyIx prop) {
-    auto maybe_prop = record_accessor.GetProperty(prop.name);
-    // Handler non existent property
-    return conv_(maybe_prop);
-  }
-
-  template <class TRecordAccessor, class TTag = Tag,
-            class TReturnType = std::enable_if_t<std::is_same_v<TTag, QueryEngineTag>, TypedValue>>
-  TReturnType GetProperty(const TRecordAccessor &record_accessor, const std::string_view name) {
-    auto maybe_prop = record_accessor.GetProperty(std::string(name));
-    // Handler non existent property
-    return conv_(maybe_prop);
-  }
-
-  template <class TRecordAccessor, class TTag = Tag,
-            class TReturnType = std::enable_if_t<std::is_same_v<TTag, StorageTag>, TypedValue>>
-  TypedValue GetProperty(const TRecordAccessor &record_accessor, PropertyIx prop) {
-    auto maybe_prop = record_accessor.GetProperty(view_, ctx_->properties[prop.ix]);
-    if (maybe_prop.HasError() && maybe_prop.GetError() == Error::NONEXISTENT_OBJECT) {
-      // This is a very nasty and temporary hack in order to make MERGE work.
-      // The old storage had the following logic when returning an `OLD` view:
-      // `return old ? old : new`. That means that if the `OLD` view didn't
-      // exist, it returned the NEW view. With this hack we simulate that
-      // behavior.
-      // TODO (mferencevic, teon.banek): Remove once MERGE is reimplemented.
-      maybe_prop = record_accessor.GetProperty(StorageView::NEW, ctx_->properties[prop.ix]);
-    }
-    if (maybe_prop.HasError()) {
-      switch (maybe_prop.GetError()) {
-        case Error::DELETED_OBJECT:
-          throw ExpressionRuntimeException("Trying to get a property from a deleted object.");
-        case Error::NONEXISTENT_OBJECT:
-          throw ExpressionRuntimeException("Trying to get a property from an object that doesn't exist.");
-        case Error::SERIALIZATION_ERROR:
-        case Error::VERTEX_HAS_EDGES:
-        case Error::PROPERTIES_DISABLED:
-          throw ExpressionRuntimeException("Unexpected error when getting a property.");
-      }
-    }
-    return conv_(*maybe_prop, ctx_->memory);
-  }
-
-  template <class TRecordAccessor, class TTag = Tag,
-            class TReturnType = std::enable_if_t<std::is_same_v<TTag, StorageTag>, TypedValue>>
-  TypedValue GetProperty(const TRecordAccessor &record_accessor, const std::string_view name) {
-    auto maybe_prop = record_accessor.GetProperty(view_, dba_->NameToProperty(name));
-    if (maybe_prop.HasError() && maybe_prop.GetError() == Error::NONEXISTENT_OBJECT) {
-      // This is a very nasty and temporary hack in order to make MERGE work.
-      // The old storage had the following logic when returning an `OLD` view:
-      // `return old ? old : new`. That means that if the `OLD` view didn't
-      // exist, it returned the NEW view. With this hack we simulate that
-      // behavior.
-      // TODO (mferencevic, teon.banek): Remove once MERGE is reimplemented.
-      maybe_prop = record_accessor.GetProperty(view_, dba_->NameToProperty(name));
-    }
-    if (maybe_prop.HasError()) {
-      switch (maybe_prop.GetError()) {
-        case Error::DELETED_OBJECT:
-          throw ExpressionRuntimeException("Trying to get a property from a deleted object.");
-        case Error::NONEXISTENT_OBJECT:
-          throw ExpressionRuntimeException("Trying to get a property from an object that doesn't exist.");
-        case Error::SERIALIZATION_ERROR:
-        case Error::VERTEX_HAS_EDGES:
-        case Error::PROPERTIES_DISABLED:
-          throw ExpressionRuntimeException("Unexpected error when getting a property.");
-      }
-    }
-    return conv_(*maybe_prop, ctx_->memory);
-  }
-
-  LabelId GetLabel(LabelIx label) { return ctx_->labels[label.ix]; }
-
-  Frame<TypedValue> *frame_;
-  const SymbolTable *symbol_table_;
-  const EvaluationContext *ctx_;
-  DbAccessor *dba_;
-  // which switching approach should be used when evaluating
-  StorageView view_;
-  ConvFunctor conv_;
-};
-
-/// A helper function for evaluating an expression that's an int.
-///
-/// @param what - Name of what's getting evaluated. Used for user feedback (via
-///               exception) when the evaluated value is not an int.
-/// @throw ExpressionRuntimeException if expression doesn't evaluate to an int.
-template <typename ExpressionEvaluator>
-int64_t EvaluateInt(ExpressionEvaluator *evaluator, Expression *expr, const std::string &what) {
-  TypedValue value = expr->Accept(*evaluator);
-  try {
-    return value.ValueInt();
-  } catch (TypedValueException &e) {
-    throw ExpressionRuntimeException(what + " must be an int");
-  }
-}
-
-template <typename ExpressionEvaluator>
-std::optional<size_t> EvaluateMemoryLimit(ExpressionEvaluator *eval, Expression *memory_limit, size_t memory_scale) {
-  if (!memory_limit) return std::nullopt;
-  auto limit_value = memory_limit->Accept(*eval);
-  if (!limit_value.IsInt() || limit_value.ValueInt() <= 0)
-    throw ExpressionRuntimeException("Memory limit must be a non-negative integer.");
-  size_t limit = limit_value.ValueInt();
-  if (std::numeric_limits<size_t>::max() / memory_scale < limit)
-    throw ExpressionRuntimeException("Memory limit overflow.");
-  return limit * memory_scale;
-}
-
-}  // namespace memgraph::expr
--- a/src/expr/interpret/frame.hpp
+++ b/src/expr/interpret/frame.hpp
@@ -1,45 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <vector>
-
-#include "expr/semantic/symbol_table.hpp"
-#include "utils/logging.hpp"
-#include "utils/memory.hpp"
-#include "utils/pmr/vector.hpp"
-
-namespace memgraph::expr {
-
-template <typename TypedValue>
-class Frame {
- public:
-  /// Create a Frame of given size backed by a utils::NewDeleteResource()
-  explicit Frame(int64_t size) : elems_(size, utils::NewDeleteResource()) { MG_ASSERT(size >= 0); }
-
-  Frame(int64_t size, utils::MemoryResource *memory) : elems_(size, memory) { MG_ASSERT(size >= 0); }
-
-  TypedValue &operator[](const Symbol &symbol) { return elems_[symbol.position()]; }
-  const TypedValue &operator[](const Symbol &symbol) const { return elems_[symbol.position()]; }
-
-  TypedValue &at(const Symbol &symbol) { return elems_.at(symbol.position()); }
-  const TypedValue &at(const Symbol &symbol) const { return elems_.at(symbol.position()); }
-
-  auto &elems() { return elems_; }
-
-  utils::MemoryResource *GetMemoryResource() const { return elems_.get_allocator().GetMemoryResource(); }
-
- private:
-  utils::pmr::vector<TypedValue> elems_;
-};
-
-}  // namespace memgraph::expr
--- a/src/expr/parsing.cpp
+++ b/src/expr/parsing.cpp
@@ -1,184 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "expr/parsing.hpp"
-
-#include <cctype>
-#include <codecvt>
-#include <locale>
-#include <stdexcept>
-
-#include "expr/exceptions.hpp"
-#include "utils/logging.hpp"
-#include "utils/string.hpp"
-
-namespace memgraph::expr {
-
-int64_t ParseIntegerLiteral(const std::string &s) {
-  try {
-    // Not really correct since long long can have a bigger range than int64_t.
-    return static_cast<int64_t>(std::stoll(s, 0, 0));
-  } catch (const std::out_of_range &) {
-    throw SemanticException("Integer literal exceeds 64 bits.");
-  }
-}
-
-std::string ParseStringLiteral(const std::string &s) {
-  // These functions is declared as lambda since its semantics is highly
-  // specific for this conxtext and shouldn't be used elsewhere.
-  auto EncodeEscapedUnicodeCodepointUtf32 = [](const std::string &s, int &i) {
-    const int kLongUnicodeLength = 8;
-    int j = i + 1;
-    while (j < static_cast<int>(s.size()) - 1 && j < i + kLongUnicodeLength + 1 && isxdigit(s[j])) {
-      ++j;
-    }
-    if (j - i == kLongUnicodeLength + 1) {
-      char32_t t = stoi(s.substr(i + 1, kLongUnicodeLength), 0, 16);
-      i += kLongUnicodeLength;
-      std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
-      return converter.to_bytes(t);
-    }
-    throw SyntaxException(
-        "Expected 8 hex digits as unicode codepoint started with \\U. "
-        "Use \\u for 4 hex digits format.");
-  };
-  auto EncodeEscapedUnicodeCodepointUtf16 = [](const std::string &s, int &i) {
-    const int kShortUnicodeLength = 4;
-    int j = i + 1;
-    while (j < static_cast<int>(s.size()) - 1 && j < i + kShortUnicodeLength + 1 && isxdigit(s[j])) {
-      ++j;
-    }
-    if (j - i >= kShortUnicodeLength + 1) {
-      char16_t t = stoi(s.substr(i + 1, kShortUnicodeLength), 0, 16);
-      if (t >= 0xD800 && t <= 0xDBFF) {
-        // t is high surrogate pair. Expect one more utf16 codepoint.
-        j = i + kShortUnicodeLength + 1;
-        if (j >= static_cast<int>(s.size()) - 1 || s[j] != '\\') {
-          throw SemanticException("Invalid UTF codepoint.");
-        }
-        ++j;
-        if (j >= static_cast<int>(s.size()) - 1 || (s[j] != 'u' && s[j] != 'U')) {
-          throw SemanticException("Invalid UTF codepoint.");
-        }
-        ++j;
-        int k = j;
-        while (k < static_cast<int>(s.size()) - 1 && k < j + kShortUnicodeLength && isxdigit(s[k])) {
-          ++k;
-        }
-        if (k != j + kShortUnicodeLength) {
-          throw SemanticException("Invalid UTF codepoint.");
-        }
-        char16_t surrogates[3] = {t, static_cast<char16_t>(stoi(s.substr(j, kShortUnicodeLength), 0, 16)), 0};
-        i += kShortUnicodeLength + 2 + kShortUnicodeLength;
-        std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> converter;
-        return converter.to_bytes(surrogates);
-      } else {
-        i += kShortUnicodeLength;
-        std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> converter;
-        return converter.to_bytes(t);
-      }
-    }
-    throw SyntaxException(
-        "Expected 4 hex digits as unicode codepoint started with \\u. "
-        "Use \\U for 8 hex digits format.");
-  };
-
-  std::string unescaped;
-  bool escape = false;
-
-  // First and last char is quote, we don't need to look at them.
-  for (int i = 1; i < static_cast<int>(s.size()) - 1; ++i) {
-    if (escape) {
-      switch (s[i]) {
-        case '\\':
-          unescaped += '\\';
-          break;
-        case '\'':
-          unescaped += '\'';
-          break;
-        case '"':
-          unescaped += '"';
-          break;
-        case 'B':
-        case 'b':
-          unescaped += '\b';
-          break;
-        case 'F':
-        case 'f':
-          unescaped += '\f';
-          break;
-        case 'N':
-        case 'n':
-          unescaped += '\n';
-          break;
-        case 'R':
-        case 'r':
-          unescaped += '\r';
-          break;
-        case 'T':
-        case 't':
-          unescaped += '\t';
-          break;
-        case 'U':
-          try {
-            unescaped += EncodeEscapedUnicodeCodepointUtf32(s, i);
-          } catch (const std::range_error &) {
-            throw SemanticException("Invalid UTF codepoint.");
-          }
-          break;
-        case 'u':
-          try {
-            unescaped += EncodeEscapedUnicodeCodepointUtf16(s, i);
-          } catch (const std::range_error &) {
-            throw SemanticException("Invalid UTF codepoint.");
-          }
-          break;
-        default:
-          // This should never happen, except grammar changes and we don't
-          // notice change in this production.
-          DLOG_FATAL("can't happen");
-          throw std::exception();
-      }
-      escape = false;
-    } else if (s[i] == '\\') {
-      escape = true;
-    } else {
-      unescaped += s[i];
-    }
-  }
-  return unescaped;
-}
-
-double ParseDoubleLiteral(const std::string &s) {
-  try {
-    return utils::ParseDouble(s);
-  } catch (const utils::BasicException &) {
-    throw SemanticException("Couldn't parse string to double.");
-  }
-}
-
-std::string ParseParameter(const std::string &s) {
-  DMG_ASSERT(s[0] == '$', "Invalid string passed as parameter name");
-  if (s[1] != '`') return s.substr(1);
-  // If parameter name is escaped symbolic name then symbolic name should be
-  // unescaped and leading and trailing backquote should be removed.
-  DMG_ASSERT(s.size() > 3U && s.back() == '`', "Invalid string passed as parameter name");
-  std::string out;
-  for (int i = 2; i < static_cast<int>(s.size()) - 1; ++i) {
-    if (s[i] == '`') {
-      ++i;
-    }
-    out.push_back(s[i]);
-  }
-  return out;
-}
-
-}  // namespace memgraph::expr
--- a/src/expr/parsing.hpp
+++ b/src/expr/parsing.hpp
@@ -1,27 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-/// @file
-#pragma once
-
-#include <cstdint>
-#include <string>
-
-namespace memgraph::expr {
-
-// These are the functions for parsing literals and parameter names from
-// opencypher query.
-int64_t ParseIntegerLiteral(const std::string &s);
-std::string ParseStringLiteral(const std::string &s);
-double ParseDoubleLiteral(const std::string &s);
-std::string ParseParameter(const std::string &s);
-
-}  // namespace memgraph::expr
--- a/src/expr/semantic/symbol.lcp
+++ b/src/expr/semantic/symbol.lcp
@@ -1,87 +0,0 @@
-;; Copyright 2022 Memgraph Ltd.
-;;
-;; Use of this software is governed by the Business Source License
-;; included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-;; License, and you may not use this file except in compliance with the Business Source License.
-;;
-;; As of the Change Date specified in that file, in accordance with
-;; the Business Source License, use of this software will be governed
-;; by the Apache License, Version 2.0, included in the file
-;; licenses/APL.txt.
-
-#>cpp
-#pragma once
-
-#include <string>
-
-#include "utils/typeinfo.hpp"
-cpp<#
-
-(lcp:namespace memgraph)
-(lcp:namespace expr)
-
-(lcp:define-class symbol ()
-  ((name "std::string" :scope :public)
-   (position :int64_t :scope :public)
-   (user-declared :bool :initval "true" :scope :public)
-   (type "Type" :initval "Type::ANY" :scope :public)
-   (token-position :int64_t :initval "-1" :scope :public))
-  (:public
-    ;; This is similar to TypedValue::Type, but this has `Any` type.
-    ;; TODO: Make a better Type structure which can store a generic List.
-    (lcp:define-enum type (any vertex edge path number edge-list)
-      (:serialize))
-    #>cpp
-    // TODO: Generate enum to string conversion from LCP. Note, that this is
-    // displayed to the end user, so we may want to have a pretty name of each
-    // value.
-    static std::string TypeToString(Type type) {
-      const char *enum_string[] = {"Any",  "Vertex", "Edge",
-                                   "Path", "Number", "EdgeList"};
-      return enum_string[static_cast<int>(type)];
-    }
-
-    Symbol() {}
-    Symbol(const std::string &name, int position, bool user_declared,
-           Type type = Type::ANY, int token_position = -1)
-        : name_(name),
-          position_(position),
-          user_declared_(user_declared),
-          type_(type),
-          token_position_(token_position) {}
-
-    bool operator==(const Symbol &other) const {
-      return position_ == other.position_ && name_ == other.name_ &&
-             type_ == other.type_;
-    }
-    bool operator!=(const Symbol &other) const { return !operator==(other); }
-
-    // TODO: Remove these since members are public
-    const auto &name() const { return name_; }
-    int position() const { return position_; }
-    Type type() const { return type_; }
-    bool user_declared() const { return user_declared_; }
-    int token_position() const { return token_position_; }
-    cpp<#)
-  (:serialize (:slk)))
-
-(lcp:pop-namespace) ;; expr
-(lcp:pop-namespace) ;; memgraph
-
-#>cpp
-namespace std {
-
-template <>
-struct hash<memgraph::expr::Symbol> {
-  size_t operator()(const memgraph::expr::Symbol &symbol) const {
-    size_t prime = 265443599u;
-    size_t hash = std::hash<int>{}(symbol.position());
-    hash ^= prime * std::hash<std::string>{}(symbol.name());
-    hash ^= prime * std::hash<int>{}(static_cast<int>(symbol.type()));
-    return hash;
-  }
-};
-
-}  // namespace std
-
-cpp<#
--- a/src/expr/semantic/symbol_generator.hpp
+++ b/src/expr/semantic/symbol_generator.hpp
@@ -1,712 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-// Copyright 2017 Memgraph
-//
-// Created by Teon Banek on 11-03-2017
-
-#pragma once
-
-#include <algorithm>
-#include <optional>
-#include <ranges>
-#include <unordered_map>
-#include <unordered_set>
-#include <variant>
-#include <vector>
-
-#include "expr/ast.hpp"
-#include "expr/ast/ast_visitor.hpp"
-#include "expr/exceptions.hpp"
-#include "expr/semantic/symbol_table.hpp"
-
-namespace memgraph::expr {
-namespace detail {
-inline std::unordered_map<std::string, Identifier *> GeneratePredefinedIdentifierMap(
-    const std::vector<Identifier *> &predefined_identifiers) {
-  std::unordered_map<std::string, Identifier *> identifier_map;
-  for (const auto &identifier : predefined_identifiers) {
-    identifier_map.emplace(identifier->name_, identifier);
-  }
-
-  return identifier_map;
-}
-}  // namespace detail
-
-/// Visits the AST and generates symbols for variables.
-///
-/// During the process of symbol generation, simple semantic checks are
-/// performed. Such as, redeclaring a variable or conflicting expectations of
-/// variable types.
-class SymbolGenerator : public HierarchicalTreeVisitor {
- public:
-  explicit SymbolGenerator(SymbolTable *symbol_table, const std::vector<Identifier *> &predefined_identifiers)
-      : symbol_table_(symbol_table),
-        predefined_identifiers_{detail::GeneratePredefinedIdentifierMap(predefined_identifiers)},
-        scopes_(1, Scope()) {}
-
-  using HierarchicalTreeVisitor::PostVisit;
-  using HierarchicalTreeVisitor::PreVisit;
-  using HierarchicalTreeVisitor::Visit;
-  using typename HierarchicalTreeVisitor::ReturnType;
-
-  // Query
-  bool PreVisit(SingleQuery & /*unused*/) override {
-    prev_return_names_ = curr_return_names_;
-    curr_return_names_.clear();
-    return true;
-  }
-
-  // Union
-  bool PreVisit(CypherUnion & /*unused*/) override {
-    scopes_.back() = Scope();
-    return true;
-  }
-
-  bool PostVisit(CypherUnion &cypher_union) override {
-    if (prev_return_names_ != curr_return_names_) {
-      throw SemanticException("All subqueries in an UNION must have the same column names.");
-    }
-
-    // create new symbols for the result of the union
-    for (const auto &name : curr_return_names_) {
-      auto symbol = CreateSymbol(name, false);
-      cypher_union.union_symbols_.push_back(symbol);
-    }
-
-    return true;
-  }
-
-  // Clauses
-  bool PreVisit(Create & /*unused*/) override {
-    scopes_.back().in_create = true;
-    return true;
-  }
-
-  bool PostVisit(Create & /*unused*/) override {
-    scopes_.back().in_create = false;
-    return true;
-  }
-
-  bool PreVisit(CallProcedure &call_proc) override {
-    for (auto *expr : call_proc.arguments_) {
-      expr->Accept(*this);
-    }
-    return false;
-  }
-
-  bool PostVisit(CallProcedure &call_proc) override {
-    for (auto *ident : call_proc.result_identifiers_) {
-      if (HasSymbolLocalScope(ident->name_)) {
-        throw RedeclareVariableError(ident->name_);
-      }
-      ident->MapTo(CreateSymbol(ident->name_, true));
-    }
-    return true;
-  }
-
-  bool PreVisit(LoadCsv & /*unused*/) override { return false; }
-
-  bool PostVisit(LoadCsv &load_csv) override {
-    if (HasSymbolLocalScope(load_csv.row_var_->name_)) {
-      throw RedeclareVariableError(load_csv.row_var_->name_);
-    }
-    load_csv.row_var_->MapTo(CreateSymbol(load_csv.row_var_->name_, true));
-    return true;
-  }
-
-  bool PreVisit(Return &ret) override {
-    auto &scope = scopes_.back();
-    scope.in_return = true;
-    VisitReturnBody(ret.body_);
-    scope.in_return = false;
-    return false;  // We handled the traversal ourselves.
-  }
-
-  bool PostVisit(Return & /*unused*/) override {
-    for (const auto &name_symbol : scopes_.back().symbols) curr_return_names_.insert(name_symbol.first);
-    return true;
-  }
-
-  bool PreVisit(With &with) override {
-    auto &scope = scopes_.back();
-    scope.in_with = true;
-    VisitReturnBody(with.body_, with.where_);
-    scope.in_with = false;
-    return false;  // We handled the traversal ourselves.
-  }
-
-  bool PreVisit(Where & /*unused*/) override {
-    scopes_.back().in_where = true;
-    return true;
-  }
-
-  bool PostVisit(Where & /*unused*/) override {
-    scopes_.back().in_where = false;
-    return true;
-  }
-
-  bool PreVisit(Merge & /*unused*/) override {
-    scopes_.back().in_merge = true;
-    return true;
-  }
-
-  bool PostVisit(Merge & /*unused*/) override {
-    scopes_.back().in_merge = false;
-    return true;
-  }
-
-  bool PostVisit(Unwind &unwind) override {
-    const auto &name = unwind.named_expression_->name_;
-    if (HasSymbolLocalScope(name)) {
-      throw RedeclareVariableError(name);
-    }
-    unwind.named_expression_->MapTo(CreateSymbol(name, true));
-    return true;
-  }
-
-  bool PreVisit(Match & /*unused*/) override {
-    scopes_.back().in_match = true;
-    return true;
-  }
-
-  bool PostVisit(Match & /*unused*/) override {
-    auto &scope = scopes_.back();
-    scope.in_match = false;
-    // Check variables in property maps after visiting Match, so that they can
-    // reference symbols out of bind order.
-    for (auto &ident : scope.identifiers_in_match) {
-      if (!HasSymbolLocalScope(ident->name_) && !ConsumePredefinedIdentifier(ident->name_))
-        throw UnboundVariableError(ident->name_);
-      ident->MapTo(scope.symbols[ident->name_]);
-    }
-    scope.identifiers_in_match.clear();
-    return true;
-  }
-
-  bool PreVisit(Foreach &for_each) override {
-    const auto &name = for_each.named_expression_->name_;
-    scopes_.emplace_back(Scope());
-    scopes_.back().in_foreach = true;
-    for_each.named_expression_->MapTo(
-        CreateSymbol(name, true, Symbol::Type::ANY, for_each.named_expression_->token_position_));
-    return true;
-  }
-
-  bool PostVisit(Foreach & /*unused*/) override {
-    scopes_.pop_back();
-    return true;
-  }
-
-  // Expressions
-  ReturnType Visit(Identifier &ident) override {
-    auto &scope = scopes_.back();
-    if (scope.in_skip || scope.in_limit) {
-      throw SemanticException("Variables are not allowed in {}.", scope.in_skip ? "SKIP" : "LIMIT");
-    }
-    Symbol symbol;
-    if (scope.in_pattern && !(scope.in_node_atom || scope.visiting_edge)) {
-      // If we are in the pattern, and outside of a node or an edge, the
-      // identifier is the pattern name.
-      symbol = GetOrCreateSymbolLocalScope(ident.name_, ident.user_declared_, Symbol::Type::PATH);
-    } else if (scope.in_pattern && scope.in_pattern_atom_identifier) {
-      //  Patterns used to create nodes and edges cannot redeclare already
-      //  established bindings. Declaration only happens in single node
-      //  patterns and in edge patterns. OpenCypher example,
-      //  `MATCH (n) CREATE (n)` should throw an error that `n` is already
-      //  declared. While `MATCH (n) CREATE (n) -[:R]-> (n)` is allowed,
-      //  since `n` now references the bound node instead of declaring it.
-      if ((scope.in_create_node || scope.in_create_edge) && HasSymbolLocalScope(ident.name_)) {
-        throw RedeclareVariableError(ident.name_);
-      }
-      auto type = Symbol::Type::VERTEX;
-      if (scope.visiting_edge) {
-        // Edge referencing is not allowed (like in Neo4j):
-        // `MATCH (n) - [r] -> (n) - [r] -> (n) RETURN r` is not allowed.
-        if (HasSymbolLocalScope(ident.name_)) {
-          throw RedeclareVariableError(ident.name_);
-        }
-        type = scope.visiting_edge->IsVariable() ? Symbol::Type::EDGE_LIST : Symbol::Type::EDGE;
-      }
-      symbol = GetOrCreateSymbolLocalScope(ident.name_, ident.user_declared_, type);
-    } else if (scope.in_pattern && !scope.in_pattern_atom_identifier && scope.in_match) {
-      if (scope.in_edge_range && scope.visiting_edge->identifier_->name_ == ident.name_) {
-        // Prevent variable path bounds to reference the identifier which is bound
-        // by the variable path itself.
-        throw UnboundVariableError(ident.name_);
-      }
-      // Variables in property maps or bounds of variable length path during MATCH
-      // can reference symbols bound later in the same MATCH. We collect them
-      // here, so that they can be checked after visiting Match.
-      scope.identifiers_in_match.emplace_back(&ident);
-    } else {
-      // Everything else references a bound symbol.
-      if (!HasSymbol(ident.name_) && !ConsumePredefinedIdentifier(ident.name_)) throw UnboundVariableError(ident.name_);
-      symbol = GetOrCreateSymbol(ident.name_, ident.user_declared_, Symbol::Type::ANY);
-    }
-    ident.MapTo(symbol);
-    return true;
-  }
-
-  ReturnType Visit(PrimitiveLiteral & /*unused*/) override { return true; }
-
-  ReturnType Visit(ParameterLookup & /*unused*/) override { return true; }
-
-  bool PreVisit(Aggregation &aggr) override {
-    auto &scope = scopes_.back();
-    // Check if the aggregation can be used in this context. This check should
-    // probably move to a separate phase, which checks if the query is well
-    // formed.
-    if ((!scope.in_return && !scope.in_with) || scope.in_order_by || scope.in_skip || scope.in_limit ||
-        scope.in_where) {
-      throw SemanticException("Aggregation functions are only allowed in WITH and RETURN.");
-    }
-    if (scope.in_aggregation) {
-      throw SemanticException(
-          "Using aggregation functions inside aggregation functions is not "
-          "allowed.");
-    }
-    if (scope.num_if_operators) {
-      // Neo allows aggregations here and produces very interesting behaviors.
-      // To simplify implementation at this moment we decided to completely
-      // disallow aggregations inside of the CASE.
-      // However, in some cases aggregation makes perfect sense, for example:
-      //    CASE count(n) WHEN 10 THEN "YES" ELSE "NO" END.
-      // TODO: Rethink of allowing aggregations in some parts of the CASE
-      // construct.
-      throw SemanticException("Using aggregation functions inside of CASE is not allowed.");
-    }
-    // Create a virtual symbol for aggregation result.
-    // Currently, we only have aggregation operators which return numbers.
-    auto aggr_name = Aggregation::OpToString(aggr.op_) + std::to_string(aggr.symbol_pos_);
-    aggr.MapTo(CreateSymbol(aggr_name, false, Symbol::Type::NUMBER));
-    scope.in_aggregation = true;
-    scope.has_aggregation = true;
-    return true;
-  }
-
-  bool PostVisit(Aggregation & /*unused*/) override {
-    scopes_.back().in_aggregation = false;
-    return true;
-  }
-
-  bool PreVisit(IfOperator & /*unused*/) override {
-    ++scopes_.back().num_if_operators;
-    return true;
-  }
-
-  bool PostVisit(IfOperator & /*unused*/) override {
-    --scopes_.back().num_if_operators;
-    return true;
-  }
-
-  bool PreVisit(All &all) override {
-    all.list_expression_->Accept(*this);
-    VisitWithIdentifiers(all.where_->expression_, {all.identifier_});
-    return false;
-  }
-
-  bool PreVisit(Single &single) override {
-    single.list_expression_->Accept(*this);
-    VisitWithIdentifiers(single.where_->expression_, {single.identifier_});
-    return false;
-  }
-
-  bool PreVisit(Any &any) override {
-    any.list_expression_->Accept(*this);
-    VisitWithIdentifiers(any.where_->expression_, {any.identifier_});
-    return false;
-  }
-
-  bool PreVisit(None &none) override {
-    none.list_expression_->Accept(*this);
-    VisitWithIdentifiers(none.where_->expression_, {none.identifier_});
-    return false;
-  }
-
-  bool PreVisit(Reduce &reduce) override {
-    reduce.initializer_->Accept(*this);
-    reduce.list_->Accept(*this);
-    VisitWithIdentifiers(reduce.expression_, {reduce.accumulator_, reduce.identifier_});
-    return false;
-  }
-
-  bool PreVisit(Extract &extract) override {
-    extract.list_->Accept(*this);
-    VisitWithIdentifiers(extract.expression_, {extract.identifier_});
-    return false;
-  }
-
-  // Pattern and its subparts.
-  bool PreVisit(Pattern &pattern) override {
-    auto &scope = scopes_.back();
-    scope.in_pattern = true;
-    if ((scope.in_create || scope.in_merge) && pattern.atoms_.size() == 1U) {
-      MG_ASSERT(utils::IsSubtype(*pattern.atoms_[0], NodeAtom::kType), "Expected a single NodeAtom in Pattern");
-      scope.in_create_node = true;
-    }
-    return true;
-  }
-
-  bool PostVisit(Pattern & /*unused*/) override {
-    auto &scope = scopes_.back();
-    scope.in_pattern = false;
-    scope.in_create_node = false;
-    return true;
-  }
-
-  bool PreVisit(NodeAtom &node_atom) override {
-    auto &scope = scopes_.back();
-    auto check_node_semantic = [&node_atom, &scope, this](const bool props_or_labels) {
-      const auto &node_name = node_atom.identifier_->name_;
-      if ((scope.in_create || scope.in_merge) && props_or_labels && HasSymbolLocalScope(node_name)) {
-        throw SemanticException("Cannot create node '" + node_name +
-                                "' with labels or properties, because it is already declared.");
-      }
-      scope.in_pattern_atom_identifier = true;
-      node_atom.identifier_->Accept(*this);
-      scope.in_pattern_atom_identifier = false;
-    };
-
-    scope.in_node_atom = true;
-    if (auto *properties = std::get_if<std::unordered_map<PropertyIx, Expression *>>(&node_atom.properties_)) {
-      bool props_or_labels = !properties->empty() || !node_atom.labels_.empty();
-
-      check_node_semantic(props_or_labels);
-      for (auto kv : *properties) {
-        kv.second->Accept(*this);
-      }
-
-      return false;
-    }
-    auto &properties_parameter = std::get<ParameterLookup *>(node_atom.properties_);
-    bool props_or_labels = !properties_parameter || !node_atom.labels_.empty();
-
-    check_node_semantic(props_or_labels);
-    properties_parameter->Accept(*this);
-    return false;
-  }
-
-  bool PostVisit(NodeAtom & /*unused*/) override {
-    scopes_.back().in_node_atom = false;
-    return true;
-  }
-
-  bool PreVisit(EdgeAtom &edge_atom) override {
-    auto &scope = scopes_.back();
-    scope.visiting_edge = &edge_atom;
-    if (scope.in_create || scope.in_merge) {
-      scope.in_create_edge = true;
-      if (edge_atom.edge_types_.size() != 1U) {
-        throw SemanticException(
-            "A single relationship type must be specified "
-            "when creating an edge.");
-      }
-      if (scope.in_create &&  // Merge allows bidirectionality
-          edge_atom.direction_ == EdgeAtom::Direction::BOTH) {
-        throw SemanticException(
-            "Bidirectional relationship are not supported "
-            "when creating an edge");
-      }
-      if (edge_atom.IsVariable()) {
-        throw SemanticException(
-            "Variable length relationships are not supported when creating an "
-            "edge.");
-      }
-    }
-    if (auto *properties = std::get_if<std::unordered_map<PropertyIx, Expression *>>(&edge_atom.properties_)) {
-      for (auto kv : *properties) {
-        kv.second->Accept(*this);
-      }
-    } else {
-      std::get<ParameterLookup *>(edge_atom.properties_)->Accept(*this);
-    }
-    if (edge_atom.IsVariable()) {
-      scope.in_edge_range = true;
-      if (edge_atom.lower_bound_) {
-        edge_atom.lower_bound_->Accept(*this);
-      }
-      if (edge_atom.upper_bound_) {
-        edge_atom.upper_bound_->Accept(*this);
-      }
-      scope.in_edge_range = false;
-      scope.in_pattern = false;
-      if (edge_atom.filter_lambda_.expression) {
-        VisitWithIdentifiers(edge_atom.filter_lambda_.expression,
-                             {edge_atom.filter_lambda_.inner_edge, edge_atom.filter_lambda_.inner_node});
-      } else {
-        // Create inner symbols, but don't bind them in scope, since they are to
-        // be used in the missing filter expression.
-        auto *inner_edge = edge_atom.filter_lambda_.inner_edge;
-        inner_edge->MapTo(
-            symbol_table_->CreateSymbol(inner_edge->name_, inner_edge->user_declared_, Symbol::Type::EDGE));
-        auto *inner_node = edge_atom.filter_lambda_.inner_node;
-        inner_node->MapTo(
-            symbol_table_->CreateSymbol(inner_node->name_, inner_node->user_declared_, Symbol::Type::VERTEX));
-      }
-      if (edge_atom.weight_lambda_.expression) {
-        VisitWithIdentifiers(edge_atom.weight_lambda_.expression,
-                             {edge_atom.weight_lambda_.inner_edge, edge_atom.weight_lambda_.inner_node});
-      }
-      scope.in_pattern = true;
-    }
-    scope.in_pattern_atom_identifier = true;
-    edge_atom.identifier_->Accept(*this);
-    scope.in_pattern_atom_identifier = false;
-    if (edge_atom.total_weight_) {
-      if (HasSymbolLocalScope(edge_atom.total_weight_->name_)) {
-        throw RedeclareVariableError(edge_atom.total_weight_->name_);
-      }
-      edge_atom.total_weight_->MapTo(GetOrCreateSymbolLocalScope(
-          edge_atom.total_weight_->name_, edge_atom.total_weight_->user_declared_, Symbol::Type::NUMBER));
-    }
-    return false;
-  }
-
-  bool PostVisit(EdgeAtom & /*unused*/) override {
-    auto &scope = scopes_.back();
-    scope.visiting_edge = nullptr;
-    scope.in_create_edge = false;
-    return true;
-  }
-
- private:
-  // Scope stores the state of where we are when visiting the AST and a map of
-  // names to symbols.
-  struct Scope {
-    bool in_pattern{false};
-    bool in_merge{false};
-    bool in_create{false};
-    // in_create_node is true if we are creating or merging *only* a node.
-    // Therefore, it is *not* equivalent to (in_create || in_merge) &&
-    // in_node_atom.
-    bool in_create_node{false};
-    // True if creating an edge;
-    // shortcut for (in_create || in_merge) && visiting_edge.
-    bool in_create_edge{false};
-    bool in_node_atom{false};
-    EdgeAtom *visiting_edge{nullptr};
-    bool in_aggregation{false};
-    bool in_return{false};
-    bool in_with{false};
-    bool in_skip{false};
-    bool in_limit{false};
-    bool in_order_by{false};
-    bool in_where{false};
-    bool in_match{false};
-    bool in_foreach{false};
-    // True when visiting a pattern atom (node or edge) identifier, which can be
-    // reused or created in the pattern itself.
-    bool in_pattern_atom_identifier{false};
-    // True when visiting range bounds of a variable path.
-    bool in_edge_range{false};
-    // True if the return/with contains an aggregation in any named expression.
-    bool has_aggregation{false};
-    // Map from variable names to symbols.
-    std::map<std::string, Symbol> symbols;
-    // Identifiers found in property maps of patterns or as variable length path
-    // bounds in a single Match clause. They need to be checked after visiting
-    // Match. Identifiers created by naming vertices, edges and paths are *not*
-    // stored in here.
-    std::vector<Identifier *> identifiers_in_match;
-    // Number of nested IfOperators.
-    int num_if_operators{0};
-  };
-
-  inline static std::optional<Symbol> FindSymbolInScope(const std::string &name, const Scope &scope,
-                                                        Symbol::Type type) {
-    if (auto it = scope.symbols.find(name); it != scope.symbols.end()) {
-      const auto &symbol = it->second;
-      // Unless we have `ANY` type, check that types match.
-      if (type != Symbol::Type::ANY && symbol.type() != Symbol::Type::ANY && type != symbol.type()) {
-        throw TypeMismatchError(name, Symbol::TypeToString(symbol.type()), Symbol::TypeToString(type));
-      }
-      return symbol;
-    }
-    return std::nullopt;
-  }
-
-  bool HasSymbol(const std::string &name) const {
-    return std::ranges::any_of(scopes_, [&name](const auto &scope) { return scope.symbols.contains(name); });
-  }
-
-  bool HasSymbolLocalScope(const std::string &name) const { return scopes_.back().symbols.contains(name); }
-
-  // @return true if it added a predefined identifier with that name
-  bool ConsumePredefinedIdentifier(const std::string &name) {
-    auto it = predefined_identifiers_.find(name);
-
-    if (it == predefined_identifiers_.end()) {
-      return false;
-    }
-
-    // we can only use the predefined identifier in a single scope so we remove it after creating
-    // a symbol for it
-    auto &identifier = it->second;
-    MG_ASSERT(!identifier->user_declared_, "Predefined symbols cannot be user declared!");
-    identifier->MapTo(CreateSymbol(identifier->name_, identifier->user_declared_));
-    predefined_identifiers_.erase(it);
-    return true;
-  }
-
-  // Returns a freshly generated symbol. Previous mapping of the same name to a
-  // different symbol is replaced with the new one.
-  Symbol CreateSymbol(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY,
-                      int token_position = -1) {
-    auto symbol = symbol_table_->CreateSymbol(name, user_declared, type, token_position);
-    scopes_.back().symbols[name] = symbol;
-    return symbol;
-  }
-
-  Symbol GetOrCreateSymbol(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY) {
-    // NOLINTNEXTLINE
-    for (auto scope = scopes_.rbegin(); scope != scopes_.rend(); ++scope) {
-      if (auto maybe_symbol = FindSymbolInScope(name, *scope, type); maybe_symbol) {
-        return *maybe_symbol;
-      }
-    }
-    return CreateSymbol(name, user_declared, type);
-  }
-
-  // Returns the symbol by name. If the mapping already exists, checks if the
-  // types match. Otherwise, returns a new symbol.
-  Symbol GetOrCreateSymbolLocalScope(const std::string &name, bool user_declared,
-                                     Symbol::Type type = Symbol::Type::ANY) {
-    auto &scope = scopes_.back();
-    if (auto maybe_symbol = FindSymbolInScope(name, scope, type); maybe_symbol) {
-      return *maybe_symbol;
-    }
-    return CreateSymbol(name, user_declared, type);
-  }
-
-  void VisitReturnBody(ReturnBody &body, Where *where = nullptr) {
-    auto &scope = scopes_.back();
-    for (auto &expr : body.named_expressions) {
-      expr->Accept(*this);
-    }
-    std::vector<Symbol> user_symbols;
-    if (body.all_identifiers) {
-      // Carry over user symbols because '*' appeared.
-      for (const auto &sym_pair : scope.symbols) {
-        if (!sym_pair.second.user_declared()) {
-          continue;
-        }
-        user_symbols.emplace_back(sym_pair.second);
-      }
-      if (user_symbols.empty()) {
-        throw SemanticException("There are no variables in scope to use for '*'.");
-      }
-    }
-    // WITH/RETURN clause removes declarations of all the previous variables and
-    // declares only those established through named expressions. New declarations
-    // must not be visible inside named expressions themselves.
-    bool removed_old_names = false;
-    if ((!where && body.order_by.empty()) || scope.has_aggregation) {
-      // WHERE and ORDER BY need to see both the old and new symbols, unless we
-      // have an aggregation. Therefore, we can clear the symbols immediately if
-      // there is neither ORDER BY nor WHERE, or we have an aggregation.
-      scope.symbols.clear();
-      removed_old_names = true;
-    }
-    // Create symbols for named expressions.
-    std::unordered_set<std::string> new_names;
-    for (const auto &user_sym : user_symbols) {
-      new_names.insert(user_sym.name());
-      scope.symbols[user_sym.name()] = user_sym;
-    }
-    for (auto &named_expr : body.named_expressions) {
-      const auto &name = named_expr->name_;
-      if (!new_names.insert(name).second) {
-        throw SemanticException("Multiple results with the same name '{}' are not allowed.", name);
-      }
-      // An improvement would be to infer the type of the expression, so that the
-      // new symbol would have a more specific type.
-      named_expr->MapTo(CreateSymbol(name, true, Symbol::Type::ANY, named_expr->token_position_));
-    }
-    scope.in_order_by = true;
-    for (const auto &order_pair : body.order_by) {
-      order_pair.expression->Accept(*this);
-    }
-    scope.in_order_by = false;
-    if (body.skip) {
-      scope.in_skip = true;
-      body.skip->Accept(*this);
-      scope.in_skip = false;
-    }
-    if (body.limit) {
-      scope.in_limit = true;
-      body.limit->Accept(*this);
-      scope.in_limit = false;
-    }
-    if (where) where->Accept(*this);
-    if (!removed_old_names) {
-      // We have an ORDER BY or WHERE, but no aggregation, which means we didn't
-      // clear the old symbols, so do it now. We cannot just call clear, because
-      // we've added new symbols.
-      for (auto sym_it = scope.symbols.begin(); sym_it != scope.symbols.end();) {
-        if (new_names.find(sym_it->first) == new_names.end()) {
-          sym_it = scope.symbols.erase(sym_it);
-        } else {
-          sym_it++;
-        }
-      }
-    }
-    scopes_.back().has_aggregation = false;
-  }
-
-  void VisitWithIdentifiers(Expression *expr, const std::vector<Identifier *> &identifiers) {
-    auto &scope = scopes_.back();
-    std::vector<std::pair<std::optional<Symbol>, Identifier *>> prev_symbols;
-    // Collect previous symbols if they exist.
-    for (const auto &identifier : identifiers) {
-      std::optional<Symbol> prev_symbol;
-      auto prev_symbol_it = scope.symbols.find(identifier->name_);
-      if (prev_symbol_it != scope.symbols.end()) {
-        prev_symbol = prev_symbol_it->second;
-      }
-      identifier->MapTo(CreateSymbol(identifier->name_, identifier->user_declared_));
-      prev_symbols.emplace_back(prev_symbol, identifier);
-    }
-    // Visit the expression with the new symbols bound.
-    expr->Accept(*this);
-    // Restore back to previous symbols.
-    for (const auto &prev : prev_symbols) {
-      const auto &prev_symbol = prev.first;
-      const auto &identifier = prev.second;
-      if (prev_symbol) {
-        scope.symbols[identifier->name_] = *prev_symbol;
-      } else {
-        scope.symbols.erase(identifier->name_);
-      }
-    }
-  }
-
-  SymbolTable *symbol_table_;
-
-  // Identifiers which are injected from outside the query. Each identifier
-  // is mapped by its name.
-  std::unordered_map<std::string, Identifier *> predefined_identifiers_;
-  std::vector<Scope> scopes_;
-  std::unordered_set<std::string> prev_return_names_;
-  std::unordered_set<std::string> curr_return_names_;
-};
-
-inline SymbolTable MakeSymbolTable(CypherQuery *query, const std::vector<Identifier *> &predefined_identifiers = {}) {
-  SymbolTable symbol_table;
-  SymbolGenerator symbol_generator(&symbol_table, predefined_identifiers);
-  query->single_query_->Accept(symbol_generator);
-  for (auto *cypher_union : query->cypher_unions_) {
-    cypher_union->Accept(symbol_generator);
-  }
-  return symbol_table;
-}
-
-}  // namespace memgraph::expr
--- a/src/expr/semantic/symbol_table.hpp
+++ b/src/expr/semantic/symbol_table.hpp
@@ -1,64 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#pragma once
-
-#include <map>
-#include <string>
-
-#include "expr/ast.hpp"
-#include "expr/semantic/symbol.hpp"
-#include "utils/logging.hpp"
-
-namespace memgraph::expr {
-
-class SymbolTable final {
- public:
-  SymbolTable() {}
-  const Symbol &CreateSymbol(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY,
-                             int32_t token_position = -1) {
-    MG_ASSERT(table_.size() <= std::numeric_limits<int32_t>::max(),
-              "SymbolTable size doesn't fit into 32-bit integer!");
-    auto got = table_.emplace(position_, Symbol(name, position_, user_declared, type, token_position));
-    MG_ASSERT(got.second, "Duplicate symbol ID!");
-    position_++;
-    return got.first->second;
-  }
-
-  // TODO(buda): This is the same logic as in the cypher_main_visitor. During
-  // parsing phase symbol table doesn't exist. Figure out a better solution.
-  const Symbol &CreateAnonymousSymbol(Symbol::Type type = Symbol::Type::ANY) {
-    int id = 1;
-    while (true) {
-      static const std::string &kAnonPrefix = "anon";
-      std::string name_candidate = kAnonPrefix + std::to_string(id++);
-      if (std::find_if(std::begin(table_), std::end(table_), [&name_candidate](const auto &item) -> bool {
-            return item.second.name_ == name_candidate;
-          }) == std::end(table_)) {
-        return CreateSymbol(name_candidate, false, type);
-      }
-    }
-  }
-
-  const Symbol &at(const Identifier &ident) const { return table_.at(ident.symbol_pos_); }
-  const Symbol &at(const NamedExpression &nexpr) const { return table_.at(nexpr.symbol_pos_); }
-  const Symbol &at(const Aggregation &aggr) const { return table_.at(aggr.symbol_pos_); }
-
-  // TODO: Remove these since members are public
-  int32_t max_position() const { return static_cast<int32_t>(table_.size()); }
-
-  const auto &table() const { return table_; }
-
-  int32_t position_{0};
-  std::map<int32_t, Symbol> table_;
-};
-
-}  // namespace memgraph::expr
--- a/src/expr/typed_value.hpp
+++ b/src/expr/typed_value.hpp
--- a/src/glue/v2/auth.cpp
+++ b/src/glue/v2/auth.cpp
@@ -1,64 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "glue/v2/auth.hpp"
-
-namespace memgraph::glue::v2 {
-
-auth::Permission PrivilegeToPermission(query::v2::AuthQuery::Privilege privilege) {
-  switch (privilege) {
-    case query::v2::AuthQuery::Privilege::MATCH:
-      return auth::Permission::MATCH;
-    case query::v2::AuthQuery::Privilege::CREATE:
-      return auth::Permission::CREATE;
-    case query::v2::AuthQuery::Privilege::MERGE:
-      return auth::Permission::MERGE;
-    case query::v2::AuthQuery::Privilege::DELETE:
-      return auth::Permission::DELETE;
-    case query::v2::AuthQuery::Privilege::SET:
-      return auth::Permission::SET;
-    case query::v2::AuthQuery::Privilege::REMOVE:
-      return auth::Permission::REMOVE;
-    case query::v2::AuthQuery::Privilege::INDEX:
-      return auth::Permission::INDEX;
-    case query::v2::AuthQuery::Privilege::STATS:
-      return auth::Permission::STATS;
-    case query::v2::AuthQuery::Privilege::CONSTRAINT:
-      return auth::Permission::CONSTRAINT;
-    case query::v2::AuthQuery::Privilege::DUMP:
-      return auth::Permission::DUMP;
-    case query::v2::AuthQuery::Privilege::REPLICATION:
-      return auth::Permission::REPLICATION;
-    case query::v2::AuthQuery::Privilege::DURABILITY:
-      return auth::Permission::DURABILITY;
-    case query::v2::AuthQuery::Privilege::READ_FILE:
-      return auth::Permission::READ_FILE;
-    case query::v2::AuthQuery::Privilege::FREE_MEMORY:
-      return auth::Permission::FREE_MEMORY;
-    case query::v2::AuthQuery::Privilege::TRIGGER:
-      return auth::Permission::TRIGGER;
-    case query::v2::AuthQuery::Privilege::CONFIG:
-      return auth::Permission::CONFIG;
-    case query::v2::AuthQuery::Privilege::AUTH:
-      return auth::Permission::AUTH;
-    case query::v2::AuthQuery::Privilege::STREAM:
-      return auth::Permission::STREAM;
-    case query::v2::AuthQuery::Privilege::MODULE_READ:
-      return auth::Permission::MODULE_READ;
-    case query::v2::AuthQuery::Privilege::MODULE_WRITE:
-      return auth::Permission::MODULE_WRITE;
-    case query::v2::AuthQuery::Privilege::WEBSOCKET:
-      return auth::Permission::WEBSOCKET;
-    case query::v2::AuthQuery::Privilege::SCHEMA:
-      return auth::Permission::SCHEMA;
-  }
-}
-}  // namespace memgraph::glue::v2
--- a/src/glue/v2/auth.hpp
+++ b/src/glue/v2/auth.hpp
@@ -1,23 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "auth/models.hpp"
-#include "query/v2/frontend/ast/ast.hpp"
-
-namespace memgraph::glue::v2 {
-
-/**
- * This function converts query::AuthQuery::Privilege to its corresponding
- * auth::Permission.
- */
-auth::Permission PrivilegeToPermission(query::v2::AuthQuery::Privilege privilege);
-
-}  // namespace memgraph::glue::v2
--- a/src/glue/v2/communication.cpp
+++ b/src/glue/v2/communication.cpp
@@ -1,277 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "glue/v2/communication.hpp"
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include "storage/v3/edge_accessor.hpp"
-#include "storage/v3/shard.hpp"
-#include "storage/v3/vertex_accessor.hpp"
-#include "utils/temporal.hpp"
-
-using memgraph::communication::bolt::Value;
-
-namespace memgraph::glue::v2 {
-
-query::v2::TypedValue ToTypedValue(const Value &value) {
-  switch (value.type()) {
-    case Value::Type::Null:
-      return {};
-    case Value::Type::Bool:
-      return query::v2::TypedValue(value.ValueBool());
-    case Value::Type::Int:
-      return query::v2::TypedValue(value.ValueInt());
-    case Value::Type::Double:
-      return query::v2::TypedValue(value.ValueDouble());
-    case Value::Type::String:
-      return query::v2::TypedValue(value.ValueString());
-    case Value::Type::List: {
-      std::vector<query::v2::TypedValue> list;
-      list.reserve(value.ValueList().size());
-      for (const auto &v : value.ValueList()) list.push_back(ToTypedValue(v));
-      return query::v2::TypedValue(std::move(list));
-    }
-    case Value::Type::Map: {
-      std::map<std::string, query::v2::TypedValue> map;
-      for (const auto &kv : value.ValueMap()) map.emplace(kv.first, ToTypedValue(kv.second));
-      return query::v2::TypedValue(std::move(map));
-    }
-    case Value::Type::Vertex:
-    case Value::Type::Edge:
-    case Value::Type::UnboundedEdge:
-    case Value::Type::Path:
-      throw communication::bolt::ValueException("Unsupported conversion from Value to TypedValue");
-    case Value::Type::Date:
-      return query::v2::TypedValue(value.ValueDate());
-    case Value::Type::LocalTime:
-      return query::v2::TypedValue(value.ValueLocalTime());
-    case Value::Type::LocalDateTime:
-      return query::v2::TypedValue(value.ValueLocalDateTime());
-    case Value::Type::Duration:
-      return query::v2::TypedValue(value.ValueDuration());
-  }
-}
-
-storage::v3::Result<communication::bolt::Vertex> ToBoltVertex(const query::v2::VertexAccessor &vertex,
-                                                              const storage::v3::Shard &db, storage::v3::View view) {
-  return ToBoltVertex(vertex.impl_, db, view);
-}
-
-storage::v3::Result<communication::bolt::Edge> ToBoltEdge(const query::v2::EdgeAccessor &edge,
-                                                          const storage::v3::Shard &db, storage::v3::View view) {
-  return ToBoltEdge(edge.impl_, db, view);
-}
-
-storage::v3::Result<Value> ToBoltValue(const query::v2::TypedValue &value, const storage::v3::Shard &db,
-                                       storage::v3::View view) {
-  switch (value.type()) {
-    case query::v2::TypedValue::Type::Null:
-      return Value();
-    case query::v2::TypedValue::Type::Bool:
-      return Value(value.ValueBool());
-    case query::v2::TypedValue::Type::Int:
-      return Value(value.ValueInt());
-    case query::v2::TypedValue::Type::Double:
-      return Value(value.ValueDouble());
-    case query::v2::TypedValue::Type::String:
-      return Value(std::string(value.ValueString()));
-    case query::v2::TypedValue::Type::List: {
-      std::vector<Value> values;
-      values.reserve(value.ValueList().size());
-      for (const auto &v : value.ValueList()) {
-        auto maybe_value = ToBoltValue(v, db, view);
-        if (maybe_value.HasError()) return maybe_value.GetError();
-        values.emplace_back(std::move(*maybe_value));
-      }
-      return Value(std::move(values));
-    }
-    case query::v2::TypedValue::Type::Map: {
-      std::map<std::string, Value> map;
-      for (const auto &kv : value.ValueMap()) {
-        auto maybe_value = ToBoltValue(kv.second, db, view);
-        if (maybe_value.HasError()) return maybe_value.GetError();
-        map.emplace(kv.first, std::move(*maybe_value));
-      }
-      return Value(std::move(map));
-    }
-    case query::v2::TypedValue::Type::Vertex: {
-      auto maybe_vertex = ToBoltVertex(value.ValueVertex(), db, view);
-      if (maybe_vertex.HasError()) return maybe_vertex.GetError();
-      return Value(std::move(*maybe_vertex));
-    }
-    case query::v2::TypedValue::Type::Edge: {
-      auto maybe_edge = ToBoltEdge(value.ValueEdge(), db, view);
-      if (maybe_edge.HasError()) return maybe_edge.GetError();
-      return Value(std::move(*maybe_edge));
-    }
-    case query::v2::TypedValue::Type::Path: {
-      auto maybe_path = ToBoltPath(value.ValuePath(), db, view);
-      if (maybe_path.HasError()) return maybe_path.GetError();
-      return Value(std::move(*maybe_path));
-    }
-    case query::v2::TypedValue::Type::Date:
-      return Value(value.ValueDate());
-    case query::v2::TypedValue::Type::LocalTime:
-      return Value(value.ValueLocalTime());
-    case query::v2::TypedValue::Type::LocalDateTime:
-      return Value(value.ValueLocalDateTime());
-    case query::v2::TypedValue::Type::Duration:
-      return Value(value.ValueDuration());
-  }
-}
-
-storage::v3::Result<communication::bolt::Vertex> ToBoltVertex(const storage::v3::VertexAccessor &vertex,
-                                                              const storage::v3::Shard &db, storage::v3::View view) {
-  // TODO(jbajic) Fix bolt communication
-  auto id = communication::bolt::Id::FromUint(0);
-  auto maybe_labels = vertex.Labels(view);
-  if (maybe_labels.HasError()) return maybe_labels.GetError();
-  std::vector<std::string> labels;
-  labels.reserve(maybe_labels->size());
-  for (const auto &label : *maybe_labels) {
-    labels.push_back(db.LabelToName(label));
-  }
-  auto maybe_properties = vertex.Properties(view);
-  if (maybe_properties.HasError()) return maybe_properties.GetError();
-  std::map<std::string, Value> properties;
-  for (const auto &prop : *maybe_properties) {
-    properties[db.PropertyToName(prop.first)] = ToBoltValue(prop.second);
-  }
-  return communication::bolt::Vertex{id, labels, properties};
-}
-
-storage::v3::Result<communication::bolt::Edge> ToBoltEdge(const storage::v3::EdgeAccessor &edge,
-                                                          const storage::v3::Shard &db, storage::v3::View view) {
-  // TODO(jbajic) Fix bolt communication
-  auto id = communication::bolt::Id::FromUint(0);
-  auto from = communication::bolt::Id::FromUint(0);
-  auto to = communication::bolt::Id::FromUint(0);
-  const auto &type = db.EdgeTypeToName(edge.EdgeType());
-  auto maybe_properties = edge.Properties(view);
-  if (maybe_properties.HasError()) return maybe_properties.GetError();
-  std::map<std::string, Value> properties;
-  for (const auto &prop : *maybe_properties) {
-    properties[db.PropertyToName(prop.first)] = ToBoltValue(prop.second);
-  }
-  return communication::bolt::Edge{id, from, to, type, properties};
-}
-
-storage::v3::Result<communication::bolt::Path> ToBoltPath(const query::v2::Path &path, const storage::v3::Shard &db,
-                                                          storage::v3::View view) {
-  std::vector<communication::bolt::Vertex> vertices;
-  vertices.reserve(path.vertices().size());
-  for (const auto &v : path.vertices()) {
-    auto maybe_vertex = ToBoltVertex(v, db, view);
-    if (maybe_vertex.HasError()) return maybe_vertex.GetError();
-    vertices.emplace_back(std::move(*maybe_vertex));
-  }
-  std::vector<communication::bolt::Edge> edges;
-  edges.reserve(path.edges().size());
-  for (const auto &e : path.edges()) {
-    auto maybe_edge = ToBoltEdge(e, db, view);
-    if (maybe_edge.HasError()) return maybe_edge.GetError();
-    edges.emplace_back(std::move(*maybe_edge));
-  }
-  return communication::bolt::Path(vertices, edges);
-}
-
-storage::v3::PropertyValue ToPropertyValue(const Value &value) {
-  switch (value.type()) {
-    case Value::Type::Null:
-      return {};
-    case Value::Type::Bool:
-      return storage::v3::PropertyValue(value.ValueBool());
-    case Value::Type::Int:
-      return storage::v3::PropertyValue(value.ValueInt());
-    case Value::Type::Double:
-      return storage::v3::PropertyValue(value.ValueDouble());
-    case Value::Type::String:
-      return storage::v3::PropertyValue(value.ValueString());
-    case Value::Type::List: {
-      std::vector<storage::v3::PropertyValue> vec;
-      vec.reserve(value.ValueList().size());
-      for (const auto &value : value.ValueList()) vec.emplace_back(ToPropertyValue(value));
-      return storage::v3::PropertyValue(std::move(vec));
-    }
-    case Value::Type::Map: {
-      std::map<std::string, storage::v3::PropertyValue> map;
-      for (const auto &kv : value.ValueMap()) map.emplace(kv.first, ToPropertyValue(kv.second));
-      return storage::v3::PropertyValue(std::move(map));
-    }
-    case Value::Type::Vertex:
-    case Value::Type::Edge:
-    case Value::Type::UnboundedEdge:
-    case Value::Type::Path:
-      throw communication::bolt::ValueException("Unsupported conversion from Value to PropertyValue");
-    case Value::Type::Date:
-      return storage::v3::PropertyValue(
-          storage::v3::TemporalData(storage::v3::TemporalType::Date, value.ValueDate().MicrosecondsSinceEpoch()));
-    case Value::Type::LocalTime:
-      return storage::v3::PropertyValue(storage::v3::TemporalData(storage::v3::TemporalType::LocalTime,
-                                                                  value.ValueLocalTime().MicrosecondsSinceEpoch()));
-    case Value::Type::LocalDateTime:
-      return storage::v3::PropertyValue(storage::v3::TemporalData(storage::v3::TemporalType::LocalDateTime,
-                                                                  value.ValueLocalDateTime().MicrosecondsSinceEpoch()));
-    case Value::Type::Duration:
-      return storage::v3::PropertyValue(
-          storage::v3::TemporalData(storage::v3::TemporalType::Duration, value.ValueDuration().microseconds));
-  }
-}
-
-Value ToBoltValue(const storage::v3::PropertyValue &value) {
-  switch (value.type()) {
-    case storage::v3::PropertyValue::Type::Null:
-      return {};
-    case storage::v3::PropertyValue::Type::Bool:
-      return {value.ValueBool()};
-    case storage::v3::PropertyValue::Type::Int:
-      return {value.ValueInt()};
-      break;
-    case storage::v3::PropertyValue::Type::Double:
-      return {value.ValueDouble()};
-    case storage::v3::PropertyValue::Type::String:
-      return {value.ValueString()};
-    case storage::v3::PropertyValue::Type::List: {
-      const auto &values = value.ValueList();
-      std::vector<Value> vec;
-      vec.reserve(values.size());
-      for (const auto &v : values) {
-        vec.push_back(ToBoltValue(v));
-      }
-      return {std::move(vec)};
-    }
-    case storage::v3::PropertyValue::Type::Map: {
-      const auto &map = value.ValueMap();
-      std::map<std::string, Value> dv_map;
-      for (const auto &kv : map) {
-        dv_map.emplace(kv.first, ToBoltValue(kv.second));
-      }
-      return {std::move(dv_map)};
-    }
-    case storage::v3::PropertyValue::Type::TemporalData:
-      const auto &type = value.ValueTemporalData();
-      switch (type.type) {
-        case storage::v3::TemporalType::Date:
-          return {utils::Date(type.microseconds)};
-        case storage::v3::TemporalType::LocalTime:
-          return {utils::LocalTime(type.microseconds)};
-        case storage::v3::TemporalType::LocalDateTime:
-          return {utils::LocalDateTime(type.microseconds)};
-        case storage::v3::TemporalType::Duration:
-          return {utils::Duration(type.microseconds)};
-      }
-  }
-}
-
-}  // namespace memgraph::glue::v2
--- a/src/glue/v2/communication.hpp
+++ b/src/glue/v2/communication.hpp
@@ -1,68 +0,0 @@
-// Copyright 2022 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-/// @file Conversion functions between Value and other memgraph types.
-#pragma once
-
-#include "communication/bolt/v1/value.hpp"
-#include "query/v2/bindings/typed_value.hpp"
-#include "storage/v3/property_value.hpp"
-#include "storage/v3/result.hpp"
-#include "storage/v3/view.hpp"
-
-namespace memgraph::storage::v3 {
-class EdgeAccessor;
-class Storage;
-class VertexAccessor;
-}  // namespace memgraph::storage::v3
-
-namespace memgraph::glue::v2 {
-
-/// @param storage::v3::VertexAccessor for converting to
-///        communication::bolt::Vertex.
-/// @param storage::v3::Shard for getting label and property names.
-/// @param storage::v3::View for deciding which vertex attributes are visible.
-///
-/// @throw std::bad_alloc
-storage::v3::Result<communication::bolt::Vertex> ToBoltVertex(const storage::v3::VertexAccessor &vertex,
-                                                              const storage::v3::Shard &db, storage::v3::View view);
-
-/// @param storage::v3::EdgeAccessor for converting to communication::bolt::Edge.
-/// @param storage::v3::Shard for getting edge type and property names.
-/// @param storage::v3::View for deciding which edge attributes are visible.
-///
-/// @throw std::bad_alloc
-storage::v3::Result<communication::bolt::Edge> ToBoltEdge(const storage::v3::EdgeAccessor &edge,
-                                                          const storage::v3::Shard &db, storage::v3::View view);
-
-/// @param query::v2::Path for converting to communication::bolt::Path.
-/// @param storage::v3::Shard for ToBoltVertex and ToBoltEdge.
-/// @param storage::v3::View for ToBoltVertex and ToBoltEdge.
-///
-/// @throw std::bad_alloc
-storage::v3::Result<communication::bolt::Path> ToBoltPath(const query::v2::Path &path, const storage::v3::Shard &db,
-                                                          storage::v3::View view);
-
-/// @param query::v2::TypedValue for converting to communication::bolt::Value.
-/// @param storage::v3::Shard for ToBoltVertex and ToBoltEdge.
-/// @param storage::v3::View for ToBoltVertex and ToBoltEdge.
-///
-/// @throw std::bad_alloc
-storage::v3::Result<communication::bolt::Value> ToBoltValue(const query::v2::TypedValue &value,
-                                                            const storage::v3::Shard &db, storage::v3::View view);
-
-query::v2::TypedValue ToTypedValue(const communication::bolt::Value &value);
-
-communication::bolt::Value ToBoltValue(const storage::v3::PropertyValue &value);
-
-storage::v3::PropertyValue ToPropertyValue(const communication::bolt::Value &value);
-
-}  // namespace memgraph::glue::v2
--- a/src/integrations/constants.hpp
+++ b/src/integrations/constants.hpp
@@ -17,7 +17,6 @@
 namespace memgraph::integrations {

 inline constexpr int64_t kDefaultCheckBatchLimit{1};
-inline constexpr int64_t kMinimumStartBatchLimit{1};
 inline constexpr std::chrono::milliseconds kDefaultCheckTimeout{30000};
 inline constexpr std::chrono::milliseconds kMinimumInterval{1};
 inline constexpr int64_t kMinimumSize{1};
--- a/src/integrations/kafka/consumer.cpp
+++ b/src/integrations/kafka/consumer.cpp
@@ -74,36 +74,6 @@ utils::BasicResult<std::string, std::vector<Message>> GetBatch(RdKafka::KafkaCon

  return std::move(batch);
 }
-
-void CheckAndDestroyLastAssignmentIfNeeded(RdKafka::KafkaConsumer &consumer, const ConsumerInfo &info,
-                                           std::vector<RdKafka::TopicPartition *> &last_assignment) {
-  if (!last_assignment.empty()) {
-    if (const auto err = consumer.assign(last_assignment); err != RdKafka::ERR_NO_ERROR) {
-      throw ConsumerStartFailedException(info.consumer_name,
-                                         fmt::format("Couldn't restore commited offsets: '{}'", RdKafka::err2str(err)));
-    }
-    RdKafka::TopicPartition::destroy(last_assignment);
-  }
-}
-
-void TryToConsumeBatch(RdKafka::KafkaConsumer &consumer, const ConsumerInfo &info,
-                       const ConsumerFunction &consumer_function, const std::vector<Message> &batch) {
-  consumer_function(batch);
-  std::vector<RdKafka::TopicPartition *> partitions;
-  utils::OnScopeExit clear_partitions([&]() { RdKafka::TopicPartition::destroy(partitions); });
-
-  if (const auto err = consumer.assignment(partitions); err != RdKafka::ERR_NO_ERROR) {
-    throw ConsumerCommitFailedException(
-        info.consumer_name, fmt::format("Couldn't get assignment to commit offsets: {}", RdKafka::err2str(err)));
-  }
-  if (const auto err = consumer.position(partitions); err != RdKafka::ERR_NO_ERROR) {
-    throw ConsumerCommitFailedException(info.consumer_name,
-                                        fmt::format("Couldn't get offsets from librdkafka {}", RdKafka::err2str(err)));
-  }
-  if (const auto err = consumer.commitSync(partitions); err != RdKafka::ERR_NO_ERROR) {
-    throw ConsumerCommitFailedException(info.consumer_name, RdKafka::err2str(err));
-  }
-}
 }  // namespace

 Message::Message(std::unique_ptr<RdKafka::Message> &&message) : message_{std::move(message)} {
@@ -251,21 +221,10 @@ void Consumer::Start() {
  StartConsuming();
 }

-void Consumer::StartWithLimit(const uint64_t limit_batches, std::optional<std::chrono::milliseconds> timeout) const {
-  if (is_running_) {
-    throw ConsumerRunningException(info_.consumer_name);
+void Consumer::StartIfStopped() {
+  if (!is_running_) {
+    StartConsuming();
  }
-  if (limit_batches < kMinimumStartBatchLimit) {
-    throw ConsumerStartFailedException(
-        info_.consumer_name, fmt::format("Batch limit has to be greater than or equal to {}", kMinimumStartBatchLimit));
-  }
-  if (timeout.value_or(kMinimumInterval) < kMinimumInterval) {
-    throw ConsumerStartFailedException(
-        info_.consumer_name,
-        fmt::format("Timeout has to be greater than or equal to {} milliseconds", kMinimumInterval.count()));
-  }
-
-  StartConsumingWithLimit(limit_batches, timeout);
 }

 void Consumer::Stop() {
@@ -285,7 +244,7 @@ void Consumer::StopIfRunning() {
  }
 }

-void Consumer::Check(std::optional<std::chrono::milliseconds> timeout, std::optional<uint64_t> limit_batches,
+void Consumer::Check(std::optional<std::chrono::milliseconds> timeout, std::optional<int64_t> limit_batches,
                     const ConsumerFunction &check_consumer_function) const {
  // NOLINTNEXTLINE (modernize-use-nullptr)
  if (timeout.value_or(kMinimumInterval) < kMinimumInterval) {
@@ -385,7 +344,13 @@ void Consumer::StartConsuming() {

  is_running_.store(true);

-  CheckAndDestroyLastAssignmentIfNeeded(*consumer_, info_, last_assignment_);
+  if (!last_assignment_.empty()) {
+    if (const auto err = consumer_->assign(last_assignment_); err != RdKafka::ERR_NO_ERROR) {
+      throw ConsumerStartFailedException(info_.consumer_name,
+                                         fmt::format("Couldn't restore commited offsets: '{}'", RdKafka::err2str(err)));
+    }
+    RdKafka::TopicPartition::destroy(last_assignment_);
+  }

  thread_ = std::thread([this] {
    static constexpr auto kMaxThreadNameSize = utils::GetMaxThreadNameSize();
@@ -396,18 +361,33 @@ void Consumer::StartConsuming() {
    while (is_running_) {
      auto maybe_batch = GetBatch(*consumer_, info_, is_running_);
      if (maybe_batch.HasError()) {
-        throw ConsumerReadMessagesFailedException(info_.consumer_name, maybe_batch.GetError());
+        spdlog::warn("Error happened in consumer {} while fetching messages: {}!", info_.consumer_name,
+                     maybe_batch.GetError());
+        break;
      }
      const auto &batch = maybe_batch.GetValue();

-      if (batch.empty()) {
-        continue;
-      }
+      if (batch.empty()) continue;

      spdlog::info("Kafka consumer {} is processing a batch", info_.consumer_name);

      try {
-        TryToConsumeBatch(*consumer_, info_, consumer_function_, batch);
+        consumer_function_(batch);
+        std::vector<RdKafka::TopicPartition *> partitions;
+        utils::OnScopeExit clear_partitions([&]() { RdKafka::TopicPartition::destroy(partitions); });
+
+        if (const auto err = consumer_->assignment(partitions); err != RdKafka::ERR_NO_ERROR) {
+          throw ConsumerCheckFailedException(
+              info_.consumer_name, fmt::format("Couldn't get assignment to commit offsets: {}", RdKafka::err2str(err)));
+        }
+        if (const auto err = consumer_->position(partitions); err != RdKafka::ERR_NO_ERROR) {
+          throw ConsumerCheckFailedException(
+              info_.consumer_name, fmt::format("Couldn't get offsets from librdkafka {}", RdKafka::err2str(err)));
+        }
+        if (const auto err = consumer_->commitSync(partitions); err != RdKafka::ERR_NO_ERROR) {
+          spdlog::warn("Committing offset of consumer {} failed: {}", info_.consumer_name, RdKafka::err2str(err));
+          break;
+        }
      } catch (const std::exception &e) {
        spdlog::warn("Error happened in consumer {} while processing a batch: {}!", info_.consumer_name, e.what());
        break;
@@ -418,44 +398,6 @@ void Consumer::StartConsuming() {
  });
 }

-void Consumer::StartConsumingWithLimit(uint64_t limit_batches, std::optional<std::chrono::milliseconds> timeout) const {
-  MG_ASSERT(!is_running_, "Cannot start already running consumer!");
-
-  if (is_running_.exchange(true)) {
-    throw ConsumerRunningException(info_.consumer_name);
-  }
-  utils::OnScopeExit restore_is_running([this] { is_running_.store(false); });
-
-  CheckAndDestroyLastAssignmentIfNeeded(*consumer_, info_, last_assignment_);
-
-  const auto timeout_to_use = timeout.value_or(kDefaultCheckTimeout);
-  const auto start = std::chrono::steady_clock::now();
-
-  for (uint64_t batch_count = 0; batch_count < limit_batches;) {
-    const auto now = std::chrono::steady_clock::now();
-    if (now - start >= timeout_to_use) {
-      throw ConsumerStartFailedException(info_.consumer_name, "Timeout reached");
-    }
-
-    const auto maybe_batch = GetBatch(*consumer_, info_, is_running_);
-    if (maybe_batch.HasError()) {
-      throw ConsumerReadMessagesFailedException(info_.consumer_name, maybe_batch.GetError());
-    }
-    const auto &batch = maybe_batch.GetValue();
-
-    if (batch.empty()) {
-      continue;
-    }
-    ++batch_count;
-
-    spdlog::info("Kafka consumer {} is processing a batch", info_.consumer_name);
-
-    TryToConsumeBatch(*consumer_, info_, consumer_function_, batch);
-
-    spdlog::info("Kafka consumer {} finished processing", info_.consumer_name);
-  }
-}
-
 void Consumer::StopConsuming() {
  is_running_.store(false);
  if (thread_.joinable()) thread_.join();
--- a/src/integrations/kafka/consumer.hpp
+++ b/src/integrations/kafka/consumer.hpp
@@ -113,19 +113,11 @@ class Consumer final : public RdKafka::EventCb {
  /// This method will start a new thread which will poll all the topics for messages.
  ///
  /// @throws ConsumerRunningException if the consumer is already running
-  /// @throws ConsumerStartFailedException if the commited offsets cannot be restored
  void Start();

-  /// Starts consuming messages.
+  /// Starts consuming messages if it is not started already.
  ///
-  /// This method will start a new thread which will poll all the topics for messages.
-  ///
-  /// @param limit_batches the consumer will only consume the given number of batches.
-  /// @param timeout the maximum duration during which the command should run.
-  ///
-  /// @throws ConsumerRunningException if the consumer is already running
-  /// @throws ConsumerStartFailedException if the commited offsets cannot be restored
-  void StartWithLimit(uint64_t limit_batches, std::optional<std::chrono::milliseconds> timeout) const;
+  void StartIfStopped();

  /// Stops consuming messages.
  ///
@@ -144,9 +136,9 @@ class Consumer final : public RdKafka::EventCb {
  ///                      used.
  /// @param check_consumer_function a function to feed the received messages in, only used during this dry-run.
  ///
-  /// @throws ConsumerRunningException if the consumer is already running.
+  /// @throws ConsumerRunningException if the consumer is alredy running.
  /// @throws ConsumerCheckFailedException if check isn't successful.
-  void Check(std::optional<std::chrono::milliseconds> timeout, std::optional<uint64_t> limit_batches,
+  void Check(std::optional<std::chrono::milliseconds> timeout, std::optional<int64_t> limit_batches,
             const ConsumerFunction &check_consumer_function) const;

  /// Returns true if the consumer is actively consuming messages.
@@ -165,7 +157,6 @@ class Consumer final : public RdKafka::EventCb {
  void event_cb(RdKafka::Event &event) override;

  void StartConsuming();
-  void StartConsumingWithLimit(uint64_t limit_batches, std::optional<std::chrono::milliseconds> timeout) const;

  void StopConsuming();

@@ -187,6 +178,7 @@ class Consumer final : public RdKafka::EventCb {
  ConsumerFunction consumer_function_;
  mutable std::atomic<bool> is_running_{false};
  mutable std::vector<RdKafka::TopicPartition *> last_assignment_;  // Protected by is_running_
+  std::optional<int64_t> limit_batches_{std::nullopt};
  std::unique_ptr<RdKafka::KafkaConsumer, std::function<void(RdKafka::KafkaConsumer *)>> consumer_;
  std::thread thread_;
  ConsumerRebalanceCb cb_;
--- a/src/integrations/kafka/exceptions.hpp
+++ b/src/integrations/kafka/exceptions.hpp
@@ -64,16 +64,4 @@ class TopicNotFoundException : public KafkaStreamException {
  TopicNotFoundException(const std::string_view consumer_name, const std::string_view topic_name)
      : KafkaStreamException("Kafka consumer {} cannot find topic {}", consumer_name, topic_name) {}
 };
-
-class ConsumerCommitFailedException : public KafkaStreamException {
- public:
-  ConsumerCommitFailedException(const std::string_view consumer_name, const std::string_view error)
-      : KafkaStreamException("Committing offset of consumer {} failed: {}", consumer_name, error) {}
-};
-
-class ConsumerReadMessagesFailedException : public KafkaStreamException {
- public:
-  ConsumerReadMessagesFailedException(const std::string_view consumer_name, const std::string_view error)
-      : KafkaStreamException("Error happened in consumer {} while fetching messages: {}", consumer_name, error) {}
-};
 }  // namespace memgraph::integrations::kafka
--- a/src/integrations/pulsar/consumer.cpp
+++ b/src/integrations/pulsar/consumer.cpp
@@ -11,14 +11,13 @@

 #include "integrations/pulsar/consumer.hpp"

-#include <algorithm>
-#include <chrono>
-#include <thread>
-
 #include <fmt/format.h>
 #include <pulsar/Client.h>
 #include <pulsar/InitialPosition.h>

+#include <chrono>
+#include <thread>
+
 #include "integrations/constants.hpp"
 #include "integrations/pulsar/exceptions.hpp"
 #include "utils/concepts.hpp"
@@ -34,10 +33,6 @@ namespace {
 template <typename T>
 concept PulsarConsumer = utils::SameAsAnyOf<T, pulsar_client::Consumer, pulsar_client::Reader>;

-template <typename TFunc>
-concept PulsarMessageGetter =
-    std::same_as<const pulsar_client::Message &, std::invoke_result_t<TFunc, const Message &>>;
-
 pulsar_client::Result ConsumeMessage(pulsar_client::Consumer &consumer, pulsar_client::Message &message,
                                     int remaining_timeout_in_ms) {
  return consumer.receive(message, remaining_timeout_in_ms);
@@ -102,26 +97,6 @@ pulsar_client::Client CreateClient(const std::string &service_url) {
  conf.setLogger(new SpdlogLoggerFactory);
  return {service_url, conf};
 }
-
-template <PulsarConsumer TConsumer, PulsarMessageGetter TPulsarMessageGetter>
-void TryToConsumeBatch(TConsumer &consumer, const ConsumerInfo &info, const ConsumerFunction &consumer_function,
-                       pulsar_client::MessageId &last_message_id, const std::vector<Message> &batch,
-                       const TPulsarMessageGetter &message_getter) {
-  consumer_function(batch);
-
-  auto has_message_failed = [&consumer, &info, &last_message_id, &message_getter](const auto &message) {
-    if (const auto result = consumer.acknowledge(message_getter(message)); result != pulsar_client::ResultOk) {
-      spdlog::warn("Acknowledging a message of consumer {} failed: {}", info.consumer_name, result);
-      return true;
-    }
-    last_message_id = message_getter(message).getMessageId();
-    return false;
-  };
-
-  if (std::ranges::any_of(batch, has_message_failed)) {
-    throw ConsumerAcknowledgeMessagesFailedException(info.consumer_name);
-  }
-}
 }  // namespace

 Message::Message(pulsar_client::Message &&message) : message_{std::move(message)} {}
@@ -162,24 +137,6 @@ void Consumer::Start() {
  StartConsuming();
 }

-void Consumer::StartWithLimit(const uint64_t limit_batches,
-                              const std::optional<std::chrono::milliseconds> timeout) const {
-  if (is_running_) {
-    throw ConsumerRunningException(info_.consumer_name);
-  }
-  if (limit_batches < kMinimumStartBatchLimit) {
-    throw ConsumerStartFailedException(
-        info_.consumer_name, fmt::format("Batch limit has to be greater than or equal to {}", kMinimumStartBatchLimit));
-  }
-  if (timeout.value_or(kMinimumInterval) < kMinimumInterval) {
-    throw ConsumerStartFailedException(
-        info_.consumer_name,
-        fmt::format("Timeout has to be greater than or equal to {} milliseconds", kMinimumInterval.count()));
-  }
-
-  StartConsumingWithLimit(limit_batches, timeout);
-}
-
 void Consumer::Stop() {
  if (!is_running_) {
    throw ConsumerStoppedException(info_.consumer_name);
@@ -197,7 +154,7 @@ void Consumer::StopIfRunning() {
  }
 }

-void Consumer::Check(std::optional<std::chrono::milliseconds> timeout, std::optional<uint64_t> limit_batches,
+void Consumer::Check(std::optional<std::chrono::milliseconds> timeout, std::optional<int64_t> limit_batches,
                     const ConsumerFunction &check_consumer_function) const {
  // NOLINTNEXTLINE (modernize-use-nullptr)
  if (timeout.value_or(kMinimumInterval) < kMinimumInterval) {
@@ -283,7 +240,9 @@ void Consumer::StartConsuming() {
      auto maybe_batch = GetBatch(consumer_, info_, is_running_, last_message_id_);

      if (maybe_batch.HasError()) {
-        throw ConsumerReadMessagesFailedException(info_.consumer_name, maybe_batch.GetError());
+        spdlog::warn("Error happened in consumer {} while fetching messages: {}!", info_.consumer_name,
+                     maybe_batch.GetError());
+        break;
      }

      const auto &batch = maybe_batch.GetValue();
@@ -295,8 +254,18 @@ void Consumer::StartConsuming() {
      spdlog::info("Pulsar consumer {} is processing a batch", info_.consumer_name);

      try {
-        TryToConsumeBatch(consumer_, info_, consumer_function_, last_message_id_, batch,
-                          [&](const Message &message) -> const pulsar_client::Message & { return message.message_; });
+        consumer_function_(batch);
+
+        if (std::any_of(batch.begin(), batch.end(), [&](const auto &message) {
+              if (const auto result = consumer_.acknowledge(message.message_); result != pulsar_client::ResultOk) {
+                spdlog::warn("Acknowledging a message of consumer {} failed: {}", info_.consumer_name, result);
+                return true;
+              }
+              last_message_id_ = message.message_.getMessageId();
+              return false;
+            })) {
+          break;
+        }
      } catch (const std::exception &e) {
        spdlog::warn("Error happened in consumer {} while processing a batch: {}!", info_.consumer_name, e.what());
        break;
@@ -308,43 +277,6 @@ void Consumer::StartConsuming() {
  });
 }

-void Consumer::StartConsumingWithLimit(uint64_t limit_batches, std::optional<std::chrono::milliseconds> timeout) const {
-  if (is_running_.exchange(true)) {
-    throw ConsumerRunningException(info_.consumer_name);
-  }
-  utils::OnScopeExit restore_is_running([this] { is_running_.store(false); });
-
-  const auto timeout_to_use = timeout.value_or(kDefaultCheckTimeout);
-  const auto start = std::chrono::steady_clock::now();
-
-  for (uint64_t batch_count = 0; batch_count < limit_batches;) {
-    const auto now = std::chrono::steady_clock::now();
-    if (now - start >= timeout_to_use) {
-      throw ConsumerCheckFailedException(info_.consumer_name, "Timeout reached");
-    }
-
-    const auto maybe_batch = GetBatch(consumer_, info_, is_running_, last_message_id_);
-
-    if (maybe_batch.HasError()) {
-      throw ConsumerReadMessagesFailedException(info_.consumer_name, maybe_batch.GetError());
-    }
-
-    const auto &batch = maybe_batch.GetValue();
-
-    if (batch.empty()) {
-      continue;
-    }
-    ++batch_count;
-
-    spdlog::info("Pulsar consumer {} is processing a batch", info_.consumer_name);
-
-    TryToConsumeBatch(consumer_, info_, consumer_function_, last_message_id_, batch,
-                      [](const Message &message) -> const pulsar_client::Message & { return message.message_; });
-
-    spdlog::info("Pulsar consumer {} finished processing", info_.consumer_name);
-  }
-}
-
 void Consumer::StopConsuming() {
  is_running_.store(false);
  if (thread_.joinable()) {
--- a/src/integrations/pulsar/consumer.hpp
+++ b/src/integrations/pulsar/consumer.hpp
@@ -58,27 +58,25 @@ class Consumer final {

  bool IsRunning() const;
  void Start();
-  void StartWithLimit(uint64_t limit_batches, std::optional<std::chrono::milliseconds> timeout) const;
  void Stop();
  void StopIfRunning();

-  void Check(std::optional<std::chrono::milliseconds> timeout, std::optional<uint64_t> limit_batches,
+  void Check(std::optional<std::chrono::milliseconds> timeout, std::optional<int64_t> limit_batches,
             const ConsumerFunction &check_consumer_function) const;

  const ConsumerInfo &Info() const;

 private:
  void StartConsuming();
-  void StartConsumingWithLimit(uint64_t limit_batches, std::optional<std::chrono::milliseconds> timeout) const;
  void StopConsuming();

  ConsumerInfo info_;
  mutable pulsar_client::Client client_;
-  mutable pulsar_client::Consumer consumer_;
+  pulsar_client::Consumer consumer_;
  ConsumerFunction consumer_function_;

  mutable std::atomic<bool> is_running_{false};
-  mutable pulsar_client::MessageId last_message_id_{pulsar_client::MessageId::earliest()};  // Protected by is_running_
+  pulsar_client::MessageId last_message_id_{pulsar_client::MessageId::earliest()};
  std::thread thread_;
 };
 }  // namespace memgraph::integrations::pulsar
--- a/src/integrations/pulsar/exceptions.hpp
+++ b/src/integrations/pulsar/exceptions.hpp
@@ -55,16 +55,4 @@ class TopicNotFoundException : public PulsarStreamException {
  TopicNotFoundException(const std::string &consumer_name, const std::string &topic_name)
      : PulsarStreamException("Pulsar consumer {} cannot find topic {}", consumer_name, topic_name) {}
 };
-
-class ConsumerReadMessagesFailedException : public PulsarStreamException {
- public:
-  ConsumerReadMessagesFailedException(const std::string_view consumer_name, const std::string_view error)
-      : PulsarStreamException("Error happened in consumer {} while fetching messages: {}", consumer_name, error) {}
-};
-
-class ConsumerAcknowledgeMessagesFailedException : public PulsarStreamException {
- public:
-  explicit ConsumerAcknowledgeMessagesFailedException(const std::string_view consumer_name)
-      : PulsarStreamException("Acknowledging a message of consumer {} has failed!", consumer_name) {}
-};
 }  // namespace memgraph::integrations::pulsar
--- a/src/interface/.gitignore
+++ b/src/interface/.gitignore
@@ -0,0 +1 @@
+gen-cpp2
--- a/src/interface/CMakeLists.txt
+++ b/src/interface/CMakeLists.txt
@@ -0,0 +1,19 @@
+include(MgThrift)
+
+set(MG_INTERFACE_PATH ${CMAKE_CURRENT_SOURCE_DIR})
+
+mg_thrift_library(
+  "storage" #file_name
+  "Storage" #services
+  "${MG_INTERFACE_PATH}" #file_path
+  "${MG_INTERFACE_PATH}" #output_path
+  "interface" #include_prefix
+)
+
+mg_thrift_library(
+  "meta" #file_name
+  "Meta" #services
+  "${MG_INTERFACE_PATH}" #file_path
+  "${MG_INTERFACE_PATH}" #output_path
+  "interface" #include_prefix
+)
--- a/src/interface/meta.thrift
+++ b/src/interface/meta.thrift
@@ -0,0 +1,74 @@
+namespace cpp2 interface.meta
+
+typedef i64 LabelId
+typedef i64 IndexId
+
+struct Result {
+    1: bool success;
+}
+
+struct CreatePrimaryLabelRequest {
+    1: binary name;
+    2: list<binary> primary_keys;
+}
+
+struct CreateLabelResponse {
+    1: Result result;
+    2: LabelId label_id;
+}
+
+struct GetLabelInfosRequest {
+    //  The empty list means return all of the label infos
+    1: list<binary> label_names;
+}
+
+struct LabelInfo {
+    1: binary name;
+    2: LabelId label_id;
+    3: list<binary> primary_keys;
+}
+
+struct GetLabelInfoResponse {
+    1: Result result;
+    2: LabelInfo label_info;
+}
+
+struct GetLabelInfosResponse {
+    1: Result result;
+    2: list<LabelInfo> label_infos;
+}
+
+struct CreateIndexRequest {
+    1: LabelId label_id;
+    2: list<binary> property_names;
+}
+
+struct CreateIndexResponse {
+    1: Result result;
+    2: IndexId index_id;
+}
+
+struct IndexInfo {
+    1: LabelId label_id;
+    2: list<binary> property_names;
+}
+
+struct GetIndexInfosResponse {
+    1: Result result;
+    2: list<IndexInfo> index_infos;
+}
+
+
+service Meta {
+    CreateLabelResponse createPrimaryLabel(1: CreatePrimaryLabelRequest req);
+    CreateLabelResponse createSecondaryLabel(1: binary label_name);
+    Result dropLabel(1: binary label_name);
+    GetLabelInfoResponse getLabelInfo(1:binary label_name);
+    GetLabelInfosResponse getLabelInfos(1: list<binary> label_names);
+
+    CreateIndexResponse createIndex(1: CreateIndexRequest req);
+    // Don't have index names, and the label doesn't identify the index uniquely, therefore
+    Result dropIndex(1: IndexId index_id);
+    GetIndexInfosResponse getIndexInfos();
+    GetIndexInfosResponse getIndexInfosForLabel(1: LabelId label_id);
+}
--- a/src/interface/storage.thrift
+++ b/src/interface/storage.thrift
@@ -0,0 +1,302 @@
+namespace cpp2 interface.storage
+// https://stackoverflow.com/a/34234874/6639989
+
+cpp_include "storage/v2/view.hpp"
+
+typedef i64 VertexId
+typedef i64 Gid
+
+// TODO(antaljanosbenjamin): Use this after introducing 128 bit vertex ids
+// struct VertexId {
+//     1: i64 upper_half;
+//     2: i64 lower_half;
+// }
+
+struct Label {
+    1: i64 id;
+}
+
+struct EdgeType {
+    1: binary name;
+}
+
+struct EdgeId {
+    1: VertexId src;
+    // QUESTION(antaljanosbenjamin): is it okay to have vertex based (edge id = vertex id + edge id inside vertex)?
+    2: Gid gid;
+}
+
+struct Date {
+    1: i16 year;
+    2: byte month;
+    3: byte day;
+}
+
+struct LocalTime {
+    1: byte hour;
+    2: byte minute;
+    3: byte second;
+    4: i16 millisecond;
+    5: i16 microsecond;
+}
+
+struct LocalDateTime {
+    1: Date date;
+    2: LocalTime local_time;
+}
+
+struct Duration {
+    1: i64 milliseconds;
+}
+
+union Value {
+    1: Null null_v;
+    2: bool bool_v;
+    3: i64 int_v;
+    4: double double_v;
+    5: binary string_v;
+    6: list<Value> list_v;
+    7: map<binary, Value> (cpp.template = "std::unordered_map") map_v (cpp2.ref_type = "unique");
+    8: Vertex vertex_v (cpp2.ref_type = "unique");
+    9: Edge edge_v (cpp2.ref_type = "unique");
+    10: Path path_v (cpp2.ref_type = "unique");
+    11: Date date_v;
+    12: LocalTime local_time_v;
+    13: LocalDateTime local_date_time_v;
+    14: Duration duration_v;
+}
+
+struct Null {
+}
+
+struct Vertex {
+    1: VertexId id;
+    // TODO(antaljanosbenjamin): Change to sperate primary and secondary labels when schema is implemented
+    2: list<Label> labels;
+}
+
+struct Edge {
+    1: VertexId src;
+    2: VertexId dst;
+    3: EdgeType type;
+}
+
+struct PathPart {
+    1: Vertex dst;
+    2: Edge edge;
+}
+
+struct Path {
+    1: Vertex src;
+    2: list<PathPart> parts;
+}
+
+struct ValuesMap {
+    1: map<i64, Value> (cpp.template = "std::unordered_map") values_map;
+}
+
+struct MappedValues {
+    1: list<ValuesMap> properties;
+}
+
+struct ListedValues {
+    1: list<list<Value>> properties;
+}
+
+union Values {
+    // This struct is necessary because depending on the request the response
+    // has two different formats:
+    // 1. When the request specifies the returned properties, then they are
+    //    returned in that order, therefore no extra mapping is necessary.
+    // 2. When the request doesn't specify the returned properties, then all
+    //    of the properties are returned. In this case the `mapped` field is
+    //    used. To extract the <key,value> pairs from this struct the
+    //    mapping of i64 -> property name has to be used.
+    1: ListedValues listed;
+    2: MappedValues mapped;
+}
+
+struct Expression {
+    1: binary alias;
+    2: binary expression;
+}
+
+struct Filter {
+    1: binary filter_expression;
+}
+
+enum OrderingDirection {
+    ASCENDING = 1;
+    DESCENDING = 2;
+}
+
+struct OrderBy {
+    1: Expression expression;
+    2: OrderingDirection direction;
+}
+
+struct Result {
+    // Just placeholder data for now
+    1: bool success;
+}
+
+enum View {
+    OLD = 0,
+    NEW = 1
+}  (cpp.enum_strict, cpp.type = "memgraph::storage::View")
+
+struct ScanVerticesRequest {
+    1: i64 transaction_id;
+    2: optional i64 start_id;
+    // Special values are accepted:
+    // * __mg__id (Vertex, but without labels)
+    // * __mg__labels (Vertex, but without the id)
+    // If both of them is specified, then it will result in a single, fully populated vertex
+    // QUESTION(antaljanosbenjamin): Does the `__mg__labels` is necessary? What about passing the `labels` function
+    //                               as an expression? Maybe it is an optimization. For communicating the vertex id
+    //                               the Vertex struct is really handy.
+    3: optional list<binary> props_to_return;
+    4: list<Expression> expressions;
+    5: optional i64 limit;
+    6: View view;
+    7: optional Filter filter;
+}
+
+struct ScanVerticesResponse {
+    1: Result result;
+    2: Values values;
+    3: optional map<i64, binary> (cpp.template = "std::unordered_map") property_name_map;
+    // contains the next start_id if there is any
+    4: optional VertexId next_start_id;
+}
+
+union VertexOrEdgeIds {
+    1: list<VertexId> vertex_ids;
+    2: list<EdgeId> edge_ids;
+}
+
+struct GetPropertiesRequest {
+    1:  i64 transaction_id;
+    2:  VertexOrEdgeIds vertex_or_edge_ids;
+    3:  list<binary> property_names;
+    4:  list<Expression> expressions;
+    5:  bool only_unique = false;
+    6:  optional list<OrderBy> order_by;
+    7:  optional i64 limit;
+    8:  optional Filter filter;
+}
+
+struct GetPropertiesResponse {
+    1: Values values;
+    2: optional map<i64, binary> (cpp.template = "std::unordered_map") property_name_map;
+}
+
+enum EdgeDirection {
+    OUT = 1;
+    IN = 2;
+    BOTH = 3;
+}
+
+struct ExpandOneRequest {
+    1:  i64 transaction_id;
+    2:  list<VertexId> src_vertices;
+    3:  list<EdgeType> edge_types;
+    4:  EdgeDirection direction;
+    5:  bool only_unique_neighbor_rows = false;
+    //  The empty optional means return all of the properties, while an empty
+    //  list means do not return any properties
+    //  TODO(antaljanosbenjamin): All of the special values should be communicated through a single vertex object
+    //                            after schema is implemented
+    //  Special values are accepted:
+    //  * __mg__labels
+    6:  optional list<binary> src_vertex_properties;
+    //  TODO(antaljanosbenjamin): All of the special values should be communicated through a single vertex object
+    //                            after schema is implemented
+    //  Special values are accepted:
+    //  * __mg__dst_id (Vertex, but without labels)
+    //  * __mg__type (binary)
+    7:  optional list<binary> edge_properties;
+    //  QUESTION(antaljanosbenjamin): Maybe also add possibility to expressions evaluated on the source vertex?
+    //  List of expressions evaluated on edges
+    8:  list<Expression> expressions;
+    9:  optional list<OrderBy> order_by;
+    10:  optional i64 limit;
+    11: optional Filter filter;
+}
+
+struct ExpandOneResultRow {
+    // NOTE: This struct could be a single Values with columns something like this:
+    // src_vertex(Vertex), vertex_prop1(Value), vertex_prop2(Value), edges(list<Value>)
+    // where edges might be a list of:
+    // 1. list<Value> if only a defined list of edge properties are returned
+    // 2. map<binary, Value> if all of the edge properties are returned
+    // The drawback of this is currently the key of the map is always interpreted as a string in Value, not as an
+    // integer, which should be in case of mapped properties.
+    1: Vertex src_vertex;
+    2: optional Values src_vertex_properties;
+    3: Values edges;
+}
+
+struct ExpandOneResponse {
+    // This approach might not suit the expand with per shard parrallelization,
+    // because the property_name_map has to be accessed from multiple threads
+    // in order to avoid duplicated keys (two threads might map the same
+    // property with different numbers) and multiple passes (to unify the
+    // mapping amond result returned from different shards).
+    1: list<ExpandOneResultRow> result;
+    2: optional map<i64, binary>  (cpp.template = "std::unordered_map") property_name_map;
+}
+
+struct NewVertex {
+    1: list<i64> label_ids;
+    2: map<i64, Value> properties;
+}
+
+struct CreateVerticesRequest {
+    1: required i64 transaction_id;
+    2: map<i64, binary> (cpp.template = "std::unordered_map") labels_name_map;
+    3: map<i64, binary> (cpp.template = "std::unordered_map") property_name_map;
+    4: list<NewVertex> new_vertices;
+}
+
+struct NewEdge {
+    1: required VertexId src;
+    2: required VertexId dest;
+    3: required EdgeType type;
+    4: map<i64, Value> properties;
+}
+
+struct CreateEdgesRequest {
+    1: required i64 transaction_id;
+    3: map<i64, binary> (cpp.template = "std::unordered_map") property_name_map;
+    4: list<NewEdge> new_edges;
+}
+
+struct UpdateVertex {
+    1: required VertexId vertex_id;
+    2: list<i64> create_label_ids;
+    3: list<i64> delete_label_ids;
+    4: map<i64, Value> properties;
+}
+
+// Null signifies removel of label or property
+struct UpdateVerticesRequest {
+    1: required i64 transaction_id;
+    2: map<i64, binary> (cpp.template = "std::unordered_map") labels_name_map;
+    3: map<i64, binary> (cpp.template = "std::unordered_map") property_name_map;
+    4: list<UpdateVertex> update_vertices;
+}
+
+service Storage {
+    i64 startTransaction()
+    Result commitTransaction(1: i64 transaction_id)
+    void abortTransaction(1: i64 transaction_id)
+
+    Result createVertices(1: CreateVerticesRequest req)
+    Result updateVertices(1: UpdateVerticesRequest req)
+    Result createEdges(1: CreateEdgesRequest req)
+    ScanVerticesResponse scanVertices(1: ScanVerticesRequest req)
+    GetPropertiesResponse getProperties(1: GetPropertiesRequest req)
+    ExpandOneResponse expandOne(1: ExpandOneRequest req)
+
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
jbajic	061d0f8aa6	Refactor update vertices	2022-05-16 10:32:41 +02:00
jbajic	9c53a9943b	Add update vertices	2022-05-13 14:12:55 +02:00
jbajic	9685e1d3c4	Add edge updating property	2022-05-13 13:30:38 +02:00
jbajic	bdf794e229	Create edge	2022-05-12 16:22:35 +02:00
János Benjamin Antal	3dd90e2acb	Update the storage interface	2022-05-02 09:09:31 +02:00
János Benjamin Antal	62945c3b3a	Merge remote-tracking branch 'origin/master' into T0804-MG-base-thrift-project	2022-04-29 15:48:00 +02:00
János Benjamin Antal	e1704ff2d0	Revert "Use attribute instead of UNLIKELY" This reverts commit `5780ee6c5b`.	2022-04-29 15:46:49 +02:00
János Benjamin Antal	7f0c53196b	Revert unvanted change	2022-04-29 15:19:23 +02:00
János Benjamin Antal	2da28c2c87	Add meta service interface	2022-04-22 17:06:48 +02:00
János Benjamin Antal	b36cce2428	Add thrift demo	2022-03-31 09:05:52 +02:00
János Benjamin Antal	6afcfcbb89	Merge commit 'bf01c58ed9950a1b2d05a884aad9544e8193b7f3' into T0804-MG-base-thrift-project	2022-03-24 15:25:39 +01:00
János Benjamin Antal	d21798c350	Implement scanVertices	2022-03-24 08:51:37 +01:00
János Benjamin Antal	6fe2293f4a	Merge remote-tracking branch 'origin/master' into T0804-MG-base-thrift-project	2022-02-28 15:34:53 +01:00
János Benjamin Antal	2f1acff7d7	Replace outdated wrapper header file	2022-02-28 13:27:44 +01:00
János Benjamin Antal	e298f11968	Add storage client demo	2022-02-10 09:07:33 +01:00
János Benjamin Antal	5a4c0f7a1b	Resolve conflict of ANTLR generated function and macro from glog	2022-02-08 12:33:39 +01:00
János Benjamin Antal	52960a8877	Add base of server and client	2022-02-07 15:14:29 +01:00
János Benjamin Antal	4811024e75	Add `createVertices` to Thrift	2022-02-07 15:13:19 +01:00
János Benjamin Antal	9193fcade3	CMake cleanup	2022-02-07 15:12:23 +01:00
János Benjamin Antal	066cfa32e3	Fix typo	2022-02-07 15:12:13 +01:00
János Benjamin Antal	77c27482f7	Link generated thrift interface to memgraph	2022-01-28 15:17:45 +01:00
János Benjamin Antal	8f42632fd2	CMake cleanup	2022-01-28 15:14:58 +01:00
János Benjamin Antal	5780ee6c5b	Use attribute instead of UNLIKELY	2022-01-28 13:42:21 +01:00
János Benjamin Antal	542928b690	Fix namespace	2022-01-28 10:17:33 +01:00
János Benjamin Antal	67d39597d7	Remove coroutines from folly	2022-01-28 10:16:11 +01:00
János Benjamin Antal	bd0efa1159	Use patch files	2022-01-28 10:15:48 +01:00
János Benjamin Antal	e60dd252d0	Use std::unordered_map	2022-01-27 08:21:03 +01:00
János Benjamin Antal	84b78ded07	Add base of thrift interface	2022-01-27 07:52:39 +01:00