Fix v2.9 release build issues -> manual v2.9.0

* Add `--replication-restore-state-on-startup` with `false` as default

Co-authored-by: Aidar Samerkhanov <aidar.samerkhanov@memgraph.io>
Co-authored-by: Andi Skrgat <andi8647@gmail.com>

.clang-format

@@ -1,6 +1,7 @@
 ---
+BasedOnStyle: Google
+---
 Language:     Cpp
-BasedOnStyle: Google
 Standard:     "c++20"
 UseTab:       Never
 DerivePointerAlignment: false

.github/pull_request_template.md

@@ -10,5 +10,5 @@
 
 
 To keep docs changelog up to date, one more thing to do:
-- [ ] Write a release note here
+- [ ] Write a release note here, including added/changed clauses
 - [ ] Tag someone from docs team in the comments

.github/workflows/daily_benchmark.yaml

@@ -67,7 +67,7 @@ jobs:
       - name: Run mgbench
         run: |
           cd tests/mgbench
-          ./benchmark.py --num-workers-for-benchmark 12 --export-results benchmark_result.json pokec/medium/*/*
+          ./benchmark.py vendor-native --num-workers-for-benchmark 12 --export-results benchmark_result.json pokec/medium/*/*
 
       - name: Upload mgbench results
         run: |

.github/workflows/diff.yaml

@@ -196,22 +196,7 @@ jobs:
 
       - name: Run integration tests
         run: |
-          cd tests/integration
-          for name in *; do
-            if [ ! -d $name ]; then continue; fi
-            pushd $name >/dev/null
-            echo "Running: $name"
-            if [ -x prepare.sh ]; then
-              ./prepare.sh
-            fi
-            if [ -x runner.py ]; then
-              ./runner.py
-            elif [ -x runner.sh ]; then
-              ./runner.sh
-            fi
-            echo
-            popd >/dev/null
-          done
+          tests/integration/run.sh
 
       - name: Run cppcheck and clang-format
         run: |
@@ -281,12 +266,11 @@ jobs:
 
       - name: Run e2e tests
         run: |
-          # TODO(gitbuda): Setup mgclient and pymgclient properly.
           cd tests
           ./setup.sh
           source ve3/bin/activate
           cd e2e
-          LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../../libs/mgclient/lib python runner.py --workloads-root-directory .
+          ./run.sh
 
       - name: Run stress test (plain)
         run: |
@@ -308,7 +292,6 @@ jobs:
         run: |
           # Activate toolchain.
           source /opt/toolchain-v4/activate
-
           cd build
 
           # create mgconsole
@@ -355,10 +338,8 @@ jobs:
         run: |
           # Activate toolchain.
           source /opt/toolchain-v4/activate
-
           # Initialize dependencies.
           ./init
-
           # Build only memgraph release binarie.
           cd build
           cmake -DCMAKE_BUILD_TYPE=release ..
@@ -367,7 +348,7 @@ jobs:
       - name: Run Jepsen tests
         run: |
           cd tests/jepsen
-          ./run.sh test --binary ../../build/memgraph --run-args "test-all --node-configs resources/node-config.edn" --ignore-run-stdout-logs --ignore-run-stderr-logs
+          ./run.sh test-all-individually --binary ../../build/memgraph --ignore-run-stdout-logs --ignore-run-stderr-logs
 
       - name: Save Jepsen report
         uses: actions/upload-artifact@v3
@@ -437,7 +418,7 @@ jobs:
       - name: Run mgbench
         run: |
           cd tests/mgbench
-          ./benchmark.py --num-workers-for-benchmark 12 --export-results benchmark_result.json pokec/medium/*/*
+          ./benchmark.py vendor-native --num-workers-for-benchmark 12 --export-results benchmark_result.json pokec/medium/*/*
 
       - name: Upload mgbench results
         run: |

.github/workflows/package_all.yaml

@@ -2,7 +2,12 @@ name: Package All
 
 # TODO(gitbuda): Cleanup docker container if GHA job was canceled.
 
-on: workflow_dispatch
+on:
+  workflow_dispatch:
+    inputs:
+      memgraph_version:
+        description: "Memgraph version to upload as. If empty upload is skipped. Format: 'vX.Y.Z'"
+        required: false
 
 jobs:
   centos-7:
@@ -106,7 +111,7 @@ jobs:
       - name: "Upload package"
         uses: actions/upload-artifact@v3
         with:
-          name: ubuntu-1804
+          name: ubuntu-18.04
           path: build/output/ubuntu-18.04/memgraph*.deb
 
   ubuntu-2004:
@@ -123,7 +128,7 @@ jobs:
       - name: "Upload package"
         uses: actions/upload-artifact@v3
         with:
-          name: ubuntu-2004
+          name: ubuntu-20.04
           path: build/output/ubuntu-20.04/memgraph*.deb
 
   ubuntu-2204:
@@ -140,7 +145,7 @@ jobs:
       - name: "Upload package"
         uses: actions/upload-artifact@v3
         with:
-          name: ubuntu-2204
+          name: ubuntu-22.04
           path: build/output/ubuntu-22.04/memgraph*.deb
 
   debian-11-platform:
@@ -208,7 +213,7 @@ jobs:
       - name: "Upload package"
         uses: actions/upload-artifact@v3
         with:
-          name: debian-11-arm
+          name: debian-11-aarch64
           path: build/output/debian-11-arm/memgraph*.deb
 
   ubuntu-2204-arm:
@@ -225,5 +230,27 @@ jobs:
       - name: "Upload package"
         uses: actions/upload-artifact@v3
         with:
-          name: ubuntu-22.04-arm
+          name: ubuntu-22.04-aarch64
           path: build/output/ubuntu-22.04-arm/memgraph*.deb
+
+  upload-to-s3:
+    # only run upload if we specified version. Allows for runs without upload
+    if: "${{ github.event.inputs.memgraph_version != '' }}"
+    needs: [centos-7, centos-9, debian-10, debian-11, docker, ubuntu-1804, ubuntu-2004, ubuntu-2204, debian-11-platform, fedora-36, amzn-2, debian-11-arm, ubuntu-2204-arm]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@v3
+        with:
+          # name: # if name input parameter is not provided, all artifacts are downloaded
+                  # and put in directories named after each one.
+          path: build/output/release
+      - name: Upload to S3
+        uses: jakejarvis/s3-sync-action@v0.5.1
+        env:
+          AWS_S3_BUCKET: "download.memgraph.com"
+          AWS_ACCESS_KEY_ID: ${{ secrets.S3_AWS_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_AWS_SECRET_ACCESS_KEY }}
+          AWS_REGION: "eu-west-1"
+          SOURCE_DIR: "build/output/release"
+          DEST_DIR: "memgraph/${{ github.event.inputs.memgraph_version }}/"

.github/workflows/release_centos8.yaml

@@ -146,22 +146,7 @@ jobs:
 
       - name: Run integration tests
         run: |
-          cd tests/integration
-          for name in *; do
-            if [ ! -d $name ]; then continue; fi
-            pushd $name >/dev/null
-            echo "Running: $name"
-            if [ -x prepare.sh ]; then
-              ./prepare.sh
-            fi
-            if [ -x runner.py ]; then
-              ./runner.py
-            elif [ -x runner.sh ]; then
-              ./runner.sh
-            fi
-            echo
-            popd >/dev/null
-          done
+          tests/integration/run.sh
 
       - name: Run cppcheck and clang-format
         run: |
@@ -280,12 +265,11 @@ jobs:
 
       - name: Run e2e tests
         run: |
-          # TODO(gitbuda): Setup mgclient and pymgclient properly.
           cd tests
           ./setup.sh
           source ve3/bin/activate
           cd e2e
-          LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../../libs/mgclient/lib python runner.py --workloads-root-directory .
+          ./run.sh
 
       - name: Run stress test (plain)
         run: |

.github/workflows/release_debian10.yaml

@@ -146,22 +146,7 @@ jobs:
 
       - name: Run integration tests
         run: |
-          cd tests/integration
-          for name in *; do
-            if [ ! -d $name ]; then continue; fi
-            pushd $name >/dev/null
-            echo "Running: $name"
-            if [ -x prepare.sh ]; then
-              ./prepare.sh
-            fi
-            if [ -x runner.py ]; then
-              ./runner.py
-            elif [ -x runner.sh ]; then
-              ./runner.sh
-            fi
-            echo
-            popd >/dev/null
-          done
+          tests/integration/run.sh
 
       - name: Run cppcheck and clang-format
         run: |
@@ -279,12 +264,11 @@ jobs:
 
       - name: Run e2e tests
         run: |
-          # TODO(gitbuda): Setup mgclient and pymgclient properly.
           cd tests
           ./setup.sh
           source ve3/bin/activate
           cd e2e
-          LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../../libs/mgclient/lib python runner.py --workloads-root-directory .
+          ./run.sh
 
       - name: Run stress test (plain)
         run: |
@@ -334,10 +318,8 @@ jobs:
         run: |
           # Activate toolchain.
           source /opt/toolchain-v4/activate
-
           # Initialize dependencies.
           ./init
-
           # Build only memgraph release binary.
           cd build
           cmake -DCMAKE_BUILD_TYPE=release ..
@@ -346,7 +328,7 @@ jobs:
       - name: Run Jepsen tests
         run: |
           cd tests/jepsen
-          ./run.sh test --binary ../../build/memgraph --run-args "test-all --node-configs resources/node-config.edn" --ignore-run-stdout-logs --ignore-run-stderr-logs
+          ./run.sh test-all-individually --binary ../../build/memgraph --ignore-run-stdout-logs --ignore-run-stderr-logs
 
       - name: Save Jepsen report
         uses: actions/upload-artifact@v3

.github/workflows/release_docker.yaml

@@ -31,8 +31,8 @@ jobs:
       - name: Log in to Docker Hub
         uses: docker/login-action@v2
         with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Download memgraph binary
         run: |

.github/workflows/release_mgbench_client.yaml

@@ -0,0 +1,63 @@
+name: "Mgbench Bolt Client Publish Docker Image"
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Mgbench bolt client version to publish on Dockerhub."
+        required: true
+      force_release:
+        type: boolean
+        required: false
+        default: false
+
+jobs:
+  mgbench_docker_publish:
+    runs-on: ubuntu-latest
+    env:
+      DOCKER_ORGANIZATION_NAME: memgraph
+      DOCKER_REPOSITORY_NAME: mgbench-client
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - 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 tests/mgbench
+          docker buildx build \
+          --build-arg TOOLCHAIN_VERSION=toolchain-v4 \
+          --platform linux/amd64,linux/arm64 \
+          --tag $DOCKER_ORGANIZATION_NAME/$DOCKER_REPOSITORY_NAME:${{ github.event.inputs.version }} \
+          --tag $DOCKER_ORGANIZATION_NAME/$DOCKER_REPOSITORY_NAME:latest \
+          --file Dockerfile.mgbench_client \
+          --push .

.github/workflows/release_ubuntu2004.yaml

@@ -146,22 +146,7 @@ jobs:
 
       - name: Run integration tests
         run: |
-          cd tests/integration
-          for name in *; do
-            if [ ! -d $name ]; then continue; fi
-            pushd $name >/dev/null
-            echo "Running: $name"
-            if [ -x prepare.sh ]; then
-              ./prepare.sh
-            fi
-            if [ -x runner.py ]; then
-              ./runner.py
-            elif [ -x runner.sh ]; then
-              ./runner.sh
-            fi
-            echo
-            popd >/dev/null
-          done
+          tests/integration/run.sh
 
       - name: Run cppcheck and clang-format
         run: |
@@ -279,12 +264,11 @@ jobs:
 
       - name: Run e2e tests
         run: |
-          # TODO(gitbuda): Setup mgclient and pymgclient properly.
           cd tests
           ./setup.sh
           source ve3/bin/activate
           cd e2e
-          LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../../libs/mgclient/lib python runner.py --workloads-root-directory .
+          ./run.sh
 
       - name: Run stress test (plain)
         run: |

.pre-commit-config.yaml

@@ -3,6 +3,7 @@ repos:
     rev: v4.4.0
     hooks:
       - id: check-yaml
+        args: [--allow-multiple-documents]
       - id: end-of-file-fixer
       - id: trailing-whitespace
   - repo: https://github.com/psf/black

CMakeLists.txt

@@ -1,6 +1,7 @@
 # MemGraph CMake configuration
 
-cmake_minimum_required(VERSION 3.8)
+cmake_minimum_required(VERSION 3.12)
+cmake_policy(SET CMP0076 NEW)
 
 # !! IMPORTANT !! run ./project_root/init.sh before cmake command
 # to download dependencies
@@ -18,10 +19,12 @@ set_directory_properties(PROPERTIES CLEAN_NO_CUSTOM TRUE)
 # during the code coverage process
 find_program(CCACHE_FOUND ccache)
 option(USE_CCACHE "ccache:" ON)
-message(STATUS "CCache: ${USE_CCACHE}")
 if(CCACHE_FOUND AND USE_CCACHE)
   set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
   set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+  message(STATUS "CCache: Used")
+else ()
+  message(STATUS "CCache: Not used")
 endif(CCACHE_FOUND AND USE_CCACHE)
 
 # choose a compiler
@@ -37,7 +40,14 @@ endif()
 
 # -----------------------------------------------------------------------------
 
-project(memgraph)
+project(memgraph LANGUAGES C CXX)
+
+#TODO: upgrade to cmake 3.24 + CheckIPOSupported
+#cmake_policy(SET CMP0138 NEW)
+#include(CheckIPOSupported)
+#check_ipo_supported()
+#set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_Release TRUE)
+#set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RelWithDebInfo TRUE)
 
 # Install licenses.
 install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/licenses/
@@ -54,7 +64,7 @@ option(MG_ENTERPRISE "Build Memgraph Enterprise Edition" ON)
 # Set the current version here to override the automatic version detection. The
 # version must be specified as `X.Y.Z`. Primarily used when building new patch
 # versions.
-set(MEMGRAPH_OVERRIDE_VERSION "")
+set(MEMGRAPH_OVERRIDE_VERSION "2.9.0")
 
 # Custom suffix that this version should have. The suffix can be any arbitrary
 # string. Primarily used when building a version for a specific customer.
@@ -143,7 +153,9 @@ endif()
 # files used can be seen here:
 # https://git-scm.com/book/en/v2/Git-Internals-Git-References
 set(git_directory "${CMAKE_SOURCE_DIR}/.git")
-if (EXISTS "${git_directory}")
+# Check for directory because if the repo is cloned as a git submodule, .git is
+# a file and below code doesn't work.
+if (IS_DIRECTORY "${git_directory}")
   set_property(DIRECTORY APPEND PROPERTY
       CMAKE_CONFIGURE_DEPENDS "${git_directory}/HEAD")
   file(STRINGS "${git_directory}/HEAD" git_head_data)
@@ -158,7 +170,7 @@ endif()
 
 # setup CMake module path, defines path for include() and find_package()
 # https://cmake.org/cmake/help/latest/variable/CMAKE_MODULE_PATH.html
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 # custom function definitions
 include(functions)
 # -----------------------------------------------------------------------------
@@ -231,6 +243,8 @@ endif()
 message(STATUS "CMake build type: ${CMAKE_BUILD_TYPE}")
 # -----------------------------------------------------------------------------
 
+add_definitions( -DCMAKE_BUILD_TYPE_NAME="${CMAKE_BUILD_TYPE}")
+
 if (NOT MG_ARCH)
     set(MG_ARCH_DESCR "Host architecture to build Memgraph on. Supported values are x86_64, ARM64.")
     if (${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "aarch64")

config/flags.yaml

@@ -103,6 +103,10 @@ modifications:
     value: "true"
     override: false
 
+  - name: "storage_parallel_index_recovery"
+    value: "false"
+    override: true
+
 undocumented:
   - "flag_file"
   - "also_log_to_stderr"

config/generate.py

@@ -23,6 +23,14 @@ def wrap_text(s, initial_indent="# "):
 def extract_flags(binary_path):
     ret = {}
     data = subprocess.run([binary_path, "--help-xml"], stdout=subprocess.PIPE).stdout.decode("utf-8")
+    # If something is printed out before the help output, it will break the the
+    # XML parsing -> filter out if something is not XML line because something
+    # can be logged before gflags output (e.g. during the global objects init).
+    # This gets called during memgraph build phase to generate default config
+    # file later installed under /etc/memgraph/memgraph.conf
+    # NOTE: Don't use \n in the gflags description strings.
+    # NOTE: Check here if gflags version changes because of the XML format.
+    data = "\n".join([line for line in data.split("\n") if line.startswith("<")])
     root = ET.fromstring(data)
     for child in root:
         if child.tag == "usage" and child.text.lower().count("warning"):

docs/csv-import-tool/README.md

@@ -202,3 +202,29 @@ for row in csv.reader(stream, delimiter=',', doublequote=True,
 For more information about the meaning of the above values, see:
 https://docs.python.org/3/library/csv.html#csv.Dialect
 
+## Errors
+
+1. [Skipping duplicate node with ID '{}'. For more details, visit:
+   memgr.ph/csv-import-tool.](#error-1)
+2. [Skipping bad relationship with START_ID '{}'. For more details, visit:
+   memgr.ph/csv-import-tool.](#error-2)
+3. [Skipping bad relationship with END_ID '{}'. For more details, visit:
+   memgr.ph/csv-import-tool.](#error-3)
+
+## Skipping duplicate node with ID {} {#error-1}
+
+Duplicate nodes are nodes that have an ID that is the same as another node that
+was already imported. You can instruct the importer to ignore all duplicate
+nodes (instead of raising an error) by using the `--skip-duplicate-nodes` flag.
+
+## Skipping bad relationship with START_ID {} {#error-2}
+
+A node with the id `START_ID` doesn't exist. You can instruct the importer to
+ignore all bad relationships (instead of raising an error) that refer to nodes
+that don't exist in the node files by using the `--skip-bad-relationships` flag.
+
+## Skipping bad relationship with END_ID {} {#error-3}
+
+A node with the id `END_ID` doesn't exist. You can instruct the importer to
+ignore all bad relationships (instead of raising an error) that refer to nodes
+that don't exist in the node files by using the `--skip-bad-relationships` flag.

environment/README.md

@@ -0,0 +1,10 @@
+# Memgraph Operating Environments
+
+## os
+
+Under the `os` directory, you can find scripts to install all required system
+dependencies on operating systems where Memgraph natively builds. The testing
+script helps to see how to install all packages (in the case of a new package),
+or make any adjustments in the overall system setup. Also, the testing script
+helps check if Memgraph runs on a freshly installed operating system (with no
+packages installed).

environment/os/.gitignore

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

environment/os/amzn-2.sh

@@ -41,7 +41,7 @@ TOOLCHAIN_RUN_DEPS=(
 
 MEMGRAPH_BUILD_DEPS=(
     git # source code control
-    make # build system
+    make cmake # build system
     wget # for downloading libs
     libuuid-devel java-11-openjdk # required by antlr
     readline-devel # for memgraph console
@@ -57,9 +57,18 @@ MEMGRAPH_BUILD_DEPS=(
     libcurl-devel # mg-requests
     rpm-build rpmlint # for RPM package building
     doxygen graphviz # source documentation generators
-    which nodejs golang zip unzip java-11-openjdk-devel # for driver tests
+    which nodejs golang custom-golang1.18.9 zip unzip java-11-openjdk-devel jdk-17 custom-maven3.9.2 # for driver tests
     autoconf # for jemalloc code generation
     libtool  # for protobuf code generation
+    cyrus-sasl-devel
+)
+
+MEMGRAPH_RUN_DEPS=(
+    logrotate openssl python3 libseccomp
+)
+
+NEW_DEPS=(
+    wget curl tar gzip
 )
 
 list() {
@@ -73,6 +82,18 @@ check() {
     local OLD_LD_LIBRARY_PATH=${LD_LIBRARY_PATH:-""}
     LD_LIBRARY_PATH=""
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            if [ ! -f "/opt/apache-maven-3.9.2/bin/mvn" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            if [ ! -f "/opt/go1.18.9/go/bin/go" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
         if [ "$pkg" == "PyYAML" ]; then
             if ! python3 -c "import yaml" >/dev/null 2>/dev/null; then
                 missing="$pkg $missing"
@@ -103,8 +124,27 @@ install() {
     else
         echo "NOTE: export LANG=en_US.utf8"
     fi
+
     yum update -y
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            install_custom_maven "3.9.2"
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            install_custom_golang "1.18.9"
+            continue
+        fi
+        if [ "$pkg" == jdk-17 ]; then
+          if ! yum list installed jdk-17 >/dev/null 2>/dev/null; then
+              wget --no-check-certificate -c --header "Cookie: oraclelicense=accept-securebackup-cookie" https://download.oracle.com/java/17/latest/jdk-17_linux-x64_bin.rpm
+              rpm -Uvh jdk-17_linux-x64_bin.rpm
+              # NOTE: Set Java 11 as default.
+              update-alternatives --set java java-11-openjdk.x86_64
+              update-alternatives --set javac java-11-openjdk.x86_64
+          fi
+          continue
+        fi
         if [ "$pkg" == libipt ]; then
             if ! yum list installed libipt >/dev/null 2>/dev/null; then
                 yum install -y http://repo.okay.com.mx/centos/8/x86_64/release/libipt-1.6.1-8.el8.x86_64.rpm

environment/os/centos-7.sh

@@ -39,7 +39,7 @@ TOOLCHAIN_RUN_DEPS=(
 )
 
 MEMGRAPH_BUILD_DEPS=(
-    make pkgconfig # build system
+    make cmake pkgconfig # build system
     curl wget # for downloading libs
     libuuid-devel java-11-openjdk # required by antlr
     readline-devel # for memgraph console
@@ -56,9 +56,19 @@ MEMGRAPH_BUILD_DEPS=(
     sbcl # for custom Lisp C++ preprocessing
     rpm-build rpmlint # for RPM package building
     doxygen graphviz # source documentation generators
-    which mono-complete dotnet-sdk-3.1 golang nodejs zip unzip java-11-openjdk-devel # for driver tests
+    which mono-complete dotnet-sdk-3.1 golang custom-golang1.18.9 # for driver tests
+    nodejs zip unzip java-11-openjdk-devel jdk-17 custom-maven3.9.2 # for driver tests
     autoconf # for jemalloc code generation
     libtool  # for protobuf code generation
+    cyrus-sasl-devel
+)
+
+MEMGRAPH_RUN_DEPS=(
+    logrotate openssl python3 libseccomp
+)
+
+NEW_DEPS=(
+    wget curl tar gzip
 )
 
 list() {
@@ -68,6 +78,18 @@ list() {
 check() {
     local missing=""
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            if [ ! -f "/opt/apache-maven-3.9.2/bin/mvn" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            if [ ! -f "/opt/go1.18.9/go/bin/go" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
         if [ "$pkg" == git ]; then
             if ! which "git" >/dev/null; then
                 missing="git $missing"
@@ -110,7 +132,25 @@ install() {
     yum update -y
     yum install -y wget python3 python3-pip
     yum install -y git
+
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            install_custom_maven "3.9.2"
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            install_custom_golang "1.18.9"
+            continue
+        fi
+        if [ "$pkg" == jdk-17 ]; then
+            if ! yum list installed jdk-17 >/dev/null 2>/dev/null; then
+                wget https://download.oracle.com/java/17/latest/jdk-17_linux-x64_bin.rpm
+                rpm -ivh jdk-17_linux-x64_bin.rpm
+                update-alternatives --set java java-11-openjdk.x86_64
+                update-alternatives --set javac java-11-openjdk.x86_64
+            fi
+            continue
+        fi
         if [ "$pkg" == libipt ]; then
             if ! yum list installed libipt >/dev/null 2>/dev/null; then
                 yum install -y http://repo.okay.com.mx/centos/8/x86_64/release/libipt-1.6.1-8.el8.x86_64.rpm

environment/os/centos-9.sh

@@ -40,7 +40,7 @@ TOOLCHAIN_RUN_DEPS=(
 
 MEMGRAPH_BUILD_DEPS=(
     git # source code control
-    make pkgconf-pkg-config # build system
+    make cmake pkgconf-pkg-config # build system
     wget # for downloading libs
     libuuid-devel java-11-openjdk # required by antlr
     readline-devel # for memgraph console
@@ -56,10 +56,20 @@ MEMGRAPH_BUILD_DEPS=(
     libcurl-devel # mg-requests
     rpm-build rpmlint # for RPM package building
     doxygen graphviz # source documentation generators
-    which nodejs golang zip unzip java-11-openjdk-devel # for driver tests
+    which nodejs golang custom-golang1.18.9 # for driver tests
+    zip unzip java-11-openjdk-devel java-17-openjdk java-17-openjdk-devel custom-maven3.9.2 # for driver tests
     sbcl # for custom Lisp C++ preprocessing
     autoconf # for jemalloc code generation
     libtool  # for protobuf code generation
+    cyrus-sasl-devel
+)
+
+MEMGRAPH_RUN_DEPS=(
+    logrotate openssl python3 libseccomp
+)
+
+NEW_DEPS=(
+    wget curl tar gzip
 )
 
 list() {
@@ -69,6 +79,18 @@ list() {
 check() {
     local missing=""
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            if [ ! -f "/opt/apache-maven-3.9.2/bin/mvn" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            if [ ! -f "/opt/go1.18.9/go/bin/go" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
         if [ "$pkg" == "PyYAML" ]; then
             if ! python3 -c "import yaml" >/dev/null 2>/dev/null; then
                 missing="$pkg $missing"
@@ -103,7 +125,16 @@ install() {
     fi
     yum update -y
     yum install -y wget git python3 python3-pip
+
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            install_custom_maven "3.9.2"
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            install_custom_golang "1.18.9"
+            continue
+        fi
         # 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

environment/os/debian-10.sh

@@ -40,7 +40,7 @@ TOOLCHAIN_RUN_DEPS=(
 
 MEMGRAPH_BUILD_DEPS=(
     git # source code control
-    make pkg-config # build system
+    make cmake pkg-config # build system
     curl wget # for downloading libs
     uuid-dev default-jre-headless # required by antlr
     libreadline-dev # for memgraph console
@@ -53,10 +53,19 @@ MEMGRAPH_BUILD_DEPS=(
     libcurl4-openssl-dev # mg-requests
     sbcl # for custom Lisp C++ preprocessing
     doxygen graphviz # source documentation generators
-    mono-runtime mono-mcs zip unzip default-jdk-headless # for driver tests
-    dotnet-sdk-3.1 golang nodejs npm
+    mono-runtime mono-mcs zip unzip default-jdk-headless oracle-java17-installer custom-maven3.9.2 # for driver tests
+    dotnet-sdk-3.1 golang custom-golang1.18.9 nodejs npm # for driver tests
     autoconf # for jemalloc code generation
     libtool  # for protobuf code generation
+    libsasl2-dev
+)
+
+MEMGRAPH_RUN_DEPS=(
+    logrotate openssl python3 libseccomp
+)
+
+NEW_DEPS=(
+    wget curl tar gzip
 )
 
 list() {
@@ -64,7 +73,28 @@ list() {
 }
 
 check() {
-    check_all_dpkg "$1"
+    local missing=""
+    for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            if [ ! -f "/opt/apache-maven-3.9.2/bin/mvn" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            if [ ! -f "/opt/go1.18.9/go/bin/go" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if ! dpkg -s "$pkg" >/dev/null 2>/dev/null; then
+            missing="$pkg $missing"
+        fi
+    done
+    if [ "$missing" != "" ]; then
+        echo "MISSING PACKAGES: $missing"
+        exit 1
+    fi
 }
 
 install() {
@@ -75,8 +105,15 @@ deb http://deb.debian.org/debian/ buster-updates main contrib non-free
 deb-src http://deb.debian.org/debian/ buster-updates main contrib non-free
 deb http://security.debian.org/debian-security buster/updates main contrib non-free
 deb-src http://security.debian.org/debian-security buster/updates main contrib non-free
+EOF
+    apt --allow-releaseinfo-change update
+    cat >/etc/apt/sources.list.d/java.list << EOF
+deb http://ppa.launchpad.net/linuxuprising/java/ubuntu bionic main
+deb-src http://ppa.launchpad.net/linuxuprising/java/ubuntu bionic main
 EOF
     cd "$DIR"
+    apt install -y gnupg
+    apt-key adv --keyserver keyserver.ubuntu.com --recv-keys EA8CACC073C3DB2A
     apt --allow-releaseinfo-change update
     # If GitHub Actions runner is installed, append LANG to the environment.
     # Python related tests doesn't work the LANG export.
@@ -85,8 +122,26 @@ EOF
     else
         echo "NOTE: export LANG=en_US.utf8"
     fi
-    apt install -y wget
+
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            install_custom_maven "3.9.2"
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            install_custom_golang "1.18.9"
+            continue
+        fi
+        if [ "$pkg" == oracle-java17-installer ]; then
+            if ! dpkg -s "$pkg" 2>/dev/null >/dev/null; then
+              echo oracle-java17-installer shared/accepted-oracle-license-v1-3 select true | /usr/bin/debconf-set-selections
+              echo oracle-java17-installer shared/accepted-oracle-license-v1-3 seen true | /usr/bin/debconf-set-selections
+              apt install -y "$pkg"
+              update-alternatives --set java /usr/lib/jvm/java-11-openjdk-amd64/bin/java
+              update-alternatives --set javac /usr/lib/jvm/java-11-openjdk-amd64/bin/javac
+            fi
+            continue
+        fi
         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

environment/os/debian-11-arm.sh

@@ -54,10 +54,19 @@ MEMGRAPH_BUILD_DEPS=(
     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
-    golang nodejs npm
+    mono-runtime mono-mcs zip unzip default-jdk-headless openjdk-17-jdk custom-maven3.9.2 # for driver tests
+    golang custom-golang1.18.9 nodejs npm
     autoconf # for jemalloc code generation
     libtool  # for protobuf code generation
+    libsasl2-dev
+)
+
+MEMGRAPH_RUN_DEPS=(
+    logrotate openssl python3 libseccomp
+)
+
+NEW_DEPS=(
+    wget curl tar gzip
 )
 
 list() {
@@ -65,7 +74,28 @@ list() {
 }
 
 check() {
-    check_all_dpkg "$1"
+    local missing=""
+    for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            if [ ! -f "/opt/apache-maven-3.9.2/bin/mvn" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            if [ ! -f "/opt/go1.18.9/go/bin/go" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if ! dpkg -s "$pkg" >/dev/null 2>/dev/null; then
+            missing="$pkg $missing"
+        fi
+    done
+    if [ "$missing" != "" ]; then
+        echo "MISSING PACKAGES: $missing"
+        exit 1
+    fi
 }
 
 install() {
@@ -89,7 +119,25 @@ EOF
         echo "NOTE: export LANG=en_US.utf8"
     fi
     apt install -y wget
+
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            install_custom_maven "3.9.2"
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            install_custom_golang "1.18.9"
+            continue
+        fi
+        if [ "$pkg" == openjdk-17-jdk ]; then
+            if ! dpkg -s "$pkg" 2>/dev/null >/dev/null; then
+                apt install -y "$pkg"
+                # The default Java version should be Java 11
+                update-alternatives --set java /usr/lib/jvm/java-11-openjdk-arm64/bin/java
+                update-alternatives --set javac /usr/lib/jvm/java-11-openjdk-arm64/bin/javac
+            fi
+            continue
+        fi
         apt install -y "$pkg"
     done
 }

environment/os/debian-11.sh

@@ -41,7 +41,7 @@ TOOLCHAIN_RUN_DEPS=(
 
 MEMGRAPH_BUILD_DEPS=(
     git # source code control
-    make pkg-config # build system
+    make cmake pkg-config # build system
     curl wget # for downloading libs
     uuid-dev default-jre-headless # required by antlr
     libreadline-dev # for memgraph console
@@ -54,10 +54,19 @@ MEMGRAPH_BUILD_DEPS=(
     libcurl4-openssl-dev # mg-requests
     sbcl # for custom Lisp C++ preprocessing
     doxygen graphviz # source documentation generators
-    mono-runtime mono-mcs zip unzip default-jdk-headless # for driver tests
-    dotnet-sdk-3.1 golang nodejs npm
+    mono-runtime mono-mcs zip unzip default-jdk-headless openjdk-17-jdk custom-maven3.9.2 # for driver tests
+    dotnet-sdk-3.1 golang custom-golang1.18.9 nodejs npm
     autoconf # for jemalloc code generation
     libtool  # for protobuf code generation
+    libsasl2-dev
+)
+
+MEMGRAPH_RUN_DEPS=(
+    logrotate openssl python3 libseccomp
+)
+
+NEW_DEPS=(
+    wget curl tar gzip
 )
 
 list() {
@@ -65,7 +74,28 @@ list() {
 }
 
 check() {
-    check_all_dpkg "$1"
+    local missing=""
+    for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            if [ ! -f "/opt/apache-maven-3.9.2/bin/mvn" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            if [ ! -f "/opt/go1.18.9/go/bin/go" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if ! dpkg -s "$pkg" >/dev/null 2>/dev/null; then
+            missing="$pkg $missing"
+        fi
+    done
+    if [ "$missing" != "" ]; then
+        echo "MISSING PACKAGES: $missing"
+        exit 1
+    fi
 }
 
 install() {
@@ -89,7 +119,25 @@ EOF
         echo "NOTE: export LANG=en_US.utf8"
     fi
     apt install -y wget
+
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            install_custom_maven "3.9.2"
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            install_custom_golang "1.18.9"
+            continue
+        fi
+        if [ "$pkg" == openjdk-17-jdk ]; then
+            if ! dpkg -s "$pkg" 2>/dev/null >/dev/null; then
+                apt install -y "$pkg"
+                # The default Java version should be Java 11
+                update-alternatives --set java /usr/lib/jvm/java-11-openjdk-amd64/bin/java
+                update-alternatives --set javac /usr/lib/jvm/java-11-openjdk-amd64/bin/javac
+            fi
+            continue
+        fi
         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

environment/os/fedora-36.sh

@@ -41,7 +41,7 @@ TOOLCHAIN_RUN_DEPS=(
 
 MEMGRAPH_BUILD_DEPS=(
     git # source code control
-    make pkgconf-pkg-config # build system
+    make cmake pkgconf-pkg-config # build system
     wget # for downloading libs
     libuuid-devel java-11-openjdk # required by antlr
     readline-devel # for memgraph console
@@ -52,10 +52,21 @@ MEMGRAPH_BUILD_DEPS=(
     libcurl-devel # mg-requests
     rpm-build rpmlint # for RPM package building
     doxygen graphviz # source documentation generators
-    which nodejs golang zip unzip java-11-openjdk-devel # for driver tests
+    java-11-openjdk-devel java-17-openjdk-devel custom-maven3.9.2 # for driver tests
+    which zip unzip
+    nodejs golang custom-golang1.18.9 # for driver tests
     sbcl # for custom Lisp C++ preprocessing
     autoconf # for jemalloc code generation
     libtool  # for protobuf code generation
+    cyrus-sasl-devel
+)
+
+MEMGRAPH_RUN_DEPS=(
+    logrotate openssl python3 libseccomp
+)
+
+NEW_DEPS=(
+    wget curl tar gzip
 )
 
 list() {
@@ -64,11 +75,25 @@ list() {
 
 check() {
     local missing=""
-    # On Fedora yum/dnf and python10 use newer glibc which is not compatible
-    # with ours, so we need to momentarely disable env
-    local OLD_LD_LIBRARY_PATH=${LD_LIBRARY_PATH}
-    LD_LIBRARY_PATH=""
+    if [ -v LD_LIBRARY_PATH ]; then
+        # On Fedora yum/dnf and python10 use newer glibc which is not compatible
+        # with ours, so we need to momentarely disable env
+        local OLD_LD_LIBRARY_PATH=${LD_LIBRARY_PATH}
+        LD_LIBRARY_PATH=""
+    fi
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            if [ ! -f "/opt/apache-maven-3.9.2/bin/mvn" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            if [ ! -f "/opt/go1.18.9/go/bin/go" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
         if ! dnf list installed "$pkg" >/dev/null 2>/dev/null; then
             missing="$pkg $missing"
         fi
@@ -77,7 +102,10 @@ check() {
         echo "MISSING PACKAGES: $missing"
         exit 1
     fi
-    LD_LIBRARY_PATH=${OLD_LD_LIBRARY_PATH}
+    if [ -v OLD_LD_LIBRARY_PATH ]; then
+        echo "Restoring LD_LIBRARY_PATH..."
+        LD_LIBRARY_PATH=${OLD_LD_LIBRARY_PATH}
+    fi
 }
 
 install() {
@@ -94,7 +122,25 @@ install() {
         echo "NOTE: export LANG=en_US.utf8"
     fi
     dnf update -y
+
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            install_custom_maven "3.9.2"
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            install_custom_golang "1.18.9"
+            continue
+        fi
+        if [ "$pkg" == java-17-openjdk-devel ]; then
+            if ! dnf list installed "$pkg" >/dev/null 2>/dev/null; then
+                dnf install -y "$pkg"
+                # The default Java version should be Java 11
+                update-alternatives --set java java-11-openjdk.x86_64
+                update-alternatives --set javac java-11-openjdk.x86_64
+            fi
+            continue
+        fi
         dnf install -y "$pkg"
     done
 }

environment/os/run.sh

@@ -0,0 +1,145 @@
+#!/bin/bash
+set -Eeuo pipefail
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+IFS=' '
+# NOTE: docker_image_name could be local image build based on release/package images.
+# NOTE: each line has to be under quotes, docker_container_type, script_name and docker_image_name separate with a space.
+# "docker_container_type script_name docker_image_name"
+OPERATING_SYSTEMS=(
+  "mgrun amzn-2 amazonlinux:2"
+  "mgrun centos-7 centos:7"
+  "mgrun centos-9 dokken/centos-stream-9"
+  "mgrun debian-10 debian:10"
+  "mgrun debian-11 debian:11"
+  "mgrun fedora-36 fedora:36"
+  "mgrun ubuntu-18.04 ubuntu:18.04"
+  "mgrun ubuntu-20.04 ubuntu:20.04"
+  "mgrun ubuntu-22.04 ubuntu:22.04"
+  # "mgbuild centos-7 package-mgbuild_centos-7"
+)
+
+if [ ! "$(docker info)" ]; then
+  echo "ERROR: Docker is required"
+  exit 1
+fi
+print_help () {
+  echo -e "$0 all\t\t\t\t  => start + init all containers in the background"
+  echo -e "$0 check\t\t\t\t  => check all containers"
+  echo -e "$0 delete\t\t\t\t  => stop + remove all containers"
+  echo -e "$0 copy src_container dst_container => copy build package from src to dst container"
+  exit 1
+}
+
+# NOTE: This is an idempotent operation!
+# TODO(gitbuda): Consider making docker_run always delete + start a new container or add a new function.
+docker_run () {
+  cnt_name="$1"
+  cnt_image="$2"
+  if [ ! "$(docker ps -q -f name=$cnt_name)" ]; then
+      if [ "$(docker ps -aq -f status=exited -f name=$cnt_name)" ]; then
+          echo "Cleanup of the old exited container..."
+          docker rm $cnt_name
+      fi
+      docker run -d --volume "$SCRIPT_DIR/../../:/memgraph" --network host --name "$cnt_name" "$cnt_image" sleep infinity
+  fi
+  echo "The $cnt_image container is active under $cnt_name name!"
+}
+
+docker_exec () {
+  cnt_name="$1"
+  cnt_cmd="$2"
+  docker exec -it "$cnt_name" bash -c "$cnt_cmd"
+}
+
+docker_stop_and_rm () {
+  cnt_name="$1"
+  if [ "$(docker ps -q -f name=$cnt_name)" ]; then
+      docker stop "$1"
+      if [ "$(docker ps -aq -f status=exited -f name=$cnt_name)" ]; then
+        docker rm "$1"
+      fi
+  fi
+}
+
+# TODO(gitbuda): Make the call to `install NEW_DEPS` configurable, the question what else is useful?
+start_all () {
+  for script_docker_pair in "${OPERATING_SYSTEMS[@]}"; do
+    read -a script_docker <<< "$script_docker_pair"
+    docker_container_type="${script_docker[0]}"
+    script_name="${script_docker[1]}"
+    docker_image="${script_docker[2]}"
+    docker_name="${docker_container_type}_$script_name"
+    echo ""
+    echo "~~~~ OPERATING ON $docker_image as $docker_name..."
+    docker_run "$docker_name" "$docker_image"
+    docker_exec "$docker_name" "/memgraph/environment/os/$script_name.sh install NEW_DEPS"
+    echo "---- DONE EVERYHING FOR $docker_image as $docker_name..."
+    echo ""
+  done
+}
+
+check_all () {
+  for script_docker_pair in "${OPERATING_SYSTEMS[@]}"; do
+    read -a script_docker <<< "$script_docker_pair"
+    docker_container_type="${script_docker[0]}"
+    script_name="${script_docker[1]}"
+    docker_image="${script_docker[2]}"
+    docker_name="${docker_container_type}_$script_name"
+    echo ""
+    echo "~~~~ OPERATING ON $docker_image as $docker_name..."
+    docker_exec "$docker_name" "/memgraph/environment/os/$script_name.sh check NEW_DEPS"
+    echo "---- DONE EVERYHING FOR $docker_image as $docker_name..."
+    echo ""
+  done
+}
+
+delete_all () {
+  for script_docker_pair in "${OPERATING_SYSTEMS[@]}"; do
+    read -a script_docker <<< "$script_docker_pair"
+    docker_container_type="${script_docker[0]}"
+    script_name="${script_docker[1]}"
+    docker_image="${script_docker[2]}"
+    docker_name="${docker_container_type}_$script_name"
+    docker_stop_and_rm "$docker_name"
+    echo "~~~~ $docker_image as $docker_name DELETED"
+  done
+}
+
+# TODO(gitbuda): Copy file between containers is a useful util, also delete, + consider copying of a whole folder.
+# TODO(gitbuda): Add args: src_cnt dst_cnt abs_path; both file and recursive folder, always delete + copy.
+copy_build_package () {
+  src_container="$1"
+  dst_container="$2"
+  src="$src_container:/memgraph/build/output"
+  tmp_dst="$SCRIPT_DIR/../../build"
+  mkdir -p "$tmp_dst"
+  rm -rf "$tmp_dst/output"
+  dst="$dst_container:/"
+  docker cp "$src" "$tmp_dst"
+  docker cp "$tmp_dst/output" "$dst"
+}
+
+if [ "$#" -eq 0 ]; then
+  print_help
+else
+  case $1 in
+    all)
+      start_all
+    ;;
+    check)
+      check_all
+    ;;
+    delete)
+      delete_all
+    ;;
+    copy) # src_container dst_container
+      if [ "$#" -ne 3 ]; then
+        print_help
+      fi
+      copy_build_package "$2" "$3"
+    ;;
+    *)
+      print_help
+    ;;
+  esac
+fi

environment/os/template.sh

@@ -6,6 +6,7 @@ DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 source "$DIR/../util.sh"
 
 check_operating_system "todo-os-name"
+check_architecture "todo-arch-name"
 
 TOOLCHAIN_BUILD_DEPS=(
     pkg
@@ -19,6 +20,16 @@ MEMGRAPH_BUILD_DEPS=(
     pkg
 )
 
+MEMGRAPH_RUN_DEPS=(
+    pkg
+)
+
+# NEW_DEPS is useful when you won't to test the installation of a new package.
+# During the test you can put here packages like wget curl tar gzip
+NEW_DEPS=(
+  pkg
+)
+
 list() {
     echo "$1"
 }

environment/os/ubuntu-18.04.sh

@@ -41,7 +41,7 @@ TOOLCHAIN_RUN_DEPS=(
 
 MEMGRAPH_BUILD_DEPS=(
     git # source code control
-    make pkg-config # build system
+    make cmake pkg-config # build system
     curl wget # downloading libs
     uuid-dev default-jre-headless # required by antlr
     libreadline-dev # memgraph console
@@ -53,9 +53,19 @@ MEMGRAPH_BUILD_DEPS=(
     libcurl4-openssl-dev # mg-requests
     sbcl # custom Lisp C++ preprocessing
     doxygen graphviz # source documentation generators
-    mono-runtime mono-mcs nodejs zip unzip default-jdk-headless # driver tests
+    mono-runtime mono-mcs nodejs zip unzip default-jdk-headless openjdk-17-jdk-headless custom-maven3.9.2 # driver tests
+    custom-golang1.18.9 # for driver tests
     autoconf # for jemalloc code generation
     libtool  # for protobuf code generation
+    libsasl2-dev
+)
+
+MEMGRAPH_RUN_DEPS=(
+    logrotate openssl python3 libseccomp2
+)
+
+NEW_DEPS=(
+    wget curl tar gzip
 )
 
 list() {
@@ -63,11 +73,53 @@ list() {
 }
 
 check() {
-    check_all_dpkg "$1"
+    local missing=""
+    for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            if [ ! -f "/opt/apache-maven-3.9.2/bin/mvn" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            if [ ! -f "/opt/go1.18.9/go/bin/go" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if ! dpkg -s "$pkg" >/dev/null 2>/dev/null; then
+            missing="$pkg $missing"
+        fi
+    done
+    if [ "$missing" != "" ]; then
+        echo "MISSING PACKAGES: $missing"
+        exit 1
+    fi
 }
 
 install() {
-    apt install -y $1
+    apt update -y
+
+    for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            install_custom_maven "3.9.2"
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            install_custom_golang "1.18.9"
+            continue
+        fi
+        if [ "$pkg" == openjdk-17-jdk-headless ]; then
+            if ! dpkg -s "$pkg" 2>/dev/null >/dev/null; then
+                apt install -y "$pkg"
+                # The default Java version should be Java 11
+                update-alternatives --set java /usr/lib/jvm/java-11-openjdk-amd64/bin/java
+                update-alternatives --set javac /usr/lib/jvm/java-11-openjdk-amd64/bin/javac
+            fi
+            continue
+        fi
+        apt install -y "$pkg"
+    done
 }
 
 deps=$2"[*]"

environment/os/ubuntu-20.04.sh

@@ -40,7 +40,7 @@ TOOLCHAIN_RUN_DEPS=(
 
 MEMGRAPH_BUILD_DEPS=(
     git # source code control
-    make pkg-config # build system
+    make cmake pkg-config # build system
     curl wget # for downloading libs
     uuid-dev default-jre-headless # required by antlr
     libreadline-dev # for memgraph console
@@ -53,10 +53,19 @@ MEMGRAPH_BUILD_DEPS=(
     libcurl4-openssl-dev # mg-requests
     sbcl # for custom Lisp C++ preprocessing
     doxygen graphviz # source documentation generators
-    mono-runtime mono-mcs zip unzip default-jdk-headless # for driver tests
-    dotnet-sdk-3.1 golang nodejs npm
+    mono-runtime mono-mcs zip unzip default-jdk-headless openjdk-17-jdk-headless custom-maven3.9.2 # for driver tests
+    dotnet-sdk-3.1 golang custom-golang1.18.9 nodejs npm # for driver tests
     autoconf # for jemalloc code generation
     libtool  # for protobuf code generation
+    libsasl2-dev
+)
+
+MEMGRAPH_RUN_DEPS=(
+    logrotate openssl python3 libseccomp2
+)
+
+NEW_DEPS=(
+    wget curl tar gzip
 )
 
 list() {
@@ -64,12 +73,35 @@ list() {
 }
 
 check() {
-    check_all_dpkg "$1"
+    local missing=""
+    for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            if [ ! -f "/opt/apache-maven-3.9.2/bin/mvn" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            if [ ! -f "/opt/go1.18.9/go/bin/go" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if ! dpkg -s "$pkg" >/dev/null 2>/dev/null; then
+            missing="$pkg $missing"
+        fi
+    done
+    if [ "$missing" != "" ]; then
+        echo "MISSING PACKAGES: $missing"
+        exit 1
+    fi
 }
 
 install() {
     cd "$DIR"
-    apt update
+    export DEBIAN_FRONTEND=noninteractive
+    apt update -y
+    apt install -y wget
     # 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
@@ -77,8 +109,16 @@ install() {
     else
         echo "NOTE: export LANG=en_US.utf8"
     fi
-    apt install -y wget
+
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            install_custom_maven "3.9.2"
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            install_custom_golang "1.18.9"
+            continue
+        fi
         if [ "$pkg" == dotnet-sdk-3.1 ]; then
             if ! dpkg -s dotnet-sdk-3.1 2>/dev/null >/dev/null; then
                 wget -nv https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
@@ -88,6 +128,15 @@ install() {
             fi
             continue
         fi
+        if [ "$pkg" == openjdk-17-jdk-headless ]; then
+            if ! dpkg -s "$pkg" 2>/dev/null >/dev/null; then
+                apt install -y "$pkg"
+                # The default Java version should be Java 11
+                update-alternatives --set java /usr/lib/jvm/java-11-openjdk-amd64/bin/java
+                update-alternatives --set javac /usr/lib/jvm/java-11-openjdk-amd64/bin/javac
+            fi
+            continue
+        fi
         apt install -y "$pkg"
     done
 }

environment/os/ubuntu-22.04-arm.sh

@@ -40,7 +40,7 @@ TOOLCHAIN_RUN_DEPS=(
 
 MEMGRAPH_BUILD_DEPS=(
     git # source code control
-    make pkg-config # build system
+    make cmake pkg-config # build system
     curl wget # for downloading libs
     uuid-dev default-jre-headless # required by antlr
     libreadline-dev # for memgraph console
@@ -53,10 +53,19 @@ MEMGRAPH_BUILD_DEPS=(
     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
+    mono-runtime mono-mcs zip unzip default-jdk-headless openjdk-17-jdk-headless custom-maven3.9.2 # for driver tests
+    dotnet-sdk-6.0 golang custom-golang1.18.9 nodejs npm
     autoconf # for jemalloc code generation
     libtool  # for protobuf code generation
+    libsasl2-dev
+)
+
+MEMGRAPH_RUN_DEPS=(
+    logrotate openssl python3 libseccomp2
+)
+
+NEW_DEPS=(
+    wget curl tar gzip
 )
 
 list() {
@@ -64,7 +73,28 @@ list() {
 }
 
 check() {
-    check_all_dpkg "$1"
+    local missing=""
+    for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            if [ ! -f "/opt/apache-maven-3.9.2/bin/mvn" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            if [ ! -f "/opt/go1.18.9/go/bin/go" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if ! dpkg -s "$pkg" >/dev/null 2>/dev/null; then
+            missing="$pkg $missing"
+        fi
+    done
+    if [ "$missing" != "" ]; then
+        echo "MISSING PACKAGES: $missing"
+        exit 1
+    fi
 }
 
 install() {
@@ -78,7 +108,16 @@ install() {
         echo "NOTE: export LANG=en_US.utf8"
     fi
     apt install -y wget
+
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            install_custom_maven "3.9.2"
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            install_custom_golang "1.18.9"
+            continue
+        fi
         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
@@ -88,6 +127,15 @@ install() {
             fi
             continue
         fi
+        if [ "$pkg" == openjdk-17-jdk-headless ]; then
+            if ! dpkg -s "$pkg" 2>/dev/null >/dev/null; then
+                apt install -y "$pkg"
+                # The default Java version should be Java 11
+                update-alternatives --set java /usr/lib/jvm/java-11-openjdk-arm64/bin/java
+                update-alternatives --set javac /usr/lib/jvm/java-11-openjdk-arm64/bin/javac
+            fi
+            continue
+        fi
         apt install -y "$pkg"
     done
 }

environment/os/ubuntu-22.04.sh

@@ -40,7 +40,7 @@ TOOLCHAIN_RUN_DEPS=(
 
 MEMGRAPH_BUILD_DEPS=(
     git # source code control
-    make pkg-config # build system
+    make cmake pkg-config # build system
     curl wget # for downloading libs
     uuid-dev default-jre-headless # required by antlr
     libreadline-dev # for memgraph console
@@ -53,10 +53,19 @@ MEMGRAPH_BUILD_DEPS=(
     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
+    mono-runtime mono-mcs zip unzip default-jdk-headless openjdk-17-jdk-headless custom-maven3.9.2 # for driver tests
+    dotnet-sdk-6.0 golang custom-golang1.18.9 nodejs npm # for driver tests
     autoconf # for jemalloc code generation
     libtool  # for protobuf code generation
+    libsasl2-dev
+)
+
+MEMGRAPH_RUN_DEPS=(
+    logrotate openssl python3 libseccomp2
+)
+
+NEW_DEPS=(
+    wget curl tar gzip
 )
 
 list() {
@@ -64,12 +73,34 @@ list() {
 }
 
 check() {
-    check_all_dpkg "$1"
+    local missing=""
+    for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            if [ ! -f "/opt/apache-maven-3.9.2/bin/mvn" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            if [ ! -f "/opt/go1.18.9/go/bin/go" ]; then
+              missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if ! dpkg -s "$pkg" >/dev/null 2>/dev/null; then
+            missing="$pkg $missing"
+        fi
+    done
+    if [ "$missing" != "" ]; then
+        echo "MISSING PACKAGES: $missing"
+        exit 1
+    fi
 }
 
 install() {
     cd "$DIR"
-    apt update
+    apt update -y
+    apt install -y wget
     # 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
@@ -77,8 +108,16 @@ install() {
     else
         echo "NOTE: export LANG=en_US.utf8"
     fi
-    apt install -y wget
+
     for pkg in $1; do
+        if [ "$pkg" == custom-maven3.9.2 ]; then
+            install_custom_maven "3.9.2"
+            continue
+        fi
+        if [ "$pkg" == custom-golang1.18.9 ]; then
+            install_custom_golang "1.18.9"
+            continue
+        fi
         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
@@ -88,6 +127,15 @@ install() {
             fi
             continue
         fi
+        if [ "$pkg" == openjdk-17-jdk-headless ]; then
+            if ! dpkg -s "$pkg" 2>/dev/null >/dev/null; then
+                apt install -y "$pkg"
+                # The default Java version should be Java 11
+                update-alternatives --set java /usr/lib/jvm/java-11-openjdk-amd64/bin/java
+                update-alternatives --set javac /usr/lib/jvm/java-11-openjdk-amd64/bin/javac
+            fi
+            continue
+        fi
         apt install -y "$pkg"
     done
 }

environment/util.sh

@@ -76,3 +76,26 @@ function install_all_apt() {
         apt install -y "$pkg"
     done
 }
+
+function install_custom_golang() {
+    # NOTE: The official https://go.dev/doc/manage-install doesn't seem to be working.
+    GOVERSION="$1"
+    GOINSTALLDIR="/opt/go$GOVERSION"
+    GOROOT="$GOINSTALLDIR/go" # GOPATH=$HOME/go
+    if [ ! -f "$GOROOT/bin/go" ]; then
+      curl -LO https://go.dev/dl/go$GOVERSION.linux-amd64.tar.gz
+      mkdir -p "$GOINSTALLDIR"
+      tar -C "$GOINSTALLDIR" -xzf go$GOVERSION.linux-amd64.tar.gz
+    fi
+    echo "go $GOVERSION installed under $GOROOT"
+}
+
+function install_custom_maven() {
+  MVNVERSION="$1"
+  MVNINSTALLDIR="/opt/apache-maven-$MVNVERSION"
+  if [ ! -f "$MVNINSTALLDIR/bin/mvn" ]; then
+    curl -LO "https://dlcdn.apache.org/maven/maven-3/$MVNVERSION/binaries/apache-maven-$MVNVERSION-bin.tar.gz"
+    tar -C "/opt" -xzf "apache-maven-$MVNVERSION-bin.tar.gz"
+  fi
+  echo "maven $MVNVERSION installed under $MVNINSTALLDIR"
+}

import/mglogs2cypherl.sh

@@ -0,0 +1,26 @@
+#!/bin/bash -e
+COLOR_ORANGE="\e[38;5;208m"
+COLOR_GREEN="\e[38;5;35m"
+COLOR_RED="\e[0;31m"
+COLOR_NULL="\e[0m"
+
+print_help() {
+    echo -e "${COLOR_ORANGE}HOW TO RUN:${COLOR_NULL} $0 memgraph_logs_file_path cypherl_output_path"
+    exit 1
+}
+
+if [ "$#" -ne 2 ]; then
+    print_help
+fi
+INPUT="$1"
+OUTPUT="$2"
+if [ ! -f "$INPUT" ]; then
+    echo -e "${COLOR_RED}ERROR:${COLOR_NULL} memgraph_logs_file_path is not a file!"
+    print_help
+fi
+
+awk -v RS="Run] '" 'NR>1 { print $0 }' < "$INPUT" | sed -e "/^\[/d;" -e "s/'\([^']*\)$/;/g" > "$OUTPUT"
+
+echo -e "${COLOR_GREEN}DONE!${COLOR_NULL} Please find Memgraph compatible cypherl file under $OUTPUT"
+echo ""
+echo "Import can be done by executing => \`cat $OUTPUT | mgconsole\`"

import/n2mg_cypherl.sh

@@ -0,0 +1,35 @@
+#!/bin/bash -e
+COLOR_ORANGE="\e[38;5;208m"
+COLOR_GREEN="\e[38;5;35m"
+COLOR_RED="\e[0;31m"
+COLOR_NULL="\e[0m"
+
+print_help() {
+    echo -e "${COLOR_ORANGE}HOW TO RUN:${COLOR_NULL} $0 input_file_path output_file_path"
+    exit 1
+}
+
+if [ "$#" -ne 2 ]; then
+    print_help
+fi
+INPUT="$1"
+OUTPUT="$2"
+if [ ! -f "$INPUT" ]; then
+    echo -e "${COLOR_RED}ERROR:${COLOR_NULL} input_file_path is not a file!"
+    print_help
+fi
+
+echo -e "${COLOR_ORANGE}NOTE:${COLOR_NULL} BEGIN and COMMIT are required because variables share the same name (e.g. row)"
+echo -e "${COLOR_ORANGE}NOTE:${COLOR_NULL} CONSTRAINTS are just skipped -> ${COLOR_RED}please create consraints manually if needed${COLOR_NULL}"
+
+sed -e 's/^:begin/BEGIN/g; s/^BEGIN$/BEGIN;/g;' \
+    -e 's/^:commit/COMMIT/g; s/^COMMIT$/COMMIT;/g;' \
+    -e '/^CALL/d; /^SCHEMA AWAIT/d;' \
+    -e 's/CREATE RANGE INDEX FOR (n:/CREATE INDEX ON :/g;' \
+    -e 's/) ON (n./(/g;' \
+    -e '/^CREATE CONSTRAINT/d; /^DROP CONSTRAINT/d;' "$INPUT" > "$OUTPUT"
+
+echo ""
+echo -e "${COLOR_GREEN}DONE!${COLOR_NULL} Please find Memgraph compatible cypherl|.cypher file under $OUTPUT"
+echo ""
+echo "Please import data by executing => \`cat $OUTPUT | mgconsole\`"

include/_mgp.hpp

@@ -677,6 +677,16 @@ inline mgp_proc *module_add_write_procedure(mgp_module *module, const char *name
   return MgInvoke<mgp_proc *>(mgp_module_add_write_procedure, module, name, cb);
 }
 
+inline mgp_proc *module_add_batch_read_procedure(mgp_module *module, const char *name, mgp_proc_cb cb,
+                                                 mgp_proc_initializer initializer, mgp_proc_cleanup cleanup) {
+  return MgInvoke<mgp_proc *>(mgp_module_add_batch_read_procedure, module, name, cb, initializer, cleanup);
+}
+
+inline mgp_proc *module_add_batch_write_procedure(mgp_module *module, const char *name, mgp_proc_cb cb,
+                                                  mgp_proc_initializer initializer, mgp_proc_cleanup cleanup) {
+  return MgInvoke<mgp_proc *>(mgp_module_add_batch_write_procedure, module, name, cb, initializer, cleanup);
+}
+
 inline void proc_add_arg(mgp_proc *proc, const char *name, mgp_type *type) {
   MgInvokeVoid(mgp_proc_add_arg, proc, name, type);
 }

include/mg_procedure.h

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -1318,6 +1318,13 @@ MGP_ENUM_CLASS mgp_log_level{
 /// to allocate global resources.
 typedef void (*mgp_proc_cb)(struct mgp_list *, struct mgp_graph *, struct mgp_result *, struct mgp_memory *);
 
+/// Cleanup for a query module read procedure. Can't be invoked through OpenCypher. Cleans batched stream.
+typedef void (*mgp_proc_cleanup)();
+
+/// Initializer for a query module batched read procedure. Can't be invoked through OpenCypher. Initializes batched
+/// stream.
+typedef void (*mgp_proc_initializer)(struct mgp_list *, struct mgp_graph *, struct mgp_memory *);
+
 /// Register a read-only procedure to a module.
 ///
 /// The `name` must be a sequence of digits, underscores, lowercase and
@@ -1342,6 +1349,30 @@ enum mgp_error mgp_module_add_read_procedure(struct mgp_module *module, const ch
 enum mgp_error mgp_module_add_write_procedure(struct mgp_module *module, const char *name, mgp_proc_cb cb,
                                               struct mgp_proc **result);
 
+/// Register a readable batched procedure to a module.
+///
+/// The `name` must be a valid identifier, following the same rules as the
+/// procedure`name` in mgp_module_add_read_procedure.
+///
+/// Return mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE if unable to allocate memory for mgp_proc.
+/// Return mgp_error::MGP_ERROR_INVALID_ARGUMENT if `name` is not a valid procedure name.
+/// RETURN mgp_error::MGP_ERROR_LOGIC_ERROR if a procedure with the same name was already registered.
+enum mgp_error mgp_module_add_batch_read_procedure(struct mgp_module *module, const char *name, mgp_proc_cb cb,
+                                                   mgp_proc_initializer initializer, mgp_proc_cleanup cleanup,
+                                                   struct mgp_proc **result);
+
+/// Register a writeable batched procedure to a module.
+///
+/// The `name` must be a valid identifier, following the same rules as the
+/// procedure`name` in mgp_module_add_read_procedure.
+///
+/// Return mgp_error::MGP_ERROR_UNABLE_TO_ALLOCATE if unable to allocate memory for mgp_proc.
+/// Return mgp_error::MGP_ERROR_INVALID_ARGUMENT if `name` is not a valid procedure name.
+/// RETURN mgp_error::MGP_ERROR_LOGIC_ERROR if a procedure with the same name was already registered.
+enum mgp_error mgp_module_add_batch_write_procedure(struct mgp_module *module, const char *name, mgp_proc_cb cb,
+                                                    mgp_proc_initializer initializer, mgp_proc_cleanup cleanup,
+                                                    struct mgp_proc **result);
+
 /// Add a required argument to a procedure.
 ///
 /// The order of adding arguments will correspond to the order the procedure

include/mgp.hpp

@@ -946,6 +946,7 @@ class Duration {
 /* #region Value */
 enum class Type : uint8_t {
   Null,
+  Any,
   Bool,
   Int,
   Double,
@@ -1318,6 +1319,20 @@ inline void AddProcedure(mgp_proc_cb callback, std::string_view name, ProcedureT
                          std::vector<Parameter> parameters, std::vector<Return> returns, mgp_module *module,
                          mgp_memory *memory);
 
+/// @brief Adds a batch procedure to the query module.
+/// @param callback - procedure callback
+/// @param initializer - procedure initializer
+/// @param cleanup - procedure cleanup
+/// @param name - procedure name
+/// @param proc_type - procedure type (read/write)
+/// @param parameters - procedure parameters
+/// @param returns - procedure return values
+/// @param module - the query module that the procedure is added to
+/// @param memory - access to memory
+inline void AddBatchProcedure(mgp_proc_cb callback, mgp_proc_initializer initializer, mgp_proc_cleanup cleanup,
+                              std::string_view name, ProcedureType proc_type, std::vector<Parameter> parameters,
+                              std::vector<Return> returns, mgp_module *module, mgp_memory *memory);
+
 /// @brief Adds a function to the query module.
 /// @param callback - function callback
 /// @param name - function name
@@ -1491,6 +1506,8 @@ inline bool ValuesEqual(mgp_value *value1, mgp_value *value2) {
 /// @brief Converts C++ API types to their MGP API equivalents.
 inline mgp_type *ToMGPType(Type type) {
   switch (type) {
+    case Type::Any:
+      return mgp::type_any();
     case Type::Bool:
       return mgp::type_bool();
     case Type::Int:
@@ -2201,7 +2218,14 @@ inline bool Map::Empty() const { return Size() == 0; }
 
 inline const Value Map::operator[](std::string_view key) const { return Value(mgp::map_at(ptr_, key.data())); }
 
-inline const Value Map::At(std::string_view key) const { return Value(mgp::map_at(ptr_, key.data())); }
+inline const Value Map::At(std::string_view key) const {
+  auto *ptr = mgp::map_at(ptr_, key.data());
+  if (ptr) {
+    return Value(ptr);
+  }
+
+  return Value();
+}
 
 inline Map::Iterator::Iterator(mgp_map_items_iterator *map_items_iterator) : map_items_iterator_(map_items_iterator) {
   if (map_items_iterator_ == nullptr) return;
@@ -3427,14 +3451,12 @@ inline mgp_type *Return::GetMGPType() const {
   return util::ToMGPType(type_);
 }
 
-void AddProcedure(mgp_proc_cb callback, std::string_view name, ProcedureType proc_type,
-                  std::vector<Parameter> parameters, std::vector<Return> returns, mgp_module *module,
-                  mgp_memory *memory) {
-  auto proc = (proc_type == ProcedureType::Read) ? mgp::module_add_read_procedure(module, name.data(), callback)
-                                                 : mgp::module_add_write_procedure(module, name.data(), callback);
-
+// do not enter
+namespace detail {
+inline void AddParamsReturnsToProc(mgp_proc *proc, std::vector<Parameter> &parameters,
+                                   const std::vector<Return> &returns) {
   for (const auto &parameter : parameters) {
-    auto parameter_name = parameter.name.data();
+    const auto *parameter_name = parameter.name.data();
     if (!parameter.optional) {
       mgp::proc_add_arg(proc, parameter_name, parameter.GetMGPType());
     } else {
@@ -3443,18 +3465,35 @@ void AddProcedure(mgp_proc_cb callback, std::string_view name, ProcedureType pro
   }
 
   for (const auto return_ : returns) {
-    auto return_name = return_.name.data();
-
+    const auto *return_name = return_.name.data();
     mgp::proc_add_result(proc, return_name, return_.GetMGPType());
   }
 }
+}  // namespace detail
+
+void AddProcedure(mgp_proc_cb callback, std::string_view name, ProcedureType proc_type,
+                  std::vector<Parameter> parameters, std::vector<Return> returns, mgp_module *module,
+                  mgp_memory *memory) {
+  auto *proc = (proc_type == ProcedureType::Read) ? mgp::module_add_read_procedure(module, name.data(), callback)
+                                                  : mgp::module_add_write_procedure(module, name.data(), callback);
+  detail::AddParamsReturnsToProc(proc, parameters, returns);
+}
+
+void AddBatchProcedure(mgp_proc_cb callback, mgp_proc_initializer initializer, mgp_proc_cleanup cleanup,
+                       std::string_view name, ProcedureType proc_type, std::vector<Parameter> parameters,
+                       std::vector<Return> returns, mgp_module *module, mgp_memory *memory) {
+  auto *proc = (proc_type == ProcedureType::Read)
+                   ? mgp::module_add_batch_read_procedure(module, name.data(), callback, initializer, cleanup)
+                   : mgp::module_add_batch_write_procedure(module, name.data(), callback, initializer, cleanup);
+  detail::AddParamsReturnsToProc(proc, parameters, returns);
+}
 
 void AddFunction(mgp_func_cb callback, std::string_view name, std::vector<Parameter> parameters, mgp_module *module,
                  mgp_memory *memory) {
-  auto func = mgp::module_add_function(module, name.data(), callback);
+  auto *func = mgp::module_add_function(module, name.data(), callback);
 
   for (const auto &parameter : parameters) {
-    auto parameter_name = parameter.name.data();
+    const auto *parameter_name = parameter.name.data();
 
     if (!parameter.optional) {
       mgp::func_add_arg(func, parameter_name, parameter.GetMGPType());

include/mgp.py

@@ -1402,6 +1402,13 @@ class UnsupportedTypingError(Exception):
         super().__init__("Unsupported typing annotation '{}'".format(type_))
 
 
+class UnequalTypesError(Exception):
+    """Signals a typing annotation is not equal between types"""
+
+    def __init__(self, type1_: typing.Any, type2_: typing.Any):
+        super().__init__(f"Unequal typing annotation '{type1_}' and '{type2_}'")
+
+
 def _typing_to_cypher_type(type_):
     """Convert typing annotation to a _mgp.CypherType instance."""
     simple_types = {
@@ -1514,6 +1521,72 @@ def _typing_to_cypher_type(type_):
         return parse_typing(str(type_))
 
 
+def _is_typing_same(type1_, type2_):
+    """Convert typing annotation to a _mgp.CypherType instance."""
+    simple_types = {
+        typing.Any: 1,
+        object: 2,
+        list: 3,
+        Any: 4,
+        bool: 5,
+        str: 6,
+        int: 7,
+        float: 8,
+        Number: 9,
+        Map: 10,
+        Vertex: 11,
+        Edge: 12,
+        Path: 13,
+        Date: 14,
+        LocalTime: 15,
+        LocalDateTime: 16,
+        Duration: 17,
+    }
+    try:
+        return simple_types[type1_] == simple_types[type2_]
+    except KeyError:
+        pass
+
+    if sys.version_info < (3, 8):
+        # skip type checks
+        return True
+
+    complex_type1 = typing.get_origin(type1_)
+    type_args1 = typing.get_args(type2_)
+
+    complex_type2 = typing.get_origin(type1_)
+    type_args2 = typing.get_args(type2_)
+
+    if complex_type2 != complex_type1:
+        raise UnequalTypesError(type1_, type2_)
+
+    if complex_type1 == typing.Union:
+        contains_none_arg1 = type(None) in type_args1
+        contains_none_arg2 = type(None) in type_args2
+
+        if contains_none_arg1 != contains_none_arg2:
+            raise UnequalTypesError(type1_, type2_)
+
+        if contains_none_arg1:
+            types1 = tuple(t for t in type_args1 if t is not type(None))  # noqa E721
+            types2 = tuple(t for t in type_args2 if t is not type(None))  # noqa E721
+            if len(types1) != len(types2):
+                raise UnequalTypesError(types1, types2)
+            if len(types1) == 1:
+                (type_arg1,) = types1
+                (type_arg2,) = types2
+            else:
+                type_arg1 = typing.Union.__getitem__(types1)
+                type_arg2 = typing.Union.__getitem__(types2)
+            return _is_typing_same(type_arg1, type_arg2)
+    elif complex_type1 == list:
+        (type_arg1,) = type_args1
+        (type_arg2,) = type_args2
+        return _is_typing_same(type_arg1, type_arg2)
+    # skip type checks
+    return True
+
+
 # Procedure registration
 
 
@@ -1673,6 +1746,92 @@ def write_proc(func: typing.Callable[..., Record]):
     return _register_proc(func, True)
 
 
+def _register_batch_proc(
+    func: typing.Callable[..., Record], initializer: typing.Callable, cleanup: typing.Callable, is_write: bool
+):
+    raise_if_does_not_meet_requirements(func)
+    register_func = _mgp.Module.add_batch_write_procedure if is_write else _mgp.Module.add_batch_read_procedure
+    func_sig = inspect.signature(func)
+    func_params = tuple(func_sig.parameters.values())
+
+    initializer_sig = inspect.signature(initializer)
+    initializer_params = tuple(initializer_sig.parameters.values())
+
+    assert (
+        func_params and initializer_params or not func_params and not initializer_params
+    ), "Both function params and initializer params must exist or not exist"
+
+    assert len(func_params) == len(initializer_params), "Number of params must be same"
+
+    assert initializer_sig.return_annotation is initializer_sig.empty, "Initializer can't return anything"
+
+    if func_params and func_params[0].annotation is ProcCtx:
+        assert (
+            initializer_params and initializer_params[0].annotation is ProcCtx
+        ), "Initializer must have mgp.ProcCtx as first parameter"
+
+        @wraps(func)
+        def wrapper_func(graph, args):
+            return func(ProcCtx(graph), *args)
+
+        @wraps(initializer)
+        def wrapper_initializer(graph, args):
+            return initializer(ProcCtx(graph), *args)
+
+        func_params = func_params[1:]
+        initializer_params = initializer_params[1:]
+        mgp_proc = register_func(_mgp._MODULE, wrapper_func, wrapper_initializer, cleanup)
+    else:
+
+        @wraps(func)
+        def wrapper_func(graph, args):
+            return func(*args)
+
+        @wraps(initializer)
+        def wrapper_initializer(graph, args):
+            return initializer(*args)
+
+        mgp_proc = register_func(_mgp._MODULE, wrapper_func, wrapper_initializer, cleanup)
+
+    for func_param, initializer_param in zip(func_params, initializer_params):
+        func_param_name = func_param.name
+        func_param_type_ = func_param.annotation
+        if func_param_type_ is func_param.empty:
+            func_param_type_ = object
+        initializer_param_type_ = initializer_param.annotation
+        if initializer_param.annotation is initializer_param.empty:
+            initializer_param_type_ = object
+
+        assert _is_typing_same(
+            func_param_type_, initializer_param_type_
+        ), "Types of initializer and function must be same"
+
+        func_cypher_type = _typing_to_cypher_type(func_param_type_)
+        if func_param.default is func_param.empty:
+            mgp_proc.add_arg(func_param_name, func_cypher_type)
+        else:
+            mgp_proc.add_opt_arg(func_param_name, func_cypher_type, func_param.default)
+    if func_sig.return_annotation is not func_sig.empty:
+        record = func_sig.return_annotation
+        if not isinstance(record, Record):
+            raise TypeError("Expected '{}' to return 'mgp.Record', got '{}'".format(func.__name__, type(record)))
+        for name, type_ in record.fields.items():
+            if isinstance(type_, Deprecated):
+                cypher_type = _typing_to_cypher_type(type_.field_type)
+                mgp_proc.add_deprecated_result(name, cypher_type)
+            else:
+                mgp_proc.add_result(name, _typing_to_cypher_type(type_))
+    return func
+
+
+def add_batch_write_proc(func: typing.Callable[..., Record], initializer: typing.Callable, cleanup: typing.Callable):
+    return _register_batch_proc(func, initializer, cleanup, True)
+
+
+def add_batch_read_proc(func: typing.Callable[..., Record], initializer: typing.Callable, cleanup: typing.Callable):
+    return _register_batch_proc(func, initializer, cleanup, False)
+
+
 class InvalidMessageError(Exception):
     """
     Signals using a message instance outside of the registered transformation.

init

@@ -77,7 +77,9 @@ fi
 
 # Fix for centos 7 during release
 if [ "${DISTRO}" = "centos-7" ] || [ "${DISTRO}" = "debian-11" ] || [ "${DISTRO}" = "amzn-2" ]; then
-  python3 -m pip uninstall -y virtualenv
+  if python3 -m pip show virtualenv >/dev/null 2>/dev/null; then
+    python3 -m pip uninstall -y virtualenv
+  fi
   python3 -m pip install virtualenv
 fi
 
@@ -100,16 +102,20 @@ setup_virtualenv tests/integration/ldap
 
 echo "Done installing dependencies for Memgraph"
 
-echo "Linking git hooks"
-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;
+echo "Linking git hooks OR skip if .git folder is not there"
+if [ -d "$DIR/.git" ]; then
+  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;
+else
+  echo "WARNING: .git folder not present, skip adding hooks"
+fi
 
 # Install precommit hook except on old operating systems because we don't
 # develop on them -> pre-commit hook not required -> we can use latest
 # packages.
-if [ "${DISTRO}" != "centos-7" ] && [ "$DISTRO" != "debian-10" ] && [ "${DISTRO}" != "ubuntu-18.04" ]; then
+if [ "${DISTRO}" != "centos-7" ] && [ "$DISTRO" != "debian-10" ] && [ "${DISTRO}" != "ubuntu-18.04" ] && [ "${DISTRO}" != "amzn-2" ]; then
   python3 -m pip install pre-commit
   python3 -m pre_commit install
   # Install py format tools for usage during the development.

libs/.gitignore

@@ -6,3 +6,4 @@
 !__main.cpp
 !pulsar.patch
 !antlr4.10.1.patch
+!rocksdb8.1.1.patch

libs/CMakeLists.txt

@@ -12,6 +12,7 @@ find_package(Boost 1.78 REQUIRED)
 find_package(BZip2 1.0.6 REQUIRED)
 find_package(Threads REQUIRED)
 set(GFLAGS_NOTHREADS OFF)
+# NOTE: config/generate.py depends on the gflags help XML format.
 find_package(gflags REQUIRED)
 find_package(fmt 8.0.1)
 find_package(Jemalloc REQUIRED)
@@ -28,6 +29,7 @@ function(import_header_library name include_dir)
   set(${_upper_name}_INCLUDE_DIR ${include_dir} CACHE FILEPATH
       "Path to ${name} include directory" FORCE)
   mark_as_advanced(${_upper_name}_INCLUDE_DIR)
+  add_library(lib::${name} ALIAS ${name})
 endfunction(import_header_library)
 
 function(import_library name type location include_dir)
@@ -256,3 +258,6 @@ import_external_library(librdtsc STATIC
   ${CMAKE_CURRENT_SOURCE_DIR}/librdtsc/include
   CMAKE_ARGS ${MG_LIBRDTSC_CMAKE_ARGS}
   BUILD_COMMAND $(MAKE) rdtsc)
+
+# setup ctre
+import_header_library(ctre ${CMAKE_CURRENT_SOURCE_DIR})

libs/rocksdb8.1.1.patch

@@ -0,0 +1,13 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 598c728..816c705 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -1242,7 +1242,7 @@ if(NOT WIN32 OR ROCKSDB_INSTALL_ON_WINDOWS)
+
+   if(ROCKSDB_BUILD_SHARED)
+     install(
+-      TARGETS ${ROCKSDB_SHARED_LIB}
++      TARGETS ${ROCKSDB_SHARED_LIB} OPTIONAL
+       EXPORT RocksDBTargets
+       COMPONENT runtime
+       ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"

libs/setup.sh

@@ -117,11 +117,12 @@ declare -A primary_urls=(
   ["mgconsole"]="http://$local_cache_host/git/mgconsole.git"
   ["spdlog"]="http://$local_cache_host/git/spdlog"
   ["nlohmann"]="http://$local_cache_host/file/nlohmann/json/4f8fba14066156b73f1189a2b8bd568bde5284c5/single_include/nlohmann/json.hpp"
-  ["neo4j"]="http://$local_cache_host/file/neo4j-community-3.2.3-unix.tar.gz"
+  ["neo4j"]="http://$local_cache_host/file/neo4j-community-5.6.0-unix.tar.gz"
   ["librdkafka"]="http://$local_cache_host/git/librdkafka.git"
   ["protobuf"]="http://$local_cache_host/git/protobuf.git"
   ["pulsar"]="http://$local_cache_host/git/pulsar.git"
   ["librdtsc"]="http://$local_cache_host/git/librdtsc.git"
+  ["ctre"]="http://$local_cache_host/file/hanickadot/compile-time-regular-expressions/v3.7.2/single-header/ctre.hpp"
 )
 
 # The goal of secondary urls is to have links to the "source of truth" of
@@ -142,11 +143,12 @@ declare -A secondary_urls=(
   ["mgconsole"]="http://github.com/memgraph/mgconsole.git"
   ["spdlog"]="https://github.com/gabime/spdlog"
   ["nlohmann"]="https://raw.githubusercontent.com/nlohmann/json/4f8fba14066156b73f1189a2b8bd568bde5284c5/single_include/nlohmann/json.hpp"
-  ["neo4j"]="https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/neo4j-community-3.2.3-unix.tar.gz"
+  ["neo4j"]="https://dist.neo4j.org/neo4j-community-5.6.0-unix.tar.gz"
   ["librdkafka"]="https://github.com/edenhill/librdkafka.git"
   ["protobuf"]="https://github.com/protocolbuffers/protobuf.git"
   ["pulsar"]="https://github.com/apache/pulsar.git"
   ["librdtsc"]="https://github.com/gabrieleara/librdtsc.git"
+  ["ctre"]="https://raw.githubusercontent.com/hanickadot/compile-time-regular-expressions/v3.7.2/single-header/ctre.hpp"
 )
 
 # antlr
@@ -180,9 +182,9 @@ repo_clone_try_double "${primary_urls[libbcrypt]}" "${secondary_urls[libbcrypt]}
 
 # neo4j
 file_get_try_double "${primary_urls[neo4j]}" "${secondary_urls[neo4j]}"
-tar -xzf neo4j-community-3.2.3-unix.tar.gz
-mv neo4j-community-3.2.3 neo4j
-rm neo4j-community-3.2.3-unix.tar.gz
+tar -xzf neo4j-community-5.6.0-unix.tar.gz
+mv neo4j-community-5.6.0 neo4j
+rm neo4j-community-5.6.0-unix.tar.gz
 
 # nlohmann json
 # We wget header instead of cloning repo since repo is huge (lots of test data).
@@ -192,10 +194,10 @@ cd json
 file_get_try_double "${primary_urls[nlohmann]}" "${secondary_urls[nlohmann]}"
 cd ..
 
-rocksdb_tag="v6.14.6" # (2020-10-14)
+rocksdb_tag="v8.1.1" # (2023-04-21)
 repo_clone_try_double "${primary_urls[rocksdb]}" "${secondary_urls[rocksdb]}" "rocksdb" "$rocksdb_tag" true
 pushd rocksdb
-git apply ../rocksdb.patch
+git apply ../rocksdb8.1.1.patch
 popd
 
 # mgclient
@@ -238,3 +240,9 @@ repo_clone_try_double "${primary_urls[librdtsc]}" "${secondary_urls[librdtsc]}"
 pushd librdtsc
 git apply ../librdtsc.patch
 popd
+
+#ctre
+mkdir -p ctre
+cd ctre
+file_get_try_double "${primary_urls[ctre]}" "${secondary_urls[ctre]}"
+cd ..

licenses/BSL.txt

@@ -36,7 +36,7 @@ ADDITIONAL USE GRANT:   You may use the Licensed Work in accordance with the
                         3. using the Licensed Work to create a work or solution
                         which competes (or might reasonably be expected to
                         compete) with the Licensed Work.
-CHANGE DATE:            2027-08-03
+CHANGE DATE:            2027-20-07
 CHANGE LICENSE:         Apache License, Version 2.0
 
 For information about alternative licensing arrangements, please visit: https://memgraph.com/legal.

licenses/third-party/ldbc/LICENSE

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

release/CMakeLists.txt

@@ -48,7 +48,7 @@ set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}
 
 # 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")
@@ -69,6 +69,12 @@ set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION
 set(CPACK_RPM_PACKAGE_REQUIRES_PRE "shadow-utils")
 set(CPACK_RPM_USER_BINARY_SPECFILE "${CMAKE_CURRENT_SOURCE_DIR}/rpm/memgraph.spec.in")
 set(CPACK_RPM_PACKAGE_LICENSE "Memgraph License")
+# CPACK deduces dependency to libstdc++ which:
+#   * can't be easily installed on Centos 7 (the one from the toolchain,
+#     only required to avoid printing issue within query modules)
+#   * it causes issues with glibcxx 2.4
+#     `if(DISTRO STREQUAL "Amazon Linux" AND DISTRO_VERSION STREQUAL "2")`
+set(CPACK_RPM_PACKAGE_AUTOREQ " no")
 
 # Description formatting is important, no line must be greater than 80 characters.
 set(CPACK_RPM_PACKAGE_DESCRIPTION "Contains Memgraph, the graph database.
@@ -77,13 +83,7 @@ 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++ >= 3.4.29, logrotate")
-
-# If amzn-2
-if(DISTRO STREQUAL "Amazon Linux" AND DISTRO_VERSION STREQUAL "2")
-    # It causes issues with glibcxx 2.4
-    set(CPACK_RPM_PACKAGE_AUTOREQ " no")
-endif()
+set(CPACK_RPM_PACKAGE_REQUIRES "openssl >= 1.0.0, curl >= 7.29.0, python3 >= 3.5.0, logrotate")
 
 # All variables must be set before including.
 include(CPack)

release/docker/package_docker

@@ -55,7 +55,8 @@ image_name="memgraph:${version}"
 image_package_name="memgraph-${version}-docker.tar.gz"
 
 # Build docker image.
-docker build -t ${image_name} ${tag_latest} -f ${dockerfile_path} \
+# NOTE: --pull is here to always pull that latest base image because of security patches.
+docker build --pull -t ${image_name} ${tag_latest} -f ${dockerfile_path} \
 --build-arg BINARY_NAME=${package_name} \
 --build-arg EXTENSION=${extension} \
 --build-arg TARGETARCH="" .

release/package/run.sh

@@ -17,7 +17,8 @@ ACTIVATE_TOOLCHAIN="source /opt/${TOOLCHAIN_VERSION}/activate"
 HOST_OUTPUT_DIR="$PROJECT_ROOT/build/output"
 
 print_help () {
-    echo "$0 init|package {os} [--for-docker|--for-platform]|docker|test"
+    # TODO(gitbuda): Update the release/package/run.sh help
+    echo "$0 init|package|docker|test {os} [--for-docker|--for-platform]"
     echo ""
     echo "    OSs: ${SUPPORTED_OS[*]}"
     exit 1
@@ -35,7 +36,7 @@ make_package () {
         package_command=" cpack -G RPM --config ../CPackConfig.cmake && rpmlint --file='../../release/rpm/rpmlintrc' memgraph*.rpm "
     fi
     if [[ "$os" =~ ^"debian".* ]]; then
-        docker exec "$build_container" bash -c "apt update"
+        docker exec "$build_container" bash -c "apt --allow-releaseinfo-change -y update"
         package_command=" cpack -G DEB --config ../CPackConfig.cmake "
     fi
     if [[ "$os" =~ ^"ubuntu".* ]]; then
@@ -64,6 +65,7 @@ make_package () {
         git fetch origin master:master
     fi
     docker exec "$build_container" mkdir -p /memgraph
+    # TODO(gitbuda): Revisit copying the whole repo -> makese sense under CI.
     docker cp "$PROJECT_ROOT/." "$build_container:/memgraph/"
 
     container_build_dir="/memgraph/build"
@@ -74,6 +76,8 @@ 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.
+    # TODO(gitbuda): On the other side, having this here allows updating deps
+    # wihout reruning the build containers.
     echo "Installing dependencies using '/memgraph/environment/os/$os.sh' script..."
     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"
@@ -83,6 +87,7 @@ make_package () {
     docker exec "$build_container" bash -c "cd /memgraph && git config --global --add safe.directory '*'"
     docker exec "$build_container" bash -c "cd /memgraph && $ACTIVATE_TOOLCHAIN && ./init"
     docker exec "$build_container" bash -c "cd $container_build_dir && rm -rf ./*"
+    # TODO(gitbuda): cmake fails locally if remote is clone via ssh because of the key -> FIX
     if [[ "$os" =~ "-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
@@ -108,8 +113,13 @@ make_package () {
 case "$1" in
     init)
         cd "$SCRIPT_DIR"
-        docker-compose build --build-arg TOOLCHAIN_VERSION="${TOOLCHAIN_VERSION}"
-        docker-compose up -d
+        if ! which "docker-compose" >/dev/null; then
+            docker_compose_cmd="docker compose"
+        else
+            docker_compose_cmd="docker-compose"
+        fi
+        $docker_compose_cmd build --build-arg TOOLCHAIN_VERSION="${TOOLCHAIN_VERSION}"
+        $docker_compose_cmd up -d
     ;;
 
     docker)

src/CMakeLists.txt

@@ -1,6 +1,7 @@
 # CMake configuration for the main memgraph library and executable
 
 # add memgraph sub libraries, ordered by dependency
+add_subdirectory(csv)
 add_subdirectory(utils)
 add_subdirectory(requests)
 add_subdirectory(io)
@@ -16,10 +17,7 @@ add_subdirectory(slk)
 add_subdirectory(rpc)
 add_subdirectory(license)
 add_subdirectory(auth)
-
-if(MG_ENTERPRISE)
-        add_subdirectory(audit)
-endif()
+add_subdirectory(audit)
 
 string(TOLOWER ${CMAKE_BUILD_TYPE} lower_build_type)
 
@@ -36,12 +34,7 @@ set(mg_single_node_v2_sources
 )
 
 set(mg_single_node_v2_libs stdc++fs Threads::Threads
-        mg-telemetry mg-query mg-communication mg-memory mg-utils mg-auth mg-license mg-settings mg-glue)
-
-if(MG_ENTERPRISE)
-        # These are enterprise subsystems
-        set(mg_single_node_v2_libs ${mg_single_node_v2_libs} mg-audit)
-endif()
+        mg-telemetry mg-query mg-communication mg-memory mg-utils mg-auth mg-license mg-settings mg-glue mg-audit)
 
 # memgraph main executable
 add_executable(memgraph ${mg_single_node_v2_sources})

src/auth/CMakeLists.txt

@@ -16,6 +16,10 @@ target_link_libraries(mg-auth mg-utils mg-kvstore mg-license )
 target_link_libraries(mg-auth ${Seccomp_LIBRARIES})
 target_include_directories(mg-auth SYSTEM PRIVATE ${Seccomp_INCLUDE_DIRS})
 
+find_package(OpenSSL REQUIRED)
+target_link_libraries(mg-auth ${OPENSSL_LIBRARIES})
+target_include_directories(mg-auth SYSTEM PUBLIC ${OPENSSL_INCLUDE_DIR})
+
 # Install reference auth modules and their configuration files.
 install(PROGRAMS ${CMAKE_CURRENT_SOURCE_DIR}/reference_modules/example.py
         DESTINATION lib/memgraph/auth_module)

src/auth/crypto.cpp

@@ -1,19 +1,64 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Licensed as a Memgraph Enterprise file under the Memgraph Enterprise
 // License (the "License"); by using this file, you agree to be bound by the terms of the License, and you may not use
 // this file except in compliance with the License. You may obtain a copy of the License at https://memgraph.com/legal.
 //
 //
-
 #include "auth/crypto.hpp"
 
+#include <iomanip>
+#include <sstream>
+
+#include <gflags/gflags.h>
 #include <libbcrypt/bcrypt.h>
+#include <openssl/evp.h>
+#include <openssl/opensslv.h>
+#include <openssl/sha.h>
 
 #include "auth/exceptions.hpp"
+#include "utils/enum.hpp"
+#include "utils/flag_validation.hpp"
+
+namespace {
+using namespace std::literals;
+inline constexpr std::array password_encryption_mappings{
+    std::pair{"bcrypt"sv, memgraph::auth::PasswordEncryptionAlgorithm::BCRYPT},
+    std::pair{"sha256"sv, memgraph::auth::PasswordEncryptionAlgorithm::SHA256},
+    std::pair{"sha256-multiple"sv, memgraph::auth::PasswordEncryptionAlgorithm::SHA256_MULTIPLE}};
+
+inline constexpr uint64_t ONE_SHA_ITERATION = 1;
+inline constexpr uint64_t MULTIPLE_SHA_ITERATIONS = 1024;
+}  // namespace
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables,misc-unused-parameters)
+DEFINE_VALIDATED_string(password_encryption_algorithm, "bcrypt",
+                        "The password encryption algorithm used for authentication.", {
+                          if (const auto result =
+                                  memgraph::utils::IsValidEnumValueString(value, password_encryption_mappings);
+                              result.HasError()) {
+                            const auto error = result.GetError();
+                            switch (error) {
+                              case memgraph::utils::ValidationError::EmptyValue: {
+                                std::cout << "Password encryption algorithm cannot be empty." << std::endl;
+                                break;
+                              }
+                              case memgraph::utils::ValidationError::InvalidValue: {
+                                std::cout << "Invalid value for password encryption algorithm. Allowed values: "
+                                          << memgraph::utils::GetAllowedEnumValuesString(password_encryption_mappings)
+                                          << std::endl;
+                                break;
+                              }
+                            }
+                            return false;
+                          }
+
+                          return true;
+                        });
 
 namespace memgraph::auth {
-const std::string EncryptPassword(const std::string &password) {
+namespace BCrypt {
+std::string EncryptPassword(const std::string &password) {
   char salt[BCRYPT_HASHSIZE];
   char hash[BCRYPT_HASHSIZE];
 
@@ -28,7 +73,7 @@ const std::string EncryptPassword(const std::string &password) {
     throw AuthException("Couldn't hash password!");
   }
 
-  return std::string(hash);
+  return {hash};
 }
 
 bool VerifyPassword(const std::string &password, const std::string &hash) {
@@ -38,5 +83,102 @@ bool VerifyPassword(const std::string &password, const std::string &hash) {
   }
   return ret == 0;
 }
+}  // namespace BCrypt
+
+namespace SHA {
+#if OPENSSL_VERSION_MAJOR >= 3
+std::string EncryptPasswordOpenSSL3(const std::string &password, const uint64_t number_of_iterations) {
+  unsigned char hash[SHA256_DIGEST_LENGTH];
+
+  EVP_MD_CTX *ctx = EVP_MD_CTX_new();
+  EVP_MD *md = EVP_MD_fetch(nullptr, "SHA2-256", nullptr);
+
+  EVP_DigestInit_ex(ctx, md, nullptr);
+  for (auto i = 0; i < number_of_iterations; i++) {
+    EVP_DigestUpdate(ctx, password.c_str(), password.size());
+  }
+  EVP_DigestFinal_ex(ctx, hash, nullptr);
+
+  EVP_MD_free(md);
+  EVP_MD_CTX_free(ctx);
+
+  std::stringstream result_stream;
+  for (auto hash_char : hash) {
+    result_stream << std::hex << std::setw(2) << std::setfill('0') << (int)hash_char;
+  }
+
+  return result_stream.str();
+}
+#else
+std::string EncryptPasswordOpenSSL1_1(const std::string &password, const uint64_t number_of_iterations) {
+  unsigned char hash[SHA256_DIGEST_LENGTH];
+
+  SHA256_CTX sha256;
+  SHA256_Init(&sha256);
+  for (auto i = 0; i < number_of_iterations; i++) {
+    SHA256_Update(&sha256, password.c_str(), password.size());
+  }
+  SHA256_Final(hash, &sha256);
+
+  std::stringstream ss;
+  for (auto hash_char : hash) {
+    ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash_char;
+  }
+
+  return ss.str();
+}
+#endif
+
+std::string EncryptPassword(const std::string &password, const uint64_t number_of_iterations) {
+#if OPENSSL_VERSION_MAJOR >= 3
+  return EncryptPasswordOpenSSL3(password, number_of_iterations);
+#else
+  return EncryptPasswordOpenSSL1_1(password, number_of_iterations);
+#endif
+}
+
+bool VerifyPassword(const std::string &password, const std::string &hash, const uint64_t number_of_iterations) {
+  auto password_hash = EncryptPassword(password, number_of_iterations);
+  return password_hash == hash;
+}
+}  // namespace SHA
+
+bool VerifyPassword(const std::string &password, const std::string &hash) {
+  const auto password_encryption_algorithm = utils::StringToEnum<PasswordEncryptionAlgorithm>(
+      FLAGS_password_encryption_algorithm, password_encryption_mappings);
+
+  if (!password_encryption_algorithm.has_value()) {
+    throw AuthException("Invalid password encryption flag '{}'!", FLAGS_password_encryption_algorithm);
+  }
+
+  switch (password_encryption_algorithm.value()) {
+    case PasswordEncryptionAlgorithm::BCRYPT:
+      return BCrypt::VerifyPassword(password, hash);
+    case PasswordEncryptionAlgorithm::SHA256:
+      return SHA::VerifyPassword(password, hash, ONE_SHA_ITERATION);
+    case PasswordEncryptionAlgorithm::SHA256_MULTIPLE:
+      return SHA::VerifyPassword(password, hash, MULTIPLE_SHA_ITERATIONS);
+  }
+
+  throw AuthException("Invalid password encryption flag '{}'!", FLAGS_password_encryption_algorithm);
+}
+
+std::string EncryptPassword(const std::string &password) {
+  const auto password_encryption_algorithm = utils::StringToEnum<PasswordEncryptionAlgorithm>(
+      FLAGS_password_encryption_algorithm, password_encryption_mappings);
+
+  if (!password_encryption_algorithm.has_value()) {
+    throw AuthException("Invalid password encryption flag '{}'!", FLAGS_password_encryption_algorithm);
+  }
+
+  switch (password_encryption_algorithm.value()) {
+    case PasswordEncryptionAlgorithm::BCRYPT:
+      return BCrypt::EncryptPassword(password);
+    case PasswordEncryptionAlgorithm::SHA256:
+      return SHA::EncryptPassword(password, ONE_SHA_ITERATION);
+    case PasswordEncryptionAlgorithm::SHA256_MULTIPLE:
+      return SHA::EncryptPassword(password, MULTIPLE_SHA_ITERATIONS);
+  }
+}
 
 }  // namespace memgraph::auth

src/auth/crypto.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Licensed as a Memgraph Enterprise file under the Memgraph Enterprise
 // License (the "License"); by using this file, you agree to be bound by the terms of the License, and you may not use
@@ -11,10 +11,11 @@
 #include <string>
 
 namespace memgraph::auth {
+enum class PasswordEncryptionAlgorithm : uint8_t { BCRYPT, SHA256, SHA256_MULTIPLE };
+
 /// @throw AuthException if unable to encrypt the password.
-const std::string EncryptPassword(const std::string &password);
+std::string EncryptPassword(const std::string &password);
 
 /// @throw AuthException if unable to verify the password.
 bool VerifyPassword(const std::string &password, const std::string &hash);
-
 }  // namespace memgraph::auth

src/auth/models.cpp

@@ -45,7 +45,9 @@ const std::vector<Permission> kPermissionsAll = {Permission::MATCH,       Permis
                                                  Permission::FREE_MEMORY, Permission::TRIGGER,
                                                  Permission::CONFIG,      Permission::STREAM,
                                                  Permission::MODULE_READ, Permission::MODULE_WRITE,
-                                                 Permission::WEBSOCKET,   Permission::TRANSACTION_MANAGEMENT};
+                                                 Permission::WEBSOCKET,   Permission::TRANSACTION_MANAGEMENT,
+                                                 Permission::STORAGE_MODE};
+
 }  // namespace
 
 std::string PermissionToString(Permission permission) {
@@ -94,6 +96,8 @@ std::string PermissionToString(Permission permission) {
       return "WEBSOCKET";
     case Permission::TRANSACTION_MANAGEMENT:
       return "TRANSACTION_MANAGEMENT";
+    case Permission::STORAGE_MODE:
+      return "STORAGE_MODE";
   }
 }
 

src/auth/models.hpp

@@ -40,7 +40,8 @@ enum class Permission : uint64_t {
   MODULE_READ  = 1U << 18U,
   MODULE_WRITE = 1U << 19U,
   WEBSOCKET    = 1U << 20U,
-  TRANSACTION_MANAGEMENT = 1U << 21U
+  TRANSACTION_MANAGEMENT = 1U << 21U,
+  STORAGE_MODE    = 1U << 22U
 };
 // clang-format on
 

src/communication/bolt/v1/codes.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -20,6 +20,8 @@ inline constexpr uint8_t kPreamble[4] = {0x60, 0x60, 0xB0, 0x17};
 enum class Signature : uint8_t {
   Noop = 0x00,
   Init = 0x01,
+  LogOn = 0x6A,
+  LogOff = 0x6B,
   AckFailure = 0x0E,  // only v1
   Reset = 0x0F,
   Goodbye = 0x02,

src/communication/bolt/v1/constants.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -28,7 +28,7 @@ inline constexpr size_t kChunkWholeSize = kChunkHeaderSize + kChunkMaxDataSize;
  */
 inline constexpr size_t kHandshakeSize = 20;
 
-inline constexpr uint16_t kSupportedVersions[] = {0x0100, 0x0400, 0x0401, 0x0403};
+inline constexpr uint16_t kSupportedVersions[] = {0x0100, 0x0400, 0x0401, 0x0403, 0x0502};
 
 inline constexpr int kPullAll = -1;
 inline constexpr int kPullLast = -1;

src/communication/bolt/v1/decoder/decoder.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -33,7 +33,14 @@ namespace memgraph::communication::bolt {
 template <typename Buffer>
 class Decoder {
  public:
-  explicit Decoder(Buffer &buffer) : buffer_(buffer) {}
+  explicit Decoder(Buffer &buffer) : buffer_(buffer), major_v_(0) {}
+
+  /**
+   * Lets the user update the version.
+   * This is all single thread for now. TODO: Update if ever multithreaded.
+   * @param major_v the major version of the Bolt protocol used.
+   */
+  void UpdateVersion(int major_v) { major_v_ = major_v; }
 
   /**
    * Reads a Value from the available data in the buffer.
@@ -208,6 +215,10 @@ class Decoder {
 
  protected:
   Buffer &buffer_;
+  int major_v_;  //!< Major version of the underlying Bolt protocol
+                 // TODO: when refactoring
+  // Ideally the major_v would be a compile time constant. If the higher level (Bolt driver) ends up being separate
+  // classes, this could be just a template and each version of the driver would use the appropriate decoder.
 
  private:
   bool ReadNull(const Marker &marker, Value *data) {
@@ -370,11 +381,7 @@ class Decoder {
       }
       ret.emplace(std::move(dv_key.ValueString()), std::move(dv_val));
     }
-    if (ret.size() != size) {
-      return false;
-    }
-
-    return true;
+    return ret.size() == size;
   }
 
   bool ReadVertex(Value *data) {
@@ -407,6 +414,14 @@ class Decoder {
     }
     vertex.properties = std::move(dv.ValueMap());
 
+    if (major_v_ > 4) {
+      // element_id introduced in v5.0
+      if (!ReadValue(&dv, Value::Type::String)) {
+        return false;
+      }
+      vertex.element_id = std::move(dv.ValueString());
+    }
+
     return true;
   }
 
@@ -445,6 +460,23 @@ class Decoder {
     }
     edge.properties = std::move(dv.ValueMap());
 
+    if (major_v_ > 4) {
+      // element_id introduced in v5.0
+      if (!ReadValue(&dv, Value::Type::String)) {
+        return false;
+      }
+      edge.element_id = std::move(dv.ValueString());
+      // from_element_id introduced in v5.0
+      if (!ReadValue(&dv, Value::Type::String)) {
+        return false;
+      }
+      edge.from_element_id = std::move(dv.ValueString());
+      // to_element_id introduced in v5.0
+      if (!ReadValue(&dv, Value::Type::String)) {
+        return false;
+      }
+      edge.to_element_id = std::move(dv.ValueString());
+    }
     return true;
   }
 
@@ -471,6 +503,14 @@ class Decoder {
     }
     edge.properties = std::move(dv.ValueMap());
 
+    if (major_v_ > 4) {
+      // element_id introduced in v5.0
+      if (!ReadValue(&dv, Value::Type::String)) {
+        return false;
+      }
+      edge.element_id = std::move(dv.ValueString());
+    }
+
     return true;
   }
 

src/communication/bolt/v1/encoder/base_encoder.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -36,7 +36,14 @@ namespace memgraph::communication::bolt {
 template <typename Buffer>
 class BaseEncoder {
  public:
-  explicit BaseEncoder(Buffer &buffer) : buffer_(buffer) {}
+  explicit BaseEncoder(Buffer &buffer) : buffer_(buffer), major_v_(0) {}
+
+  /**
+   * Lets the user update the version.
+   * This is all single thread for now. TODO: Update if ever multithreaded.
+   * @param major_v the major version of the Bolt protocol used.
+   */
+  void UpdateVersion(int major_v) { major_v_ = major_v; }
 
   void WriteRAW(const uint8_t *data, uint64_t len) { buffer_.Write(data, len); }
 
@@ -116,7 +123,8 @@ class BaseEncoder {
   }
 
   void WriteVertex(const Vertex &vertex) {
-    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct) + 3);
+    int struct_n = 3 + 1 * int(major_v_ > 4);  // element_id introduced from v5
+    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct) + struct_n);
     WriteRAW(utils::UnderlyingCast(Signature::Node));
     WriteInt(vertex.id.AsInt());
 
@@ -132,10 +140,16 @@ class BaseEncoder {
       WriteString(prop.first);
       WriteValue(prop.second);
     }
+
+    if (major_v_ > 4) {
+      // element_id introduced in v5.0
+      WriteString(vertex.element_id);
+    }
   }
 
   void WriteEdge(const Edge &edge, bool unbound = false) {
-    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct) + (unbound ? 3 : 5));
+    int struct_n = (unbound ? 3 + 1 * int(major_v_ > 4) : 5 + 3 * int(major_v_ > 4));  // element_id introduced from v5
+    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct) + struct_n);
     WriteRAW(utils::UnderlyingCast(unbound ? Signature::UnboundRelationship : Signature::Relationship));
 
     WriteInt(edge.id.AsInt());
@@ -152,10 +166,22 @@ class BaseEncoder {
       WriteString(prop.first);
       WriteValue(prop.second);
     }
+
+    if (major_v_ > 4) {
+      // element_id introduced in v5.0
+      WriteString(edge.element_id);
+      if (!unbound) {
+        // from_element_id introduced in v5.0
+        WriteString(edge.from_element_id);
+        // to_element_id introduced in v5.0
+        WriteString(edge.to_element_id);
+      }
+    }
   }
 
   void WriteEdge(const UnboundedEdge &edge) {
-    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct) + 3);
+    const int struct_n = 3 + 1 * int(major_v_ > 4);  // element_id introduced from v5
+    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct) + struct_n);
     WriteRAW(utils::UnderlyingCast(Signature::UnboundRelationship));
 
     WriteInt(edge.id.AsInt());
@@ -168,6 +194,11 @@ class BaseEncoder {
       WriteString(prop.first);
       WriteValue(prop.second);
     }
+
+    if (major_v_ > 4) {
+      // element_id introduced in v5.0
+      WriteString(edge.element_id);
+    }
   }
 
   void WritePath(const Path &path) {
@@ -264,6 +295,7 @@ class BaseEncoder {
 
  protected:
   Buffer &buffer_;
+  int major_v_;  //!< Major version of the underlying Bolt protocol (TODO: Think about reimplementing the versioning)
 
  private:
   template <class T>

src/communication/bolt/v1/encoder/client_encoder.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -41,6 +41,8 @@ class ClientEncoder : private BaseEncoder<Buffer> {
  public:
   ClientEncoder(Buffer &buffer) : BaseEncoder<Buffer>(buffer) {}
 
+  using BaseEncoder<Buffer>::UpdateVersion;
+
   /**
    * Writes a Init message.
    *

src/communication/bolt/v1/encoder/encoder.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -34,6 +34,8 @@ class Encoder : private BaseEncoder<Buffer> {
  public:
   Encoder(Buffer &buffer) : BaseEncoder<Buffer>(buffer) {}
 
+  using BaseEncoder<Buffer>::UpdateVersion;
+
   /**
    * Sends a Record message.
    *

src/communication/bolt/v1/session.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -63,7 +63,8 @@ class Session {
    * if an explicit transaction was started.
    */
   virtual std::pair<std::vector<std::string>, std::optional<int>> Interpret(
-      const std::string &query, const std::map<std::string, Value> &params) = 0;
+      const std::string &query, const std::map<std::string, Value> &params,
+      const std::map<std::string, memgraph::communication::bolt::Value> &metadata) = 0;
 
   /**
    * Put results of the processed query in the `encoder`.
@@ -85,7 +86,7 @@ class Session {
    */
   virtual std::map<std::string, Value> Discard(std::optional<int> n, std::optional<int> qid) = 0;
 
-  virtual void BeginTransaction() = 0;
+  virtual void BeginTransaction(const std::map<std::string, memgraph::communication::bolt::Value> &) = 0;
   virtual void CommitTransaction() = 0;
   virtual void RollbackTransaction() = 0;
 
@@ -120,6 +121,9 @@ class Session {
         return;
       }
       handshake_done_ = true;
+      // Update the decoder's Bolt version (v5 has changed the undelying structure)
+      decoder_.UpdateVersion(version_.major);
+      encoder_.UpdateVersion(version_.major);
     }
 
     ChunkState chunk_state;

src/communication/bolt/v1/states/executing.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -22,10 +22,15 @@
 #include "communication/bolt/v1/state.hpp"
 #include "communication/bolt/v1/states/handlers.hpp"
 #include "communication/bolt/v1/value.hpp"
+#include "utils/event_counter.hpp"
 #include "utils/likely.hpp"
 #include "utils/logging.hpp"
 #include "utils/message.hpp"
 
+namespace memgraph::metrics {
+extern const Event BoltMessages;
+}  // namespace memgraph::metrics
+
 namespace memgraph::communication::bolt {
 
 template <typename TSession>
@@ -86,6 +91,37 @@ State RunHandlerV4(Signature signature, TSession &session, State state, Marker m
   }
 }
 
+template <typename TSession>
+State RunHandlerV5(Signature signature, TSession &session, State state, Marker marker) {
+  switch (signature) {
+    case Signature::Run:
+      return HandleRunV5<TSession>(session, state, marker);
+    case Signature::Pull:
+      return HandlePullV5<TSession>(session, state, marker);
+    case Signature::Discard:
+      return HandleDiscardV5<TSession>(session, state, marker);
+    case Signature::Reset:
+      return HandleReset<TSession>(session, marker);
+    case Signature::Begin:
+      return HandleBegin<TSession>(session, state, marker);
+    case Signature::Commit:
+      return HandleCommit<TSession>(session, state, marker);
+    case Signature::Goodbye:
+      return HandleGoodbye<TSession>();
+    case Signature::Rollback:
+      return HandleRollback<TSession>(session, state, marker);
+    case Signature::Noop:
+      return HandleNoop<TSession>(state);
+    case Signature::Route:
+      return HandleRoute<TSession>(session, marker);
+    case Signature::LogOff:
+      return HandleLogOff<TSession>();
+    default:
+      spdlog::trace("Unrecognized signature received (0x{:02X})!", utils::UnderlyingCast(signature));
+      return State::Close;
+  }
+}
+
 /**
  * Executor state run function
  * This function executes an initialized Bolt session.
@@ -103,8 +139,10 @@ State StateExecutingRun(TSession &session, State state) {
 
   switch (session.version_.major) {
     case 1:
+      memgraph::metrics::IncrementCounter(memgraph::metrics::BoltMessages);
       return RunHandlerV1(signature, session, state, marker);
     case 4: {
+      memgraph::metrics::IncrementCounter(memgraph::metrics::BoltMessages);
       if (session.version_.minor >= 3) {
         return RunHandlerV4<TSession, 3>(signature, session, state, marker);
       }
@@ -113,6 +151,8 @@ State StateExecutingRun(TSession &session, State state) {
       }
       return RunHandlerV4<TSession>(signature, session, state, marker);
     }
+    case 5:
+      return RunHandlerV5<TSession>(signature, session, state, marker);
     default:
       spdlog::trace("Unsupported bolt version:{}.{})!", session.version_.major, session.version_.minor);
       return State::Close;

src/communication/bolt/v1/states/handlers.hpp

@@ -12,6 +12,7 @@
 #pragma once
 
 #include <map>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -22,6 +23,7 @@
 #include "communication/bolt/v1/state.hpp"
 #include "communication/bolt/v1/value.hpp"
 #include "communication/exceptions.hpp"
+#include "storage/v2/property_value.hpp"
 #include "utils/logging.hpp"
 #include "utils/message.hpp"
 
@@ -71,6 +73,23 @@ inline std::pair<std::string, std::string> ExceptionToErrorMessage(const std::ex
           "should be in database logs."};
 }
 
+namespace helpers {
+
+/** Extracts metadata from the extras field.
+ * NOTE: In order to avoid a copy, the metadata in moved.
+ * TODO: Update if extra field is used for anything else.
+ */
+inline std::map<std::string, Value> ConsumeMetadata(Value &extra) {
+  std::map<std::string, Value> md;
+  auto &md_tv = extra.ValueMap()["tx_metadata"];
+  if (md_tv.IsMap()) {
+    md = std::move(md_tv.ValueMap());
+  }
+  return md;
+}
+
+}  // namespace helpers
+
 namespace details {
 
 template <bool is_pull, typename TSession>
@@ -209,7 +228,7 @@ State HandleRunV1(TSession &session, const State state, const Marker marker) {
 
   try {
     // Interpret can throw.
-    const auto [header, qid] = session.Interpret(query.ValueString(), params.ValueMap());
+    const auto [header, qid] = session.Interpret(query.ValueString(), params.ValueMap(), {});
     // Convert std::string to Value
     std::vector<Value> vec;
     std::map<std::string, Value> data;
@@ -250,6 +269,7 @@ State HandleRunV4(TSession &session, const State state, const Marker marker) {
   // Even though this part seems unnecessary it is needed to move the buffer
   if (!session.decoder_.ReadValue(&extra, Value::Type::Map)) {
     spdlog::trace("Couldn't read extra field!");
+    return State::Close;
   }
 
   if (state != State::Idle) {
@@ -266,7 +286,8 @@ State HandleRunV4(TSession &session, const State state, const Marker marker) {
 
   try {
     // Interpret can throw.
-    const auto [header, qid] = session.Interpret(query.ValueString(), params.ValueMap());
+    const auto [header, qid] =
+        session.Interpret(query.ValueString(), params.ValueMap(), helpers::ConsumeMetadata(extra));
     // Convert std::string to Value
     std::vector<Value> vec;
     std::map<std::string, Value> data;
@@ -288,6 +309,12 @@ State HandleRunV4(TSession &session, const State state, const Marker marker) {
   }
 }
 
+template <typename TSession>
+State HandleRunV5(TSession &session, const State state, const Marker marker) {
+  // Using V4 on purpose
+  return HandleRunV4<TSession>(session, state, marker);
+}
+
 template <typename TSession>
 State HandlePullV1(TSession &session, const State state, const Marker marker) {
   return details::HandlePullDiscardV1<true>(session, state, marker);
@@ -298,6 +325,12 @@ State HandlePullV4(TSession &session, const State state, const Marker marker) {
   return details::HandlePullDiscardV4<true>(session, state, marker);
 }
 
+template <typename TSession>
+State HandlePullV5(TSession &session, const State state, const Marker marker) {
+  // Using V4 on purpose
+  return HandlePullV4<TSession>(session, state, marker);
+}
+
 template <typename TSession>
 State HandleDiscardV1(TSession &session, const State state, const Marker marker) {
   return details::HandlePullDiscardV1<false>(session, state, marker);
@@ -308,6 +341,12 @@ State HandleDiscardV4(TSession &session, const State state, const Marker marker)
   return details::HandlePullDiscardV4<false>(session, state, marker);
 }
 
+template <typename TSession>
+State HandleDiscardV5(TSession &session, const State state, const Marker marker) {
+  // Using V4 on purpose
+  return HandleDiscardV4<TSession>(session, state, marker);
+}
+
 template <typename TSession>
 State HandleReset(TSession &session, const Marker marker) {
   // IMPORTANT: This implementation of the Bolt RESET command isn't fully
@@ -360,7 +399,7 @@ State HandleBegin(TSession &session, const State state, const Marker marker) {
   }
 
   try {
-    session.BeginTransaction();
+    session.BeginTransaction(helpers::ConsumeMetadata(extra));
   } catch (const std::exception &e) {
     return HandleFailure(session, e);
   }
@@ -465,4 +504,10 @@ State HandleRoute(TSession &session, const Marker marker) {
   }
   return State::Error;
 }
+
+template <typename TSession>
+State HandleLogOff() {
+  // Not arguments sent, the user just needs to reauthenticate
+  return State::Init;
+}
 }  // namespace memgraph::communication::bolt

src/communication/bolt/v1/states/init.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -27,17 +27,25 @@ namespace details {
 template <typename TSession>
 std::optional<State> AuthenticateUser(TSession &session, Value &metadata) {
   // Get authentication data.
+  // From neo4j driver v4.4, fields that have a default value are not sent.
+  // In order to have back-compatibility, the missing fields will be added.
+
   auto &data = metadata.ValueMap();
-  if (!data.count("scheme")) {
-    spdlog::warn("The client didn't supply authentication information!");
-    return State::Close;
+  if (data.empty()) {  // Special case auth=None
+    spdlog::warn("The client didn't supply the authentication scheme! Trying with \"none\"...");
+    data["scheme"] = "none";
   }
+
   std::string username;
   std::string password;
   if (data["scheme"].ValueString() == "basic") {
-    if (!data.count("principal") || !data.count("credentials")) {
-      spdlog::warn("The client didn't supply authentication information!");
-      return State::Close;
+    if (!data.count("principal")) {  // Special case principal = ""
+      spdlog::warn("The client didn't supply the principal field! Trying with \"\"...");
+      data["principal"] = "";
+    }
+    if (!data.count("credentials")) {  // Special case credentials = ""
+      spdlog::warn("The client didn't supply the credentials field! Trying with \"\"...");
+      data["credentials"] = "";
     }
     username = data["principal"].ValueString();
     password = data["credentials"].ValueString();
@@ -106,6 +114,30 @@ std::optional<Value> GetMetadataV4(TSession &session, const Marker marker) {
     return std::nullopt;
   }
 
+  auto &data = metadata.ValueMap();
+  if (!data.count("user_agent")) {
+    spdlog::warn("The client didn't supply the user agent!");
+    return std::nullopt;
+  }
+
+  spdlog::info("Client connected '{}'", data.at("user_agent").ValueString());
+
+  return metadata;
+}
+
+template <typename TSession>
+std::optional<Value> GetInitDataV5(TSession &session, const Marker marker) {
+  if (marker != Marker::TinyStruct1) [[unlikely]] {
+    spdlog::trace("Expected TinyStruct1 marker, but received 0x{:02X}!", utils::UnderlyingCast(marker));
+    return std::nullopt;
+  }
+
+  Value metadata;
+  if (!session.decoder_.ReadValue(&metadata, Value::Type::Map)) {
+    spdlog::trace("Couldn't read metadata!");
+    return std::nullopt;
+  }
+
   const auto &data = metadata.ValueMap();
   if (!data.count("user_agent")) {
     spdlog::warn("The client didn't supply the user agent!");
@@ -117,6 +149,22 @@ std::optional<Value> GetMetadataV4(TSession &session, const Marker marker) {
   return metadata;
 }
 
+template <typename TSession>
+std::optional<Value> GetAuthDataV5(TSession &session, const Marker marker) {
+  if (marker != Marker::TinyStruct1) [[unlikely]] {
+    spdlog::trace("Expected TinyStruct1 marker, but received 0x{:02X}!", utils::UnderlyingCast(marker));
+    return std::nullopt;
+  }
+
+  Value metadata;
+  if (!session.decoder_.ReadValue(&metadata, Value::Type::Map)) {
+    spdlog::trace("Couldn't read metadata!");
+    return std::nullopt;
+  }
+
+  return metadata;
+}
+
 template <typename TSession>
 State SendSuccessMessage(TSession &session) {
   // Neo4j's Java driver 4.1.1+ requires connection_id.
@@ -180,6 +228,57 @@ State StateInitRunV4(TSession &session, Marker marker, Signature signature) {
 
   return SendSuccessMessage(session);
 }
+
+template <typename TSession>
+State StateInitRunV5(TSession &session, Marker marker, Signature signature) {
+  if (signature == Signature::Noop) [[unlikely]] {
+    SPDLOG_DEBUG("Received NOOP message");
+    return State::Init;
+  }
+
+  if (signature == Signature::Init) {
+    auto maybeMetadata = GetInitDataV5(session, marker);
+
+    if (!maybeMetadata) {
+      return State::Close;
+    }
+
+    if (SendSuccessMessage(session) == State::Close) {
+      return State::Close;
+    }
+    // Stay in Init
+    return State::Init;
+
+  } else if (signature == Signature::LogOn) {
+    if (marker != Marker::TinyStruct1) [[unlikely]] {
+      spdlog::trace("Expected TinyStruct1 marker, but received 0x{:02X}!", utils::UnderlyingCast(marker));
+      spdlog::trace(
+          "The client sent malformed data, but we are continuing "
+          "because the official Neo4j Java driver sends malformed "
+          "data. D'oh!");
+      return State::Close;
+    }
+
+    auto maybeMetadata = GetAuthDataV5(session, marker);
+    if (!maybeMetadata) {
+      return State::Close;
+    }
+    auto result = AuthenticateUser(session, *maybeMetadata);
+    if (result) {
+      spdlog::trace("Failed to authenticate, closing connection...");
+      return State::Close;
+    }
+
+    if (SendSuccessMessage(session) == State::Close) {
+      return State::Close;
+    }
+    return State::Idle;
+
+  } else [[unlikely]] {
+    spdlog::trace("Expected Init signature, but received 0x{:02X}!", utils::UnderlyingCast(signature));
+    return State::Close;
+  }
+}
 }  // namespace details
 
 /**
@@ -208,6 +307,9 @@ State StateInitRun(TSession &session) {
       }
       return details::StateInitRunV4<TSession>(session, marker, signature);
     }
+    case 5: {
+      return details::StateInitRunV5<TSession>(session, marker, signature);
+    }
   }
   spdlog::trace("Unsupported bolt version:{}.{})!", session.version_.major, session.version_.minor);
   return State::Close;

src/communication/bolt/v1/value.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -342,6 +342,9 @@ std::ostream &operator<<(std::ostream &os, const Vertex &vertex) {
                          [&](auto &stream, const auto &pair) { stream << pair.first << ": " << pair.second; });
     os << "}";
   }
+  if (!vertex.element_id.empty()) {
+    os << " element_id: " << vertex.element_id;
+  }
   return os << ")";
 }
 

src/communication/bolt/v1/value.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -57,6 +57,7 @@ struct Vertex {
   Id id;
   std::vector<std::string> labels;
   std::map<std::string, Value> properties;
+  std::string element_id;
 };
 
 /**
@@ -69,6 +70,9 @@ struct Edge {
   Id to;
   std::string type;
   std::map<std::string, Value> properties;
+  std::string element_id;
+  std::string from_element_id;
+  std::string to_element_id;
 };
 
 /**
@@ -79,6 +83,7 @@ struct UnboundedEdge {
   Id id;
   std::string type;
   std::map<std::string, Value> properties;
+  std::string element_id;
 };
 
 /**

src/communication/http/listener.hpp

@@ -0,0 +1,108 @@
+// Copyright 2023 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 <list>
+#include <memory>
+
+#include <spdlog/spdlog.h>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/strand.hpp>
+#include <boost/beast/core.hpp>
+
+#include "communication/context.hpp"
+#include "communication/http/session.hpp"
+#include "utils/spin_lock.hpp"
+#include "utils/synchronized.hpp"
+
+namespace memgraph::communication::http {
+
+template <class TRequestHandler, typename TSessionData>
+class Listener final : public std::enable_shared_from_this<Listener<TRequestHandler, TSessionData>> {
+  using tcp = boost::asio::ip::tcp;
+  using SessionHandler = Session<TRequestHandler, TSessionData>;
+  using std::enable_shared_from_this<Listener<TRequestHandler, TSessionData>>::shared_from_this;
+
+ public:
+  Listener(const Listener &) = delete;
+  Listener(Listener &&) = delete;
+  Listener &operator=(const Listener &) = delete;
+  Listener &operator=(Listener &&) = delete;
+  ~Listener() {}
+
+  template <typename... Args>
+  static std::shared_ptr<Listener> Create(Args &&...args) {
+    return std::shared_ptr<Listener>{new Listener(std::forward<Args>(args)...)};
+  }
+
+  // Start accepting incoming connections
+  void Run() { DoAccept(); }
+  tcp::endpoint GetEndpoint() const { return acceptor_.local_endpoint(); }
+
+ private:
+  Listener(boost::asio::io_context &ioc, TSessionData *data, ServerContext *context, tcp::endpoint endpoint)
+      : ioc_(ioc), data_(data), context_(context), acceptor_(ioc) {
+    boost::beast::error_code ec;
+
+    // Open the acceptor
+    acceptor_.open(endpoint.protocol(), ec);
+    if (ec) {
+      LogError(ec, "open");
+      return;
+    }
+
+    // Allow address reuse
+    acceptor_.set_option(boost::asio::socket_base::reuse_address(true), ec);
+    if (ec) {
+      LogError(ec, "set_option");
+      return;
+    }
+
+    // Bind to the server address
+    acceptor_.bind(endpoint, ec);
+    if (ec) {
+      LogError(ec, "bind");
+      return;
+    }
+
+    acceptor_.listen(boost::asio::socket_base::max_listen_connections, ec);
+    if (ec) {
+      LogError(ec, "listen");
+      return;
+    }
+
+    spdlog::info("HTTP server is listening on {}:{}", endpoint.address(), endpoint.port());
+  }
+
+  void DoAccept() {
+    acceptor_.async_accept(ioc_, [shared_this = shared_from_this()](auto ec, auto socket) {
+      shared_this->OnAccept(ec, std::move(socket));
+    });
+  }
+
+  void OnAccept(boost::beast::error_code ec, tcp::socket socket) {
+    if (ec) {
+      return LogError(ec, "accept");
+    }
+
+    SessionHandler::Create(std::move(socket), data_, *context_)->Run();
+
+    DoAccept();
+  }
+
+  boost::asio::io_context &ioc_;
+  TSessionData *data_;
+  ServerContext *context_;
+  tcp::acceptor acceptor_;
+};
+}  // namespace memgraph::communication::http

src/communication/http/server.hpp

@@ -0,0 +1,65 @@
+// Copyright 2023 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 <thread>
+
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/ip/tcp.hpp>
+
+#include "communication/http/listener.hpp"
+#include "io/network/endpoint.hpp"
+
+namespace memgraph::communication::http {
+
+template <class TRequestHandler, typename TSessionData>
+class Server final {
+  using tcp = boost::asio::ip::tcp;
+
+ public:
+  explicit Server(io::network::Endpoint endpoint, TSessionData *data, ServerContext *context)
+      : listener_{Listener<TRequestHandler, TSessionData>::Create(
+            ioc_, data, context, tcp::endpoint{boost::asio::ip::make_address(endpoint.address), endpoint.port})} {}
+
+  Server(const Server &) = delete;
+  Server(Server &&) = delete;
+  Server &operator=(const Server &) = delete;
+  Server &operator=(Server &&) = delete;
+
+  ~Server() {
+    MG_ASSERT(!background_thread_ || (ioc_.stopped() && !background_thread_->joinable()),
+              "Server wasn't shutdown properly");
+  }
+
+  void Start() {
+    MG_ASSERT(!background_thread_, "The server was already started!");
+    listener_->Run();
+    background_thread_.emplace([this] { ioc_.run(); });
+  }
+
+  void Shutdown() { ioc_.stop(); }
+
+  void AwaitShutdown() {
+    if (background_thread_ && background_thread_->joinable()) {
+      background_thread_->join();
+    }
+  }
+  bool IsRunning() const { return background_thread_ && !ioc_.stopped(); }
+  tcp::endpoint GetEndpoint() const { return listener_->GetEndpoint(); }
+
+ private:
+  boost::asio::io_context ioc_;
+
+  std::shared_ptr<Listener<TRequestHandler, TSessionData>> listener_;
+  std::optional<std::thread> background_thread_;
+};
+}  // namespace memgraph::communication::http

src/communication/http/session.hpp

@@ -0,0 +1,193 @@
+// Copyright 2023 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 <deque>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+
+#include <spdlog/spdlog.h>
+#include <boost/asio/bind_executor.hpp>
+#include <boost/asio/dispatch.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/strand.hpp>
+#include <boost/beast/core/buffers_to_string.hpp>
+#include <boost/beast/core/stream_traits.hpp>
+#include <boost/beast/core/tcp_stream.hpp>
+#include <boost/beast/http.hpp>
+#include <boost/beast/ssl.hpp>
+#include <boost/beast/version.hpp>
+#include <json/json.hpp>
+
+#include "communication/context.hpp"
+#include "utils/logging.hpp"
+#include "utils/variant_helpers.hpp"
+
+namespace memgraph::communication::http {
+
+inline constexpr uint16_t kSSLExpirySeconds = 30;
+inline void LogError(boost::beast::error_code ec, const std::string_view what) {
+  spdlog::warn("HTTP session failed on {}: {}", what, ec.message());
+}
+
+template <class TRequestHandler, typename TSessionData>
+class Session : public std::enable_shared_from_this<Session<TRequestHandler, TSessionData>> {
+  using tcp = boost::asio::ip::tcp;
+  using std::enable_shared_from_this<Session<TRequestHandler, TSessionData>>::shared_from_this;
+
+ public:
+  template <typename... Args>
+  static std::shared_ptr<Session> Create(Args &&...args) {
+    return std::shared_ptr<Session>{new Session{std::forward<Args>(args)...}};
+  }
+
+  void Run() {
+    if (auto *ssl = std::get_if<SSLSocket>(&stream_); ssl != nullptr) {
+      try {
+        boost::beast::get_lowest_layer(*ssl).expires_after(std::chrono::seconds(kSSLExpirySeconds));
+        ssl->handshake(boost::asio::ssl::stream_base::server);
+      } catch (const boost::system::system_error &e) {
+        spdlog::warn("Failed on SSL handshake: {}", e.what());
+        return;
+      }
+    }
+
+    // run on the strand
+    boost::asio::dispatch(strand_, [shared_this = shared_from_this()] { shared_this->DoRead(); });
+  }
+
+ private:
+  using PlainSocket = boost::beast::tcp_stream;
+  using SSLSocket = boost::beast::ssl_stream<boost::beast::tcp_stream>;
+
+  explicit Session(tcp::socket &&socket, TSessionData *data, ServerContext &context)
+      : stream_(CreateSocket(std::move(socket), context)),
+        handler_(data),
+        strand_{boost::asio::make_strand(GetExecutor())} {}
+
+  std::variant<PlainSocket, SSLSocket> CreateSocket(tcp::socket &&socket, ServerContext &context) {
+    if (context.use_ssl()) {
+      ssl_context_.emplace(context.context_clone());
+      return Session::SSLSocket{std::move(socket), *ssl_context_};
+    }
+
+    return Session::PlainSocket{std::move(socket)};
+  }
+
+  void OnWrite(boost::beast::error_code ec, size_t bytes_transferred) {
+    boost::ignore_unused(bytes_transferred);
+
+    if (ec) {
+      close_ = true;
+      return LogError(ec, "write");
+    }
+
+    if (close_) {
+      DoClose();
+      return;
+    }
+
+    res_ = nullptr;
+
+    DoRead();
+  }
+
+  void DoRead() {
+    req_ = {};
+
+    ExecuteForStream([this](auto &&stream) {
+      boost::beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(kSSLExpirySeconds));
+
+      boost::beast::http::async_read(
+          stream, buffer_, req_,
+          boost::asio::bind_executor(strand_, std::bind_front(&Session::OnRead, shared_from_this())));
+    });
+  }
+
+  void OnRead(boost::beast::error_code ec, size_t bytes_transferred) {
+    boost::ignore_unused(bytes_transferred);
+
+    if (ec == boost::beast::http::error::end_of_stream) {
+      DoClose();
+      return;
+    }
+
+    if (ec) {
+      return LogError(ec, "read");
+    }
+
+    auto async_write = [this](boost::beast::http::response<boost::beast::http::string_body> msg) {
+      ExecuteForStream([this, &msg](auto &&stream) {
+        // The lifetime of the message has to extend
+        // for the duration of the async operation so
+        // we use a shared_ptr to manage it.
+        auto sp = std::make_shared<boost::beast::http::response<boost::beast::http::string_body>>(std::move(msg));
+
+        // Store a type-erased version of the shared
+        // pointer in the class to keep it alive.
+        res_ = sp;
+        // Write the response
+        boost::beast::http::async_write(
+            stream, *sp, boost::asio::bind_executor(strand_, std::bind_front(&Session::OnWrite, shared_from_this())));
+      });
+    };
+
+    // handle request
+    handler_.HandleRequest(std::move(req_), async_write);
+  }
+
+  void DoClose() {
+    std::visit(utils::Overloaded{[this](SSLSocket &stream) {
+                                   boost::beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(30));
+
+                                   // Perform the SSL shutdown
+                                   stream.async_shutdown(
+                                       boost::beast::bind_front_handler(&Session::OnClose, shared_from_this()));
+                                 },
+                                 [](PlainSocket &stream) {
+                                   boost::beast::error_code ec;
+                                   stream.socket().shutdown(tcp::socket::shutdown_send, ec);
+                                 }},
+               stream_);
+  }
+  void OnClose(boost::beast::error_code ec) {
+    if (ec) {
+      LogError(ec, "close");
+    }
+
+    // At this point the connection is closed gracefully
+  }
+
+  auto GetExecutor() {
+    return std::visit(utils::Overloaded{[](auto &&stream) { return stream.get_executor(); }}, stream_);
+  }
+
+  template <typename F>
+  decltype(auto) ExecuteForStream(F &&fn) {
+    return std::visit(utils::Overloaded{std::forward<F>(fn)}, stream_);
+  }
+
+  std::optional<std::reference_wrapper<boost::asio::ssl::context>> ssl_context_;
+  std::variant<PlainSocket, SSLSocket> stream_;
+  boost::beast::flat_buffer buffer_;
+
+  TRequestHandler handler_;
+  boost::beast::http::request<boost::beast::http::string_body> req_;
+  std::shared_ptr<void> res_;
+
+  boost::asio::strand<boost::beast::tcp_stream::executor_type> strand_;
+  bool close_{false};
+};
+}  // namespace memgraph::communication::http

src/communication/v2/listener.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -30,6 +30,7 @@
 #include "communication/context.hpp"
 #include "communication/v2/pool.hpp"
 #include "communication/v2/session.hpp"
+#include "utils/message.hpp"
 #include "utils/spin_lock.hpp"
 #include "utils/synchronized.hpp"
 

src/communication/v2/session.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -41,11 +41,21 @@
 #include <boost/beast/websocket/rfc6455.hpp>
 #include <boost/system/detail/error_code.hpp>
 
+#include "communication/buffer.hpp"
 #include "communication/context.hpp"
 #include "communication/exceptions.hpp"
+#include "utils/event_counter.hpp"
 #include "utils/logging.hpp"
+#include "utils/on_scope_exit.hpp"
 #include "utils/variant_helpers.hpp"
 
+namespace memgraph::metrics {
+extern const Event ActiveSessions;
+extern const Event ActiveTCPSessions;
+extern const Event ActiveSSLSessions;
+extern const Event ActiveWebSocketSessions;
+}  // namespace memgraph::metrics
+
 namespace memgraph::communication::v2 {
 
 /**
@@ -99,6 +109,8 @@ class WebsocketSession : public std::enable_shared_from_this<WebsocketSession<TS
   // Start the asynchronous accept operation
   template <class Body, class Allocator>
   void DoAccept(boost::beast::http::request<Body, boost::beast::http::basic_fields<Allocator>> req) {
+    memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveWebSocketSessions);
+
     execution_active_ = true;
     // Set suggested timeout settings for the websocket
     ws_.set_option(boost::beast::websocket::stream_base::timeout::suggested(boost::beast::role_type::server));
@@ -213,6 +225,10 @@ class WebsocketSession : public std::enable_shared_from_this<WebsocketSession<TS
     if (!IsConnected()) {
       return;
     }
+
+    memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveSessions);
+    memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveWebSocketSessions);
+
     if (ec) {
       return OnError(ec, "close");
     }
@@ -259,12 +275,19 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
     if (execution_active_) {
       return false;
     }
+
+    memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveSessions);
+
     execution_active_ = true;
     timeout_timer_.async_wait(boost::asio::bind_executor(strand_, std::bind(&Session::OnTimeout, shared_from_this())));
 
     if (std::holds_alternative<SSLSocket>(socket_)) {
+      utils::OnScopeExit increment_counter(
+          [] { memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveSSLSessions); });
       boost::asio::dispatch(strand_, [shared_this = shared_from_this()] { shared_this->DoHandshake(); });
     } else {
+      utils::OnScopeExit increment_counter(
+          [] { memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveTCPSessions); });
       boost::asio::dispatch(strand_, [shared_this = shared_from_this()] { shared_this->DoRead(); });
     }
     return true;
@@ -450,6 +473,14 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
   }
 
   void OnClose(const boost::system::error_code &ec) {
+    if (ssl_context_.has_value()) {
+      memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveSSLSessions);
+    } else {
+      memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveTCPSessions);
+    }
+
+    memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveSessions);
+
     if (ec) {
       return OnError(ec);
     }
@@ -465,7 +496,7 @@ class Session final : public std::enable_shared_from_this<Session<TSession, TSes
     if (timeout_timer_.expiry() <= boost::asio::steady_timer::clock_type::now()) {
       // The deadline has passed. Stop the session. The other actors will
       // terminate as soon as possible.
-      spdlog::info("Shutting down session after {} of inactivity", timeout_seconds_);
+      spdlog::info("Shutting down session after {} seconds of inactivity", timeout_seconds_.count());
       DoShutdown();
     } else {
       // Put the actor back to sleep.

src/csv/CMakeLists.txt

@@ -0,0 +1,18 @@
+add_library(mg-csv STATIC)
+add_library(mg::csv ALIAS mg-csv)
+target_sources(mg-csv
+        PUBLIC
+        include/csv/parsing.hpp
+
+        PRIVATE
+        parsing.cpp
+        )
+target_include_directories(mg-csv PUBLIC include)
+
+find_package(Boost REQUIRED COMPONENTS iostreams)
+target_link_libraries(mg-csv
+        PUBLIC mg-utils
+        PRIVATE lib::ctre mg-requests Boost::iostreams
+        )
+
+add_subdirectory(fuzz)

src/csv/fuzz/CMakeLists.txt

@@ -0,0 +1,5 @@
+add_executable(fuzz_csv EXCLUDE_FROM_ALL)
+target_sources(fuzz_csv PRIVATE fuzz_reader.cpp)
+target_link_libraries(fuzz_csv PRIVATE mg::csv)
+target_compile_options(fuzz_csv PRIVATE -fsanitize=fuzzer)
+target_link_libraries(fuzz_csv PRIVATE -fsanitize=fuzzer)

src/csv/fuzz/fuzz_reader.cpp

@@ -0,0 +1,78 @@
+// Copyright 2023 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 <cstdint>
+#include <optional>
+#include <sstream>
+
+#include "csv/parsing.hpp"
+#include "utils/string.hpp"
+
+namespace mg = memgraph;
+namespace csv = mg::csv;
+
+using pmr_str = mg::utils::pmr::string;
+
+extern "C" int LLVMFuzzerTestOneInput(std::uint8_t const *data, std::size_t size) {
+  // need to parse a config
+  if (size < 4) return 0;
+  auto const with_header = bool(data[0]);
+  auto const ignore_bad = bool(data[1]);
+  auto const delim_size = data[2];
+  auto const quote_size = data[3];
+  // 0 will be nullopt, everything else will be one smaller
+  // 0      , 1, 2, 3, 4
+  // nullopt, 0, 1, 2, 3
+  auto const delim_real_size = delim_size == 0 ? 0 : delim_size - 1;
+  auto const quote_real_size = quote_size == 0 ? 0 : quote_size - 1;
+  // not worth testing if too large
+  if (delim_real_size > 3 || quote_real_size > 3) return 0;
+
+  // is there enough space for them to exist
+  if (size < 4 + delim_real_size + quote_real_size) return 0;
+  auto const delim_start = 4;
+  auto const delim_end = delim_start + delim_real_size;
+  auto const quote_start = delim_end;
+  auto const quote_end = quote_start + quote_real_size;
+
+  auto *mem = mg::utils::NewDeleteResource();
+  auto delim = delim_size == 0 ? std::optional<pmr_str>{} : pmr_str(&data[delim_start], &data[delim_end], mem);
+  auto quote = quote_size == 0 ? std::optional<pmr_str>{} : pmr_str(&data[quote_start], &data[quote_end], mem);
+
+  auto const remaining = static_cast<int64_t>(size) - quote_end;
+  if (remaining < 0) __builtin_trap();  // if this hits, above parsing is wrong
+
+  // #############################################################################################################
+
+  // build Config
+  auto cfg = csv::Reader::Config{with_header, ignore_bad, std::move(delim), std::move(quote)};
+
+  // build CSV source
+  auto ss = std::stringstream{};
+  ss.write(reinterpret_cast<char const *>(&data[quote_end]), static_cast<std::streamsize>(remaining));
+  auto source = csv::StreamCsvSource{std::move(ss)};
+
+  // #############################################################################################################
+  try {
+    auto reader = memgraph::csv::Reader(std::move(source), std::move(cfg));
+    auto const header = reader.GetHeader();
+    asm volatile("" : : "g"(header) : "memory");
+    while (true) {
+      auto row = reader.GetNextRow(mem);
+      if (!row) break;
+      asm volatile("" : : "g"(row) : "memory");
+    }
+  } catch (csv::CsvReadException const &) {
+    // CsvReadException is ok
+  }
+
+  return 0;
+}

src/csv/include/csv/parsing.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -23,6 +23,7 @@
 #include <fstream>
 #include <optional>
 #include <string>
+#include <variant>
 #include <vector>
 
 #include "utils/exceptions.hpp"
@@ -36,13 +37,53 @@ class CsvReadException : public utils::BasicException {
   using utils::BasicException::BasicException;
 };
 
+class FileCsvSource {
+ public:
+  explicit FileCsvSource(std::filesystem::path path);
+  std::istream &GetStream();
+
+ private:
+  std::filesystem::path path_;
+  std::ifstream stream_;
+};
+
+class StreamCsvSource {
+ public:
+  StreamCsvSource(std::stringstream stream) : stream_{std::move(stream)} {}
+  std::istream &GetStream() { return stream_; }
+
+ private:
+  std::stringstream stream_;
+};
+
+class UrlCsvSource : public StreamCsvSource {
+ public:
+  UrlCsvSource(char const *url);
+};
+
+class CsvSource {
+ public:
+  static auto Create(utils::pmr::string const &csv_location) -> CsvSource;
+  CsvSource(FileCsvSource source) : source_{std::move(source)} {}
+  CsvSource(StreamCsvSource source) : source_{std::move(source)} {}
+  CsvSource(UrlCsvSource source) : source_{std::move(source)} {}
+  std::istream &GetStream();
+
+ private:
+  std::variant<FileCsvSource, UrlCsvSource, StreamCsvSource> source_;
+};
+
 class Reader {
  public:
   struct Config {
     Config() = default;
     Config(const bool with_header, const bool ignore_bad, std::optional<utils::pmr::string> delim,
            std::optional<utils::pmr::string> qt)
-        : with_header(with_header), ignore_bad(ignore_bad), delimiter(std::move(delim)), quote(std::move(qt)) {}
+        : with_header(with_header), ignore_bad(ignore_bad), delimiter(std::move(delim)), quote(std::move(qt)) {
+      // delimiter + quote can not be empty
+      if (delimiter && delimiter->empty()) delimiter.reset();
+      if (quote && quote->empty()) quote.reset();
+    }
 
     bool with_header{false};
     bool ignore_bad{false};
@@ -53,16 +94,7 @@ class Reader {
   using Row = utils::pmr::vector<utils::pmr::string>;
   using Header = utils::pmr::vector<utils::pmr::string>;
 
-  Reader() = default;
-  explicit Reader(std::filesystem::path path, Config cfg, utils::MemoryResource *mem = utils::NewDeleteResource())
-      : memory_(mem), path_(std::move(path)) {
-    read_config_.with_header = cfg.with_header;
-    read_config_.ignore_bad = cfg.ignore_bad;
-    read_config_.delimiter = cfg.delimiter ? std::move(*cfg.delimiter) : utils::pmr::string{",", memory_};
-    read_config_.quote = cfg.quote ? std::move(*cfg.quote) : utils::pmr::string{"\"", memory_};
-    InitializeStream();
-    TryInitializeHeader();
-  }
+  explicit Reader(CsvSource source, Config cfg, utils::MemoryResource *mem = utils::NewDeleteResource());
 
   Reader(const Reader &) = delete;
   Reader &operator=(const Reader &) = delete;
@@ -81,28 +113,18 @@ class Reader {
   };
 
   using ParsingResult = utils::BasicResult<ParseError, Row>;
-  [[nodiscard]] bool HasHeader() const;
-  const Header &GetHeader() const;
-  std::optional<Row> GetNextRow(utils::MemoryResource *mem);
+
+  bool HasHeader() const;
+  auto GetHeader() const -> Header const &;
+  auto GetNextRow(utils::MemoryResource *mem) -> std::optional<Row>;
 
  private:
-  utils::MemoryResource *memory_;
-  std::filesystem::path path_;
-  std::ifstream csv_stream_;
-  Config read_config_;
-  uint64_t line_count_{1};
-  uint16_t number_of_columns_{0};
-  Header header_{memory_};
-
-  void InitializeStream();
-
-  void TryInitializeHeader();
-
-  std::optional<utils::pmr::string> GetNextLine(utils::MemoryResource *mem);
-
-  ParsingResult ParseHeader();
-
-  ParsingResult ParseRow(utils::MemoryResource *mem);
+  // Some implementation issues that need clearing up, but this is mainly because
+  // I don't want `boost/iostreams/filtering_stream.hpp` included in this header file
+  // Because it causes issues when combined with antlr headers
+  // When we have C++20 modules this can be fixed
+  struct impl;
+  std::unique_ptr<impl, void (*)(impl *)> pimpl;
 };
 
 }  // namespace memgraph::csv

src/csv/parsing.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -9,33 +9,132 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
 
-#include "utils/csv_parsing.hpp"
+#include "csv/parsing.hpp"
 
 #include <string_view>
 
+#include <boost/iostreams/filter/bzip2.hpp>
+#include <boost/iostreams/filter/gzip.hpp>
+#include <boost/iostreams/filtering_stream.hpp>
+#include <ctre/ctre.hpp>
+
+#include "requests/requests.hpp"
 #include "utils/file.hpp"
+#include "utils/on_scope_exit.hpp"
 #include "utils/string.hpp"
 
+using PlainStream = boost::iostreams::filtering_istream;
+
 namespace memgraph::csv {
 
 using ParseError = Reader::ParseError;
 
-void Reader::InitializeStream() {
-  if (!std::filesystem::exists(path_)) {
-    throw CsvReadException("CSV file not found: {}", path_.string());
-  }
-  csv_stream_.open(path_);
-  if (!csv_stream_.good()) {
-    throw CsvReadException("CSV file {} couldn't be opened!", path_.string());
-  }
+struct Reader::impl {
+  impl(CsvSource source, Reader::Config cfg, utils::MemoryResource *mem);
+
+  [[nodiscard]] bool HasHeader() const { return read_config_.with_header; }
+  [[nodiscard]] auto Header() const -> Header const & { return header_; }
+
+  auto GetNextRow(utils::MemoryResource *mem) -> std::optional<Reader::Row>;
+
+ private:
+  void InitializeStream();
+
+  void TryInitializeHeader();
+
+  std::optional<utils::pmr::string> GetNextLine(utils::MemoryResource *mem);
+
+  ParsingResult ParseHeader();
+
+  ParsingResult ParseRow(utils::MemoryResource *mem);
+
+  utils::MemoryResource *memory_;
+  std::filesystem::path path_;
+  CsvSource source_;
+  PlainStream csv_stream_;
+  Config read_config_;
+  uint64_t line_count_{1};
+  uint16_t number_of_columns_{0};
+  Reader::Header header_{memory_};
+};
+
+Reader::impl::impl(CsvSource source, Reader::Config cfg, utils::MemoryResource *mem)
+    : memory_(mem), source_(std::move(source)) {
+  read_config_.with_header = cfg.with_header;
+  read_config_.ignore_bad = cfg.ignore_bad;
+  read_config_.delimiter = cfg.delimiter ? std::move(*cfg.delimiter) : utils::pmr::string{",", memory_};
+  read_config_.quote = cfg.quote ? std::move(*cfg.quote) : utils::pmr::string{"\"", memory_};
+  InitializeStream();
+  TryInitializeHeader();
 }
 
-std::optional<utils::pmr::string> Reader::GetNextLine(utils::MemoryResource *mem) {
+enum class CompressionMethod : uint8_t {
+  NONE,
+  GZip,
+  BZip2,
+};
+
+/// Detect compression based on magic sequences
+auto DetectCompressionMethod(std::istream &is) -> CompressionMethod {
+  // Ensure stream is reset
+  auto const on_exit = utils::OnScopeExit{[&]() { is.seekg(std::ios::beg); }};
+
+  // Note we must use bytes for comparison, not char
+  //
+  std::byte c{};  // this gets reused
+  auto const next_byte = [&](std::byte &b) { return bool(is.get(reinterpret_cast<char &>(b))); };
+  if (!next_byte(c)) return CompressionMethod::NONE;
+
+  auto const as_bytes = []<typename... Args>(Args... args) {
+    return std::array<std::byte, sizeof...(Args)>{std::byte(args)...};
+  };
+
+  // Gzip - 0x1F8B
+  constexpr static auto gzip_seq = as_bytes(0x1F, 0x8B);
+  if (c == gzip_seq[0]) {
+    if (!next_byte(c) || c != gzip_seq[1]) return CompressionMethod::NONE;
+    return CompressionMethod::GZip;
+  }
+
+  // BZip2 - 0x425A68
+  constexpr static auto bzip_seq = as_bytes(0x42, 0x5A, 0x68);
+  if (c == bzip_seq[0]) {
+    if (!next_byte(c) || c != bzip_seq[1]) return CompressionMethod::NONE;
+    if (!next_byte(c) || c != bzip_seq[2]) return CompressionMethod::NONE;
+    return CompressionMethod::BZip2;
+  }
+  return CompressionMethod::NONE;
+}
+
+Reader::Reader(CsvSource source, Reader::Config cfg, utils::MemoryResource *mem)
+    : pimpl{new impl{std::move(source), std::move(cfg), mem}, [](impl *p) { delete p; }} {}
+
+void Reader::impl::InitializeStream() {
+  auto &source = source_.GetStream();
+
+  auto const method = DetectCompressionMethod(source);
+  switch (method) {
+    case CompressionMethod::GZip:
+      csv_stream_.push(boost::iostreams::gzip_decompressor{});
+      break;
+    case CompressionMethod::BZip2:
+      csv_stream_.push(boost::iostreams::bzip2_decompressor{});
+      break;
+    default:
+      break;
+  }
+
+  csv_stream_.push(source);
+  MG_ASSERT(csv_stream_.auto_close(), "Should be 'auto close' for correct operation");
+  MG_ASSERT(csv_stream_.is_complete(), "Should be 'complete' for correct operation");
+}
+
+std::optional<utils::pmr::string> Reader::impl::GetNextLine(utils::MemoryResource *mem) {
   utils::pmr::string line(mem);
   if (!std::getline(csv_stream_, line)) {
     // reached end of file or an I/0 error occurred
     if (!csv_stream_.good()) {
-      csv_stream_.close();
+      csv_stream_.reset();  // this will close the file_stream_ and clear the chain
     }
     return std::nullopt;
   }
@@ -43,13 +142,13 @@ std::optional<utils::pmr::string> Reader::GetNextLine(utils::MemoryResource *mem
   return std::move(line);
 }
 
-Reader::ParsingResult Reader::ParseHeader() {
+Reader::ParsingResult Reader::impl::ParseHeader() {
   // header must be the very first line in the file
   MG_ASSERT(line_count_ == 1, "Invalid use of {}", __func__);
   return ParseRow(memory_);
 }
 
-void Reader::TryInitializeHeader() {
+void Reader::impl::TryInitializeHeader() {
   if (!HasHeader()) {
     return;
   }
@@ -67,16 +166,16 @@ void Reader::TryInitializeHeader() {
   header_ = std::move(*header);
 }
 
-[[nodiscard]] bool Reader::HasHeader() const { return read_config_.with_header; }
+[[nodiscard]] bool Reader::HasHeader() const { return pimpl->HasHeader(); }
 
-const Reader::Header &Reader::GetHeader() const { return header_; }
+const Reader::Header &Reader::GetHeader() const { return pimpl->Header(); }
 
 namespace {
 enum class CsvParserState : uint8_t { INITIAL_FIELD, NEXT_FIELD, QUOTING, EXPECT_DELIMITER, DONE };
 
 }  // namespace
 
-Reader::ParsingResult Reader::ParseRow(utils::MemoryResource *mem) {
+Reader::ParsingResult Reader::impl::ParseRow(utils::MemoryResource *mem) {
   utils::pmr::vector<utils::pmr::string> row(mem);
   if (number_of_columns_ != 0) {
     row.reserve(number_of_columns_);
@@ -140,9 +239,10 @@ Reader::ParsingResult Reader::ParseRow(utils::MemoryResource *mem) {
           break;
         }
         case CsvParserState::QUOTING: {
+          const auto quote_size = read_config_.quote->size();
           const auto quote_now = utils::StartsWith(line_string_view, *read_config_.quote);
-          const auto quote_next =
-              utils::StartsWith(line_string_view.substr(read_config_.quote->size()), *read_config_.quote);
+          const auto quote_next = quote_size <= line_string_view.size() &&
+                                  utils::StartsWith(line_string_view.substr(quote_size), *read_config_.quote);
           if (quote_now && quote_next) {
             // This is an escaped quote character.
             column += *read_config_.quote;
@@ -216,12 +316,7 @@ Reader::ParsingResult Reader::ParseRow(utils::MemoryResource *mem) {
   return std::move(row);
 }
 
-// Returns Reader::Row if the read row if valid;
-// Returns std::nullopt if end of file is reached or an error occurred
-// making it unreadable;
-// @throws CsvReadException if a bad row is encountered, and the ignore_bad is set
-// to 'true' in the Reader::Config.
-std::optional<Reader::Row> Reader::GetNextRow(utils::MemoryResource *mem) {
+std::optional<Reader::Row> Reader::impl::GetNextRow(utils::MemoryResource *mem) {
   auto row = ParseRow(mem);
 
   if (row.HasError()) {
@@ -245,4 +340,44 @@ std::optional<Reader::Row> Reader::GetNextRow(utils::MemoryResource *mem) {
   return std::move(*row);
 }
 
+// Returns Reader::Row if the read row if valid;
+// Returns std::nullopt if end of file is reached or an error occurred
+// making it unreadable;
+// @throws CsvReadException if a bad row is encountered, and the ignore_bad is set
+// to 'true' in the Reader::Config.
+std::optional<Reader::Row> Reader::GetNextRow(utils::MemoryResource *mem) { return pimpl->GetNextRow(mem); }
+
+FileCsvSource::FileCsvSource(std::filesystem::path path) : path_(std::move(path)) {
+  if (!std::filesystem::exists(path_)) {
+    throw CsvReadException("CSV file not found: {}", path_.string());
+  }
+  stream_.open(path_);
+  if (!stream_.good()) {
+    throw CsvReadException("CSV file {} couldn't be opened!", path_.string());
+  }
+}
+std::istream &FileCsvSource::GetStream() { return stream_; }
+
+std::istream &CsvSource::GetStream() {
+  return *std::visit([](auto &&source) { return std::addressof(source.GetStream()); }, source_);
+}
+
+auto CsvSource::Create(const utils::pmr::string &csv_location) -> CsvSource {
+  constexpr auto protocol_matcher = ctre::starts_with<"(https?|ftp)://">;
+  if (protocol_matcher(csv_location)) {
+    return csv::UrlCsvSource{csv_location.c_str()};
+  }
+  return csv::FileCsvSource{csv_location};
+}
+
+// Helper for UrlCsvSource
+auto urlToStringStream(const char *url) -> std::stringstream {
+  auto ss = std::stringstream{};
+  if (!requests::DownloadToStream(url, ss)) {
+    throw CsvReadException("CSV was unable to be fetched from {}", url);
+  }
+  return ss;
+};
+
+UrlCsvSource::UrlCsvSource(const char *url) : StreamCsvSource{urlToStringStream(url)} {}
 }  // namespace memgraph::csv

src/glue/auth.cpp

@@ -58,6 +58,8 @@ auth::Permission PrivilegeToPermission(query::AuthQuery::Privilege privilege) {
       return auth::Permission::MODULE_WRITE;
     case query::AuthQuery::Privilege::WEBSOCKET:
       return auth::Permission::WEBSOCKET;
+    case query::AuthQuery::Privilege::STORAGE_MODE:
+      return auth::Permission::STORAGE_MODE;
     case query::AuthQuery::Privilege::TRANSACTION_MANAGEMENT:
       return auth::Permission::TRANSACTION_MANAGEMENT;
   }

src/glue/communication.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -150,7 +150,9 @@ storage::Result<communication::bolt::Vertex> ToBoltVertex(const storage::VertexA
   for (const auto &prop : *maybe_properties) {
     properties[db.PropertyToName(prop.first)] = ToBoltValue(prop.second);
   }
-  return communication::bolt::Vertex{id, labels, properties};
+  // Introduced in Bolt v5 (for now just send the ID)
+  const auto element_id = std::to_string(id.AsInt());
+  return communication::bolt::Vertex{id, labels, properties, element_id};
 }
 
 storage::Result<communication::bolt::Edge> ToBoltEdge(const storage::EdgeAccessor &edge, const storage::Storage &db,
@@ -165,7 +167,11 @@ storage::Result<communication::bolt::Edge> ToBoltEdge(const storage::EdgeAccesso
   for (const auto &prop : *maybe_properties) {
     properties[db.PropertyToName(prop.first)] = ToBoltValue(prop.second);
   }
-  return communication::bolt::Edge{id, from, to, type, properties};
+  // Introduced in Bolt v5 (for now just send the ID)
+  const auto element_id = std::to_string(id.AsInt());
+  const auto from_element_id = std::to_string(from.AsInt());
+  const auto to_element_id = std::to_string(to.AsInt());
+  return communication::bolt::Edge{id, from, to, type, properties, element_id, from_element_id, to_element_id};
 }
 
 storage::Result<communication::bolt::Path> ToBoltPath(const query::Path &path, const storage::Storage &db,

src/http_handlers/CMakeLists.txt

@@ -0,0 +1,4 @@
+set(mg_http_handlers_sources)
+
+add_library(mg-http-handlers STATIC ${mg_http_handlers_sources})
+target_link_libraries(mg-http-handlers mg-query mg-storage-v2)

src/http_handlers/metrics.hpp

@@ -0,0 +1,211 @@
+// Copyright 2023 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 <atomic>
+#include <tuple>
+#include <vector>
+
+#include <spdlog/spdlog.h>
+#include <boost/beast/http.hpp>
+#include <boost/beast/version.hpp>
+#include <json/json.hpp>
+
+#include <utils/event_counter.hpp>
+#include <utils/event_gauge.hpp>
+#include "storage/v2/storage.hpp"
+#include "utils/event_gauge.hpp"
+#include "utils/event_histogram.hpp"
+
+namespace memgraph::http {
+
+struct MetricsResponse {
+  uint64_t vertex_count;
+  uint64_t edge_count;
+  double average_degree;
+  uint64_t memory_usage;
+  uint64_t disk_usage;
+
+  // Storage of all the counter values throughout the system
+  // e.g. number of active transactions
+  std::vector<std::tuple<std::string, std::string, uint64_t>> event_counters{};
+
+  // Storage of all the current values throughout the system
+  std::vector<std::tuple<std::string, std::string, uint64_t>> event_gauges{};
+
+  // Storage of all the percentile values across the histograms in the system
+  // e.g. query latency percentiles, snapshot recovery duration percentiles, etc.
+  std::vector<std::tuple<std::string, std::string, uint64_t>> event_histograms{};
+};
+
+template <typename TSessionData>
+class MetricsService {
+ public:
+  explicit MetricsService(TSessionData *data) : db_(data->interpreter_context->db.get()) {}
+
+  nlohmann::json GetMetricsJSON() {
+    auto response = GetMetrics();
+    return AsJson(response);
+  }
+
+ private:
+  const storage::Storage *db_;
+
+  MetricsResponse GetMetrics() {
+    auto info = db_->GetInfo();
+
+    return MetricsResponse{.vertex_count = info.vertex_count,
+                           .edge_count = info.edge_count,
+                           .average_degree = info.average_degree,
+                           .memory_usage = info.memory_usage,
+                           .disk_usage = info.disk_usage,
+                           .event_counters = GetEventCounters(),
+                           .event_gauges = GetEventGauges(),
+                           .event_histograms = GetEventHistograms()};
+  }
+
+  nlohmann::json AsJson(MetricsResponse response) {
+    auto metrics_response = nlohmann::json();
+    const auto *general_type = "General";
+
+    metrics_response[general_type]["vertex_count"] = response.vertex_count;
+    metrics_response[general_type]["edge_count"] = response.edge_count;
+    metrics_response[general_type]["average_degree"] = response.average_degree;
+    metrics_response[general_type]["memory_usage"] = response.memory_usage;
+    metrics_response[general_type]["disk_usage"] = response.disk_usage;
+
+    for (const auto &[name, type, value] : response.event_counters) {
+      metrics_response[type][name] = value;
+    }
+
+    for (const auto &[name, type, value] : response.event_gauges) {
+      metrics_response[type][name] = value;
+    }
+
+    for (const auto &[name, type, value] : response.event_histograms) {
+      metrics_response[type][name] = value;
+    }
+
+    return metrics_response;
+  }
+
+  auto GetEventCounters() {
+    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+    std::vector<std::tuple<std::string, std::string, uint64_t>> event_counters{};
+
+    for (auto i = 0; i < memgraph::metrics::CounterEnd(); i++) {
+      event_counters.emplace_back(memgraph::metrics::GetCounterName(i), memgraph::metrics::GetCounterType(i),
+                                  memgraph::metrics::global_counters[i].load(std::memory_order_acquire));
+    }
+
+    return event_counters;
+  }
+
+  auto GetEventGauges() {
+    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+    std::vector<std::tuple<std::string, std::string, uint64_t>> event_gauges{};
+
+    for (auto i = 0; i < memgraph::metrics::GaugeEnd(); i++) {
+      event_gauges.emplace_back(memgraph::metrics::GetGaugeName(i), memgraph::metrics::GetGaugeType(i),
+                                memgraph::metrics::global_gauges[i].load(std::memory_order_acquire));
+    }
+
+    return event_gauges;
+  }
+
+  auto GetEventHistograms() {
+    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+    std::vector<std::tuple<std::string, std::string, uint64_t>> event_histograms{};
+
+    for (auto i = 0; i < memgraph::metrics::HistogramEnd(); i++) {
+      const auto *name = memgraph::metrics::GetHistogramName(i);
+      auto &histogram = memgraph::metrics::global_histograms[i];
+
+      for (auto &[percentile, value] : histogram.YieldPercentiles()) {
+        auto metric_name = std::string(name) + "_" + std::to_string(percentile) + "p";
+
+        event_histograms.emplace_back(metric_name, memgraph::metrics::GetHistogramType(i), value);
+      }
+    }
+
+    return event_histograms;
+  }
+};
+
+template <typename TSessionData>
+class MetricsRequestHandler final {
+ public:
+  explicit MetricsRequestHandler(TSessionData *data) : service_(data) {
+    spdlog::info("Basic request handler started!");
+  }
+
+  MetricsRequestHandler(const MetricsRequestHandler &) = delete;
+  MetricsRequestHandler(MetricsRequestHandler &&) = delete;
+  MetricsRequestHandler &operator=(const MetricsRequestHandler &) = delete;
+  MetricsRequestHandler &operator=(MetricsRequestHandler &&) = delete;
+  ~MetricsRequestHandler() = default;
+
+  template <class Body, class Allocator>
+  // NOLINTNEXTLINE(misc-unused-parameters)
+  void HandleRequest(boost::beast::http::request<Body, boost::beast::http::basic_fields<Allocator>> &&req,
+                     std::function<void(boost::beast::http::response<boost::beast::http::string_body>)> &&send) {
+    auto response_json = nlohmann::json();
+    // Returns a bad request response
+    auto const bad_request = [&req, &response_json](const auto why) {
+      response_json["error"] = std::string(why);
+
+      // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+      boost::beast::http::response<boost::beast::http::string_body> res{boost::beast::http::status::bad_request,
+                                                                        req.version()};
+      res.set(boost::beast::http::field::server, BOOST_BEAST_VERSION_STRING);
+      res.set(boost::beast::http::field::content_type, "application/json");
+      res.keep_alive(req.keep_alive());
+      res.body() = response_json.dump();
+      res.prepare_payload();
+      return res;
+    };
+
+    // Make sure we can handle the method
+    if (req.method() != boost::beast::http::verb::get) {
+      return send(bad_request("Unknown HTTP-method"));
+    }
+
+    // Request path must be absolute and not contain "..".
+    if (req.target().empty() || req.target()[0] != '/' || req.target().find("..") != boost::beast::string_view::npos) {
+      return send(bad_request("Illegal request-target"));
+    }
+
+    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+    boost::beast::http::string_body::value_type body;
+
+    auto service_response = service_.GetMetricsJSON();
+    body.append(service_response.dump());
+
+    // Cache the size since we need it after the move
+    const auto size = body.size();
+
+    // Respond to GET request
+    // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+    boost::beast::http::response<boost::beast::http::string_body> res{
+        std::piecewise_construct, std::make_tuple(std::move(body)),
+        std::make_tuple(boost::beast::http::status::ok, req.version())};
+    res.set(boost::beast::http::field::server, BOOST_BEAST_VERSION_STRING);
+    res.set(boost::beast::http::field::content_type, "application/json");
+    res.content_length(size);
+    res.keep_alive(req.keep_alive());
+    return send(std::move(res));
+  }
+
+ private:
+  MetricsService<TSessionData> service_;
+};
+}  // namespace memgraph::http

src/memgraph.cpp

@@ -34,13 +34,16 @@
 #include <spdlog/sinks/dist_sink.h>
 #include <spdlog/sinks/stdout_color_sinks.h>
 
+#include "audit/log.hpp"
 #include "auth/models.hpp"
 #include "communication/bolt/v1/constants.hpp"
+#include "communication/http/server.hpp"
 #include "communication/websocket/auth.hpp"
 #include "communication/websocket/server.hpp"
 #include "glue/auth_checker.hpp"
 #include "glue/auth_handler.hpp"
 #include "helpers.hpp"
+#include "http_handlers/metrics.hpp"
 #include "license/license.hpp"
 #include "license/license_sender.hpp"
 #include "py/py.hpp"
@@ -53,10 +56,14 @@
 #include "query/procedure/module.hpp"
 #include "query/procedure/py_module.hpp"
 #include "requests/requests.hpp"
+#include "storage/v2/config.hpp"
+#include "storage/v2/disk/storage.hpp"
+#include "storage/v2/inmemory/storage.hpp"
 #include "storage/v2/isolation_level.hpp"
 #include "storage/v2/storage.hpp"
 #include "storage/v2/view.hpp"
 #include "telemetry/telemetry.hpp"
+#include "utils/enum.hpp"
 #include "utils/event_counter.hpp"
 #include "utils/file.hpp"
 #include "utils/flag_validation.hpp"
@@ -95,50 +102,10 @@
 #include "auth/auth.hpp"
 #include "glue/auth.hpp"
 
-#ifdef MG_ENTERPRISE
-#include "audit/log.hpp"
-#endif
-
 constexpr const char *kMgUser = "MEMGRAPH_USER";
 constexpr const char *kMgPassword = "MEMGRAPH_PASSWORD";
 constexpr const char *kMgPassfile = "MEMGRAPH_PASSFILE";
 
-namespace {
-std::string GetAllowedEnumValuesString(const auto &mappings) {
-  std::vector<std::string> allowed_values;
-  allowed_values.reserve(mappings.size());
-  std::transform(mappings.begin(), mappings.end(), std::back_inserter(allowed_values),
-                 [](const auto &mapping) { return std::string(mapping.first); });
-  return memgraph::utils::Join(allowed_values, ", ");
-}
-
-enum class ValidationError : uint8_t { EmptyValue, InvalidValue };
-
-memgraph::utils::BasicResult<ValidationError> IsValidEnumValueString(const auto &value, const auto &mappings) {
-  if (value.empty()) {
-    return ValidationError::EmptyValue;
-  }
-
-  if (std::find_if(mappings.begin(), mappings.end(), [&](const auto &mapping) { return mapping.first == value; }) ==
-      mappings.cend()) {
-    return ValidationError::InvalidValue;
-  }
-
-  return {};
-}
-
-template <typename Enum>
-std::optional<Enum> StringToEnum(const auto &value, const auto &mappings) {
-  const auto mapping_iter =
-      std::find_if(mappings.begin(), mappings.end(), [&](const auto &mapping) { return mapping.first == value; });
-  if (mapping_iter == mappings.cend()) {
-    return std::nullopt;
-  }
-
-  return mapping_iter->second;
-}
-}  // namespace
-
 // Short help flag.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_HIDDEN_bool(h, false, "Print usage and exit.");
@@ -148,6 +115,9 @@ DEFINE_string(bolt_address, "0.0.0.0", "IP address on which the Bolt server shou
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_string(monitoring_address, "0.0.0.0",
               "IP address on which the websocket server for Memgraph monitoring should listen.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_string(metrics_address, "0.0.0.0",
+              "IP address on which the Memgraph server for exposing metrics should listen.");
 DEFINE_VALIDATED_int32(bolt_port, 7687, "Port on which the Bolt server should listen.",
                        FLAG_IN_RANGE(0, std::numeric_limits<uint16_t>::max()));
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -155,6 +125,9 @@ DEFINE_VALIDATED_int32(monitoring_port, 7444,
                        "Port on which the websocket server for Memgraph monitoring should listen.",
                        FLAG_IN_RANGE(0, std::numeric_limits<uint16_t>::max()));
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_int32(metrics_port, 9091, "Port on which the Memgraph server for exposing metrics should listen.",
+                       FLAG_IN_RANGE(0, std::numeric_limits<uint16_t>::max()));
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_VALIDATED_int32(bolt_num_workers, std::max(std::thread::hardware_concurrency(), 1U),
                        "Number of workers used by the Bolt server. By default, this will be the "
                        "number of processing units available on the machine.",
@@ -227,6 +200,20 @@ DEFINE_VALIDATED_uint64(storage_wal_file_flush_every_n_tx,
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_bool(storage_snapshot_on_exit, false, "Controls whether the storage creates another snapshot on exit.");
 
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_uint64(storage_items_per_batch, memgraph::storage::Config::Durability().items_per_batch,
+              "The number of edges and vertices stored in a batch in a snapshot file.");
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(storage_parallel_index_recovery, false,
+            "Controls whether the index creation can be done in a multithreaded fashion.");
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_uint64(storage_recovery_thread_count,
+              std::max(static_cast<uint64_t>(std::thread::hardware_concurrency()),
+                       memgraph::storage::Config::Durability().recovery_thread_count),
+              "The number of threads used to recover persisted data from disk.");
+
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_bool(telemetry_enabled, false,
             "Set to true to enable telemetry. We collect information about the "
@@ -274,6 +261,8 @@ DEFINE_double(query_execution_timeout_sec, 600,
 DEFINE_uint64(replication_replica_check_frequency_sec, 1,
               "The time duration between two replica checks/pings. If < 1, replicas will NOT be checked at all. NOTE: "
               "The MAIN instance allocates a new thread for each REPLICA.");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_bool(replication_restore_state_on_startup, false, "Restore replication state on startup, e.g. recover replica");
 
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_uint64(
@@ -290,21 +279,21 @@ inline constexpr std::array isolation_level_mappings{
 
 const std::string isolation_level_help_string =
     fmt::format("Default isolation level used for the transactions. Allowed values: {}",
-                GetAllowedEnumValuesString(isolation_level_mappings));
+                memgraph::utils::GetAllowedEnumValuesString(isolation_level_mappings));
 }  // namespace
 
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_VALIDATED_string(isolation_level, "SNAPSHOT_ISOLATION", isolation_level_help_string.c_str(), {
-  if (const auto result = IsValidEnumValueString(value, isolation_level_mappings); result.HasError()) {
+  if (const auto result = memgraph::utils::IsValidEnumValueString(value, isolation_level_mappings); result.HasError()) {
     const auto error = result.GetError();
     switch (error) {
-      case ValidationError::EmptyValue: {
+      case memgraph::utils::ValidationError::EmptyValue: {
         std::cout << "Isolation level cannot be empty." << std::endl;
         break;
       }
-      case ValidationError::InvalidValue: {
+      case memgraph::utils::ValidationError::InvalidValue: {
         std::cout << "Invalid value for isolation level. Allowed values: "
-                  << GetAllowedEnumValuesString(isolation_level_mappings) << std::endl;
+                  << memgraph::utils::GetAllowedEnumValuesString(isolation_level_mappings) << std::endl;
         break;
       }
     }
@@ -317,7 +306,7 @@ DEFINE_VALIDATED_string(isolation_level, "SNAPSHOT_ISOLATION", isolation_level_h
 namespace {
 memgraph::storage::IsolationLevel ParseIsolationLevel() {
   const auto isolation_level =
-      StringToEnum<memgraph::storage::IsolationLevel>(FLAGS_isolation_level, isolation_level_mappings);
+      memgraph::utils::StringToEnum<memgraph::storage::IsolationLevel>(FLAGS_isolation_level, isolation_level_mappings);
   MG_ASSERT(isolation_level, "Invalid isolation level");
   return *isolation_level;
 }
@@ -377,21 +366,21 @@ inline constexpr std::array log_level_mappings{
     std::pair{"INFO"sv, spdlog::level::info},   std::pair{"WARNING"sv, spdlog::level::warn},
     std::pair{"ERROR"sv, spdlog::level::err},   std::pair{"CRITICAL"sv, spdlog::level::critical}};
 
-const std::string log_level_help_string =
-    fmt::format("Minimum log level. Allowed values: {}", GetAllowedEnumValuesString(log_level_mappings));
+const std::string log_level_help_string = fmt::format("Minimum log level. Allowed values: {}",
+                                                      memgraph::utils::GetAllowedEnumValuesString(log_level_mappings));
 }  // namespace
 
 DEFINE_VALIDATED_string(log_level, "WARNING", log_level_help_string.c_str(), {
-  if (const auto result = IsValidEnumValueString(value, log_level_mappings); result.HasError()) {
+  if (const auto result = memgraph::utils::IsValidEnumValueString(value, log_level_mappings); result.HasError()) {
     const auto error = result.GetError();
     switch (error) {
-      case ValidationError::EmptyValue: {
+      case memgraph::utils::ValidationError::EmptyValue: {
         std::cout << "Log level cannot be empty." << std::endl;
         break;
       }
-      case ValidationError::InvalidValue: {
-        std::cout << "Invalid value for log level. Allowed values: " << GetAllowedEnumValuesString(log_level_mappings)
-                  << std::endl;
+      case memgraph::utils::ValidationError::InvalidValue: {
+        std::cout << "Invalid value for log level. Allowed values: "
+                  << memgraph::utils::GetAllowedEnumValuesString(log_level_mappings) << std::endl;
         break;
       }
     }
@@ -403,7 +392,7 @@ DEFINE_VALIDATED_string(log_level, "WARNING", log_level_help_string.c_str(), {
 
 namespace {
 spdlog::level::level_enum ParseLogLevel() {
-  const auto log_level = StringToEnum<spdlog::level::level_enum>(FLAGS_log_level, log_level_mappings);
+  const auto log_level = memgraph::utils::StringToEnum<spdlog::level::level_enum>(FLAGS_log_level, log_level_mappings);
   MG_ASSERT(log_level, "Invalid log level");
   return *log_level;
 }
@@ -459,21 +448,19 @@ struct SessionData {
   // supplied.
 #if MG_ENTERPRISE
 
-  SessionData(memgraph::storage::Storage *db, memgraph::query::InterpreterContext *interpreter_context,
+  SessionData(memgraph::query::InterpreterContext *interpreter_context,
               memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
               memgraph::audit::Log *audit_log)
-      : db(db), interpreter_context(interpreter_context), auth(auth), audit_log(audit_log) {}
-  memgraph::storage::Storage *db;
+      : interpreter_context(interpreter_context), auth(auth), audit_log(audit_log) {}
   memgraph::query::InterpreterContext *interpreter_context;
   memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth;
   memgraph::audit::Log *audit_log;
 
 #else
 
-  SessionData(memgraph::storage::Storage *db, memgraph::query::InterpreterContext *interpreter_context,
+  SessionData(memgraph::query::InterpreterContext *interpreter_context,
               memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth)
-      : db(db), interpreter_context(interpreter_context), auth(auth) {}
-  memgraph::storage::Storage *db;
+      : interpreter_context(interpreter_context), auth(auth) {}
   memgraph::query::InterpreterContext *interpreter_context;
   memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth;
 
@@ -486,33 +473,36 @@ struct SessionData {
 DEFINE_string(auth_user_or_role_name_regex, memgraph::glue::kDefaultUserRoleRegex.data(),
               "Set to the regular expression that each user or role name must fulfill.");
 
-void InitFromCypherlFile(memgraph::query::InterpreterContext &ctx, std::string cypherl_file_path
-#ifdef MG_ENTERPRISE
-                         ,
-                         memgraph::audit::Log *audit_log
-#endif
-) {
+void InitFromCypherlFile(memgraph::query::InterpreterContext &ctx, std::string cypherl_file_path,
+                         memgraph::audit::Log *audit_log = nullptr) {
   memgraph::query::Interpreter interpreter(&ctx);
   std::ifstream file(cypherl_file_path);
-  if (file.is_open()) {
-    std::string line;
-    while (std::getline(file, line)) {
-      if (!line.empty()) {
-        auto results = interpreter.Prepare(line, {}, {});
-        memgraph::query::DiscardValueResultStream stream;
-        interpreter.Pull(&stream, {}, results.qid);
 
-#ifdef MG_ENTERPRISE
-        if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
-          audit_log->Record("", "", line, {});
-        }
-#endif
+  if (!file.is_open()) {
+    spdlog::trace("Could not find init file {}", cypherl_file_path);
+    return;
+  }
+
+  std::string line;
+  while (std::getline(file, line)) {
+    if (!line.empty()) {
+      auto results = interpreter.Prepare(line, {}, {});
+      memgraph::query::DiscardValueResultStream stream;
+      interpreter.Pull(&stream, {}, results.qid);
+
+      if (audit_log) {
+        audit_log->Record("", "", line, {});
       }
     }
-    file.close();
   }
+
+  file.close();
 }
 
+namespace memgraph::metrics {
+extern const Event ActiveBoltSessions;
+}  // namespace memgraph::metrics
+
 class BoltSession final : public memgraph::communication::bolt::Session<memgraph::communication::v2::InputStream,
                                                                         memgraph::communication::v2::OutputStream> {
  public:
@@ -521,7 +511,6 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
               memgraph::communication::v2::OutputStream *output_stream)
       : memgraph::communication::bolt::Session<memgraph::communication::v2::InputStream,
                                                memgraph::communication::v2::OutputStream>(input_stream, output_stream),
-        db_(data->db),
         interpreter_context_(data->interpreter_context),
         interpreter_(data->interpreter_context),
         auth_(data->auth),
@@ -530,26 +519,41 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
 #endif
         endpoint_(endpoint),
         run_id_(data->run_id) {
+    memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveBoltSessions);
     interpreter_context_->interpreters.WithLock([this](auto &interpreters) { interpreters.insert(&interpreter_); });
   }
 
   ~BoltSession() override {
+    memgraph::metrics::DecrementCounter(memgraph::metrics::ActiveBoltSessions);
     interpreter_context_->interpreters.WithLock([this](auto &interpreters) { interpreters.erase(&interpreter_); });
   }
 
   using memgraph::communication::bolt::Session<memgraph::communication::v2::InputStream,
                                                memgraph::communication::v2::OutputStream>::TEncoder;
 
-  void BeginTransaction() override { interpreter_.BeginTransaction(); }
+  void BeginTransaction(const std::map<std::string, memgraph::communication::bolt::Value> &metadata) override {
+    std::map<std::string, memgraph::storage::PropertyValue> metadata_pv;
+    for (const auto &[key, bolt_value] : metadata) {
+      metadata_pv.emplace(key, memgraph::glue::ToPropertyValue(bolt_value));
+    }
+    interpreter_.BeginTransaction(metadata_pv);
+  }
 
   void CommitTransaction() override { interpreter_.CommitTransaction(); }
 
   void RollbackTransaction() override { interpreter_.RollbackTransaction(); }
 
   std::pair<std::vector<std::string>, std::optional<int>> Interpret(
-      const std::string &query, const std::map<std::string, memgraph::communication::bolt::Value> &params) override {
+      const std::string &query, const std::map<std::string, memgraph::communication::bolt::Value> &params,
+      const std::map<std::string, memgraph::communication::bolt::Value> &metadata) override {
     std::map<std::string, memgraph::storage::PropertyValue> params_pv;
-    for (const auto &kv : params) params_pv.emplace(kv.first, memgraph::glue::ToPropertyValue(kv.second));
+    std::map<std::string, memgraph::storage::PropertyValue> metadata_pv;
+    for (const auto &[key, bolt_param] : params) {
+      params_pv.emplace(key, memgraph::glue::ToPropertyValue(bolt_param));
+    }
+    for (const auto &[key, bolt_md] : metadata) {
+      metadata_pv.emplace(key, memgraph::glue::ToPropertyValue(bolt_md));
+    }
     const std::string *username{nullptr};
     if (user_) {
       username = &user_->username();
@@ -561,7 +565,7 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
     }
 #endif
     try {
-      auto result = interpreter_.Prepare(query, params_pv, username);
+      auto result = interpreter_.Prepare(query, params_pv, username, metadata_pv);
       if (user_ && !memgraph::glue::AuthChecker::IsUserAuthorized(*user_, result.privileges)) {
         interpreter_.Abort();
         throw memgraph::communication::bolt::ClientError(
@@ -581,7 +585,7 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
 
   std::map<std::string, memgraph::communication::bolt::Value> Pull(TEncoder *encoder, std::optional<int> n,
                                                                    std::optional<int> qid) override {
-    TypedValueResultStream stream(encoder, db_);
+    TypedValueResultStream stream(encoder, interpreter_context_->db.get());
     return PullResults(stream, n, qid);
   }
 
@@ -615,7 +619,8 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
       const auto &summary = interpreter_.Pull(&stream, n, qid);
       std::map<std::string, memgraph::communication::bolt::Value> decoded_summary;
       for (const auto &kv : summary) {
-        auto maybe_value = memgraph::glue::ToBoltValue(kv.second, *db_, memgraph::storage::View::NEW);
+        auto maybe_value =
+            memgraph::glue::ToBoltValue(kv.second, *interpreter_context_->db, memgraph::storage::View::NEW);
         if (maybe_value.HasError()) {
           switch (maybe_value.GetError()) {
             case memgraph::storage::Error::DELETED_OBJECT:
@@ -679,7 +684,6 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
   };
 
   // NOTE: Needed only for ToBoltValue conversions
-  const memgraph::storage::Storage *db_;
   memgraph::query::InterpreterContext *interpreter_context_;
   memgraph::query::Interpreter interpreter_;
   memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
@@ -693,6 +697,8 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
 };
 
 using ServerT = memgraph::communication::v2::Server<BoltSession, SessionData>;
+using MonitoringServerT =
+    memgraph::communication::http::Server<memgraph::http::MetricsRequestHandler<SessionData>, SessionData>;
 using memgraph::communication::ServerContext;
 
 // Needed to correctly handle memgraph destruction from a signal handler.
@@ -887,8 +893,19 @@ int main(int argc, char **argv) {
                      .wal_file_size_kibibytes = FLAGS_storage_wal_file_size_kib,
                      .wal_file_flush_every_n_tx = FLAGS_storage_wal_file_flush_every_n_tx,
                      .snapshot_on_exit = FLAGS_storage_snapshot_on_exit,
-                     .restore_replicas_on_startup = true},
-      .transaction = {.isolation_level = ParseIsolationLevel()}};
+                     .restore_replication_state_on_startup = FLAGS_replication_restore_state_on_startup,
+                     .items_per_batch = FLAGS_storage_items_per_batch,
+                     .recovery_thread_count = FLAGS_storage_recovery_thread_count,
+                     .allow_parallel_index_creation = FLAGS_storage_parallel_index_recovery},
+      .transaction = {.isolation_level = ParseIsolationLevel()},
+      .disk = {.main_storage_directory = FLAGS_data_directory + "/rocksdb_main_storage",
+               .label_index_directory = FLAGS_data_directory + "/rocksdb_label_index",
+               .label_property_index_directory = FLAGS_data_directory + "/rocksdb_label_property_index",
+               .unique_constraints_directory = FLAGS_data_directory + "/rocksdb_unique_constraints",
+               .name_id_mapper_directory = FLAGS_data_directory + "/rocksdb_name_id_mapper",
+               .id_name_mapper_directory = FLAGS_data_directory + "/rocksdb_id_name_mapper",
+               .durability_directory = FLAGS_data_directory + "/rocksdb_durability",
+               .wal_directory = FLAGS_data_directory + "/rocksdb_wal"}};
   if (FLAGS_storage_snapshot_interval_sec == 0) {
     if (FLAGS_storage_wal_enabled) {
       LOG_FATAL(
@@ -907,10 +924,9 @@ int main(int argc, char **argv) {
     }
     db_config.durability.snapshot_interval = std::chrono::seconds(FLAGS_storage_snapshot_interval_sec);
   }
-  memgraph::storage::Storage db(db_config);
 
   memgraph::query::InterpreterContext interpreter_context{
-      &db,
+      db_config,
       {.query = {.allow_load_csv = FLAGS_allow_load_csv},
        .execution_timeout_sec = FLAGS_query_execution_timeout_sec,
        .replication_replica_check_frequency = std::chrono::seconds(FLAGS_replication_replica_check_frequency_sec),
@@ -920,9 +936,9 @@ int main(int argc, char **argv) {
        .stream_transaction_retry_interval = std::chrono::milliseconds(FLAGS_stream_transaction_retry_interval)},
       FLAGS_data_directory};
 #ifdef MG_ENTERPRISE
-  SessionData session_data{&db, &interpreter_context, &auth, &audit_log};
+  SessionData session_data{&interpreter_context, &auth, &audit_log};
 #else
-  SessionData session_data{&db, &interpreter_context, &auth};
+  SessionData session_data{&interpreter_context, &auth};
 #endif
 
   memgraph::query::procedure::gModuleRegistry.SetModulesDirectory(query_modules_directories, FLAGS_data_directory);
@@ -934,10 +950,12 @@ int main(int argc, char **argv) {
   interpreter_context.auth_checker = &auth_checker;
 
   if (!FLAGS_init_file.empty()) {
-    spdlog::info("Running init file.");
+    spdlog::info("Running init file...");
 #ifdef MG_ENTERPRISE
     if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
       InitFromCypherlFile(interpreter_context, FLAGS_init_file, &audit_log);
+    } else {
+      InitFromCypherlFile(interpreter_context, FLAGS_init_file);
     }
 #else
     InitFromCypherlFile(interpreter_context, FLAGS_init_file);
@@ -960,7 +978,7 @@ int main(int argc, char **argv) {
     // Triggers can execute query procedures, so we need to reload the modules first and then
     // the triggers
     auto storage_accessor = interpreter_context.db->Access();
-    auto dba = memgraph::query::DbAccessor{&storage_accessor};
+    auto dba = memgraph::query::DbAccessor{storage_accessor.get()};
     interpreter_context.trigger_store.RestoreTriggers(
         &interpreter_context.ast_cache, &dba, interpreter_context.config.query, interpreter_context.auth_checker);
   }
@@ -993,14 +1011,15 @@ int main(int argc, char **argv) {
   std::optional<memgraph::telemetry::Telemetry> telemetry;
   if (FLAGS_telemetry_enabled) {
     telemetry.emplace(telemetry_server, data_directory / "telemetry", run_id, machine_id, std::chrono::minutes(10));
-    telemetry->AddCollector("storage", [&db]() -> nlohmann::json {
-      auto info = db.GetInfo();
+    telemetry->AddCollector("storage", [db_ = interpreter_context.db.get()]() -> nlohmann::json {
+      auto info = db_->GetInfo();
       return {{"vertices", info.vertex_count}, {"edges", info.edge_count}};
     });
     telemetry->AddCollector("event_counters", []() -> nlohmann::json {
       nlohmann::json ret;
-      for (size_t i = 0; i < EventCounter::End(); ++i) {
-        ret[EventCounter::GetName(i)] = EventCounter::global_counters[i].load(std::memory_order_relaxed);
+      for (size_t i = 0; i < memgraph::metrics::CounterEnd(); ++i) {
+        ret[memgraph::metrics::GetCounterName(i)] =
+            memgraph::metrics::global_counters[i].load(std::memory_order_relaxed);
       }
       return ret;
     });
@@ -1016,6 +1035,43 @@ int main(int argc, char **argv) {
       {FLAGS_monitoring_address, static_cast<uint16_t>(FLAGS_monitoring_port)}, &context, websocket_auth};
   AddLoggerSink(websocket_server.GetLoggingSink());
 
+  MonitoringServerT metrics_server{
+      {FLAGS_metrics_address, static_cast<uint16_t>(FLAGS_metrics_port)}, &session_data, &context};
+
+#ifdef MG_ENTERPRISE
+  if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
+    // Handler for regular termination signals
+    auto shutdown = [&metrics_server, &websocket_server, &server, &interpreter_context] {
+      // Server needs to be shutdown first and then the database. This prevents
+      // a race condition when a transaction is accepted during server shutdown.
+      server.Shutdown();
+      // After the server is notified to stop accepting and processing
+      // connections we tell the execution engine to stop processing all pending
+      // queries.
+      memgraph::query::Shutdown(&interpreter_context);
+
+      websocket_server.Shutdown();
+      metrics_server.Shutdown();
+    };
+
+    InitSignalHandlers(shutdown);
+  } else {
+    // Handler for regular termination signals
+    auto shutdown = [&websocket_server, &server, &interpreter_context] {
+      // Server needs to be shutdown first and then the database. This prevents
+      // a race condition when a transaction is accepted during server shutdown.
+      server.Shutdown();
+      // After the server is notified to stop accepting and processing
+      // connections we tell the execution engine to stop processing all pending
+      // queries.
+      memgraph::query::Shutdown(&interpreter_context);
+
+      websocket_server.Shutdown();
+    };
+
+    InitSignalHandlers(shutdown);
+  }
+#else
   // Handler for regular termination signals
   auto shutdown = [&websocket_server, &server, &interpreter_context] {
     // Server needs to be shutdown first and then the database. This prevents
@@ -1025,19 +1081,29 @@ int main(int argc, char **argv) {
     // connections we tell the execution engine to stop processing all pending
     // queries.
     memgraph::query::Shutdown(&interpreter_context);
+
     websocket_server.Shutdown();
   };
 
   InitSignalHandlers(shutdown);
+#endif
 
   MG_ASSERT(server.Start(), "Couldn't start the Bolt server!");
   websocket_server.Start();
 
+#ifdef MG_ENTERPRISE
+  if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
+    metrics_server.Start();
+  }
+#endif
+
   if (!FLAGS_init_data_file.empty()) {
     spdlog::info("Running init data file.");
 #ifdef MG_ENTERPRISE
     if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
       InitFromCypherlFile(interpreter_context, FLAGS_init_data_file, &audit_log);
+    } else {
+      InitFromCypherlFile(interpreter_context, FLAGS_init_data_file);
     }
 #else
     InitFromCypherlFile(interpreter_context, FLAGS_init_data_file);
@@ -1046,6 +1112,11 @@ int main(int argc, char **argv) {
 
   server.AwaitShutdown();
   websocket_server.AwaitShutdown();
+#ifdef MG_ENTERPRISE
+  if (memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
+    metrics_server.AwaitShutdown();
+  }
+#endif
 
   memgraph::query::procedure::gModuleRegistry.UnloadAllModules();
 

src/mg_import_csv.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -20,7 +20,8 @@
 #include <unordered_map>
 
 #include "helpers.hpp"
-#include "storage/v2/storage.hpp"
+#include "storage/v2/edge_accessor.hpp"
+#include "storage/v2/inmemory/storage.hpp"
 #include "utils/exceptions.hpp"
 #include "utils/logging.hpp"
 #include "utils/message.hpp"
@@ -421,7 +422,7 @@ void ProcessNodeRow(memgraph::storage::Storage *store, const std::vector<std::st
                     std::unordered_map<NodeId, memgraph::storage::Gid> *node_id_map) {
   std::optional<NodeId> id;
   auto acc = store->Access();
-  auto node = acc.CreateVertex();
+  auto node = acc->CreateVertex();
   for (size_t i = 0; i < row.size(); ++i) {
     const auto &field = fields[i];
     const auto &value = row[i];
@@ -436,7 +437,7 @@ void ProcessNodeRow(memgraph::storage::Storage *store, const std::vector<std::st
       if (it != node_id_map->end()) {
         if (FLAGS_skip_duplicate_nodes) {
           spdlog::warn(memgraph::utils::MessageWithLink("Skipping duplicate node with ID '{}'.", node_id,
-                                                        "https://memgr.ph/csv"));
+                                                        "https://memgr.ph/csv-import-tool"));
           return;
         } else {
           throw LoadException("Node with ID '{}' already exists", node_id);
@@ -450,29 +451,29 @@ void ProcessNodeRow(memgraph::storage::Storage *store, const std::vector<std::st
         } else {
           pv_id = memgraph::storage::PropertyValue(node_id.id);
         }
-        auto old_node_property = node.SetProperty(acc.NameToProperty(field.name), pv_id);
+        auto old_node_property = node.SetProperty(acc->NameToProperty(field.name), pv_id);
         if (!old_node_property.HasValue()) throw LoadException("Couldn't add property '{}' to the node", field.name);
         if (!old_node_property->IsNull()) throw LoadException("The property '{}' already exists", field.name);
       }
       id = node_id;
     } else if (field.type == "LABEL") {
       for (const auto &label : memgraph::utils::Split(value, FLAGS_array_delimiter)) {
-        auto node_label = node.AddLabel(acc.NameToLabel(label));
+        auto node_label = node.AddLabel(acc->NameToLabel(label));
         if (!node_label.HasValue()) throw LoadException("Couldn't add label '{}' to the node", label);
         if (!*node_label) throw LoadException("The label '{}' already exists", label);
       }
     } else if (field.type != "IGNORE") {
-      auto old_node_property = node.SetProperty(acc.NameToProperty(field.name), StringToValue(value, field.type));
+      auto old_node_property = node.SetProperty(acc->NameToProperty(field.name), StringToValue(value, field.type));
       if (!old_node_property.HasValue()) throw LoadException("Couldn't add property '{}' to the node", field.name);
       if (!old_node_property->IsNull()) throw LoadException("The property '{}' already exists", field.name);
     }
   }
   for (const auto &label : additional_labels) {
-    auto node_label = node.AddLabel(acc.NameToLabel(label));
+    auto node_label = node.AddLabel(acc->NameToLabel(label));
     if (!node_label.HasValue()) throw LoadException("Couldn't add label '{}' to the node", label);
     if (!*node_label) throw LoadException("The label '{}' already exists", label);
   }
-  if (acc.Commit().HasError()) throw LoadException("Couldn't store the node");
+  if (acc->Commit().HasError()) throw LoadException("Couldn't store the node");
 }
 
 void ProcessNodes(memgraph::storage::Storage *store, const std::string &nodes_path,
@@ -529,7 +530,7 @@ void ProcessRelationshipsRow(memgraph::storage::Storage *store, const std::vecto
       if (it == node_id_map.end()) {
         if (FLAGS_skip_bad_relationships) {
           spdlog::warn(memgraph::utils::MessageWithLink("Skipping bad relationship with START_ID '{}'.", node_id,
-                                                        "https://memgr.ph/csv"));
+                                                        "https://memgr.ph/csv-import-tool"));
           return;
         } else {
           throw LoadException("Node with ID '{}' does not exist", node_id);
@@ -547,7 +548,7 @@ void ProcessRelationshipsRow(memgraph::storage::Storage *store, const std::vecto
       if (it == node_id_map.end()) {
         if (FLAGS_skip_bad_relationships) {
           spdlog::warn(memgraph::utils::MessageWithLink("Skipping bad relationship with END_ID '{}'.", node_id,
-                                                        "https://memgr.ph/csv"));
+                                                        "https://memgr.ph/csv-import-tool"));
           return;
         } else {
           throw LoadException("Node with ID '{}' does not exist", node_id);
@@ -567,16 +568,16 @@ void ProcessRelationshipsRow(memgraph::storage::Storage *store, const std::vecto
   if (!relationship_type) throw LoadException("Relationship TYPE must be set");
 
   auto acc = store->Access();
-  auto from_node = acc.FindVertex(*start_id, memgraph::storage::View::NEW);
+  auto from_node = acc->FindVertex(*start_id, memgraph::storage::View::NEW);
   if (!from_node) throw LoadException("From node must be in the storage");
-  auto to_node = acc.FindVertex(*end_id, memgraph::storage::View::NEW);
+  auto to_node = acc->FindVertex(*end_id, memgraph::storage::View::NEW);
   if (!to_node) throw LoadException("To node must be in the storage");
 
-  auto relationship = acc.CreateEdge(&*from_node, &*to_node, acc.NameToEdgeType(*relationship_type));
+  auto relationship = acc->CreateEdge(&from_node.value(), &to_node.value(), acc->NameToEdgeType(*relationship_type));
   if (!relationship.HasValue()) throw LoadException("Couldn't create the relationship");
 
   for (const auto &property : properties) {
-    auto ret = relationship->SetProperty(acc.NameToProperty(property.first), property.second);
+    auto ret = relationship.GetValue().SetProperty(acc->NameToProperty(property.first), property.second);
     if (!ret.HasValue()) {
       if (ret.GetError() != memgraph::storage::Error::PROPERTIES_DISABLED) {
         throw LoadException("Couldn't add property '{}' to the relationship", property.first);
@@ -589,7 +590,7 @@ void ProcessRelationshipsRow(memgraph::storage::Storage *store, const std::vecto
     }
   }
 
-  if (acc.Commit().HasError()) throw LoadException("Couldn't store the relationship");
+  if (acc->Commit().HasError()) throw LoadException("Couldn't store the relationship");
 }
 
 void ProcessRelationships(memgraph::storage::Storage *store, const std::string &relationships_path,
@@ -699,13 +700,13 @@ int main(int argc, char *argv[]) {
   }
 
   std::unordered_map<NodeId, memgraph::storage::Gid> node_id_map;
-  memgraph::storage::Storage store{{
+  std::unique_ptr<memgraph::storage::Storage> store{new memgraph::storage::InMemoryStorage{{
       .items = {.properties_on_edges = FLAGS_storage_properties_on_edges},
       .durability = {.storage_directory = FLAGS_data_directory,
                      .recover_on_startup = false,
                      .snapshot_wal_mode = memgraph::storage::Config::Durability::SnapshotWalMode::DISABLED,
                      .snapshot_on_exit = true},
-  }};
+  }}};
 
   memgraph::utils::Timer load_timer;
 
@@ -715,7 +716,7 @@ int main(int argc, char *argv[]) {
     std::optional<std::vector<Field>> header;
     for (const auto &nodes_file : files) {
       spdlog::info("Loading {}", nodes_file);
-      ProcessNodes(&store, nodes_file, &header, &node_id_map, additional_labels);
+      ProcessNodes(store.get(), nodes_file, &header, &node_id_map, additional_labels);
     }
   }
 
@@ -725,7 +726,7 @@ int main(int argc, char *argv[]) {
     std::optional<std::vector<Field>> header;
     for (const auto &relationships_file : files) {
       spdlog::info("Loading {}", relationships_file);
-      ProcessRelationships(&store, relationships_file, type, &header, node_id_map);
+      ProcessRelationships(store.get(), relationships_file, type, &header, node_id_map);
     }
   }
 

src/query/CMakeLists.txt

@@ -37,12 +37,9 @@ set(mg_query_sources
     graph.cpp
     db_accessor.cpp)
 
-find_package(Boost REQUIRED)
-
 add_library(mg-query STATIC ${mg_query_sources})
 target_include_directories(mg-query PUBLIC ${CMAKE_SOURCE_DIR}/include)
-target_link_libraries(mg-query dl cppitertools Boost::headers)
-target_link_libraries(mg-query mg-integrations-pulsar mg-integrations-kafka mg-storage-v2 mg-license mg-utils mg-kvstore mg-memory)
+target_link_libraries(mg-query PUBLIC dl cppitertools Python3::Python mg-integrations-pulsar mg-integrations-kafka mg-storage-v2 mg-license mg-utils mg-kvstore mg-memory mg::csv)
 if(NOT "${MG_PYTHON_PATH}" STREQUAL "")
     set(Python3_ROOT_DIR "${MG_PYTHON_PATH}")
 endif()
@@ -51,7 +48,6 @@ if("${MG_PYTHON_VERSION}" STREQUAL "")
 else()
     find_package(Python3 "${MG_PYTHON_VERSION}" EXACT REQUIRED COMPONENTS Development)
 endif()
-target_link_libraries(mg-query Python3::Python)
 
 # Generate Antlr openCypher parser
 
@@ -94,4 +90,4 @@ add_library(antlr_opencypher_parser_lib STATIC ${antlr_opencypher_generated_src}
 add_dependencies(antlr_opencypher_parser_lib generate_opencypher_parser)
 target_link_libraries(antlr_opencypher_parser_lib antlr4)
 
-target_link_libraries(mg-query antlr_opencypher_parser_lib)
+target_link_libraries(mg-query PUBLIC antlr_opencypher_parser_lib)

src/query/constants.hpp

@@ -14,8 +14,6 @@
 #include <string>
 
 namespace memgraph::query {
-inline constexpr uint16_t kDefaultReplicationPort = 10000;
-inline constexpr auto *kDefaultReplicationServerIp = "0.0.0.0";
 inline const std::string kAsterisk = "*";
-inline constexpr uint16_t kDeleteStatisticsNumResults = 6;
+inline constexpr uint16_t kComputeStatisticsNumResults = 7;
 }  // namespace memgraph::query

src/query/context.hpp

@@ -22,6 +22,8 @@
 #include "query/trigger.hpp"
 #include "utils/async_timer.hpp"
 
+#include "query/frame_change.hpp"
+
 namespace memgraph::query {
 
 enum class TransactionStatus {
@@ -82,6 +84,7 @@ struct ExecutionContext {
   plan::ProfilingStats *stats_root{nullptr};
   ExecutionStats execution_stats;
   TriggerContextCollector *trigger_context_collector{nullptr};
+  FrameChangeCollector *frame_change_collector{nullptr};
   utils::AsyncTimer timer;
 #ifdef MG_ENTERPRISE
   std::unique_ptr<FineGrainedAuthChecker> auth_checker{nullptr};

src/query/db_accessor.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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

src/query/db_accessor.hpp

@@ -17,9 +17,11 @@
 #include <cppitertools/imap.hpp>
 
 #include "query/exceptions.hpp"
+#include "storage/v2/edge_accessor.hpp"
 #include "storage/v2/id_types.hpp"
 #include "storage/v2/property_value.hpp"
 #include "storage/v2/result.hpp"
+#include "storage/v2/storage_mode.hpp"
 #include "utils/pmr/unordered_set.hpp"
 #include "utils/variant_helpers.hpp"
 
@@ -347,6 +349,10 @@ class DbAccessor final {
 
   VertexAccessor InsertVertex() { return VertexAccessor(accessor_->CreateVertex()); }
 
+  void PrefetchOutEdges(const VertexAccessor &vertex) const { accessor_->PrefetchOutEdges(vertex.impl_); }
+
+  void PrefetchInEdges(const VertexAccessor &vertex) const { accessor_->PrefetchInEdges(vertex.impl_); }
+
   storage::Result<EdgeAccessor> InsertEdge(VertexAccessor *from, VertexAccessor *to,
                                            const storage::EdgeTypeId &edge_type) {
     auto maybe_edge = accessor_->CreateEdge(&from->impl_, &to->impl_, edge_type);
@@ -372,6 +378,8 @@ class DbAccessor final {
       VertexAccessor *vertex_accessor) {
     using ReturnType = std::pair<VertexAccessor, std::vector<EdgeAccessor>>;
 
+    accessor_->PrefetchOutEdges(vertex_accessor->impl_);
+    accessor_->PrefetchInEdges(vertex_accessor->impl_);
     auto res = accessor_->DetachDeleteVertex(&vertex_accessor->impl_);
     if (res.HasError()) {
       return res.GetError();
@@ -424,28 +432,44 @@ class DbAccessor final {
 
   void Abort() { accessor_->Abort(); }
 
+  storage::StorageMode GetStorageMode() const { return accessor_->GetCreationStorageMode(); }
+
   bool LabelIndexExists(storage::LabelId label) const { return accessor_->LabelIndexExists(label); }
 
   bool LabelPropertyIndexExists(storage::LabelId label, storage::PropertyId prop) const {
     return accessor_->LabelPropertyIndexExists(label, prop);
   }
 
-  std::optional<storage::IndexStats> GetIndexStats(const storage::LabelId &label,
-                                                   const storage::PropertyId &property) const {
+  std::optional<storage::LabelIndexStats> GetIndexStats(const storage::LabelId &label) const {
+    return accessor_->GetIndexStats(label);
+  }
+
+  std::optional<storage::LabelPropertyIndexStats> GetIndexStats(const storage::LabelId &label,
+                                                                const storage::PropertyId &property) const {
     return accessor_->GetIndexStats(label, property);
   }
 
-  std::vector<std::pair<storage::LabelId, storage::PropertyId>> ClearIndexStats() {
-    return accessor_->ClearIndexStats();
+  std::vector<std::pair<storage::LabelId, storage::PropertyId>> ClearLabelPropertyIndexStats() {
+    return accessor_->ClearLabelPropertyIndexStats();
   }
 
-  std::vector<std::pair<storage::LabelId, storage::PropertyId>> DeleteIndexStatsForLabels(
+  std::vector<storage::LabelId> ClearLabelIndexStats() { return accessor_->ClearLabelIndexStats(); }
+
+  std::vector<std::pair<storage::LabelId, storage::PropertyId>> DeleteLabelPropertyIndexStats(
       const std::span<std::string> labels) {
-    return accessor_->DeleteIndexStatsForLabels(labels);
+    return accessor_->DeleteLabelPropertyIndexStats(labels);
+  }
+
+  std::vector<storage::LabelId> DeleteLabelIndexStats(const std::span<std::string> labels) {
+    return accessor_->DeleteLabelIndexStats(labels);
+  }
+
+  void SetIndexStats(const storage::LabelId &label, const storage::LabelIndexStats &stats) {
+    accessor_->SetIndexStats(label, stats);
   }
 
   void SetIndexStats(const storage::LabelId &label, const storage::PropertyId &property,
-                     const storage::IndexStats &stats) {
+                     const storage::LabelPropertyIndexStats &stats) {
     accessor_->SetIndexStats(label, property, stats);
   }
 
@@ -494,6 +518,10 @@ class SubgraphDbAccessor final {
 
   const std::string &EdgeTypeToName(storage::EdgeTypeId type) const;
 
+  void PrefetchOutEdges(const SubgraphVertexAccessor &vertex) const { db_accessor_.PrefetchOutEdges(vertex.impl_); }
+
+  void PrefetchInEdges(const SubgraphVertexAccessor &vertex) const { db_accessor_.PrefetchInEdges(vertex.impl_); }
+
   storage::Result<std::optional<EdgeAccessor>> RemoveEdge(EdgeAccessor *edge);
 
   storage::Result<EdgeAccessor> InsertEdge(SubgraphVertexAccessor *from, SubgraphVertexAccessor *to,

src/query/dump.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 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
@@ -482,6 +482,7 @@ PullPlanDump::PullChunk PullPlanDump::CreateEdgePullChunk() {
       // If we have a saved iterable from a previous pull
       // we need to use the same iterable
       if (!maybe_edge_iterable) {
+        dba_->PrefetchOutEdges(vertex);
         maybe_edge_iterable = std::make_shared<EdgeAccessorIterable>(vertex.OutEdges(storage::View::OLD));
       }
       auto &maybe_edges = *maybe_edge_iterable;

src/query/exceptions.hpp

@@ -175,18 +175,34 @@ class ReplicationModificationInMulticommandTxException : public QueryException {
       : QueryException("Replication clause not allowed in multicommand transactions.") {}
 };
 
+class ReplicationDisabledOnDiskStorage : public QueryException {
+ public:
+  ReplicationDisabledOnDiskStorage() : QueryException("Replication is not supported while in on-disk storage mode.") {}
+};
+
 class LockPathModificationInMulticommandTxException : public QueryException {
  public:
   LockPathModificationInMulticommandTxException()
       : QueryException("Lock path query not allowed in multicommand transactions.") {}
 };
 
+class LockPathDisabledOnDiskStorage : public QueryException {
+ public:
+  LockPathDisabledOnDiskStorage()
+      : QueryException("Lock path disabled on disk storage since all data is already persisted. ") {}
+};
+
 class FreeMemoryModificationInMulticommandTxException : public QueryException {
  public:
   FreeMemoryModificationInMulticommandTxException()
       : QueryException("Free memory query not allowed in multicommand transactions.") {}
 };
 
+class FreeMemoryDisabledOnDiskStorage : public QueryException {
+ public:
+  FreeMemoryDisabledOnDiskStorage() : QueryException("Free memory does nothing when using disk storage. ") {}
+};
+
 class ShowConfigModificationInMulticommandTxException : public QueryException {
  public:
   ShowConfigModificationInMulticommandTxException()
@@ -211,12 +227,32 @@ class IsolationLevelModificationInMulticommandTxException : public QueryExceptio
       : QueryException("Isolation level cannot be modified in multicommand transactions.") {}
 };
 
+class IsolationLevelModificationInAnalyticsException : public QueryException {
+ public:
+  IsolationLevelModificationInAnalyticsException()
+      : QueryException(
+            "Isolation level cannot be modified when storage mode is set to IN_MEMORY_ANALYTICAL."
+            "IN_MEMORY_ANALYTICAL mode doesn't provide any isolation guarantees, "
+            "you can think about it as an equivalent to READ_UNCOMMITED.") {}
+};
+
+class StorageModeModificationInMulticommandTxException : public QueryException {
+ public:
+  StorageModeModificationInMulticommandTxException()
+      : QueryException("Storage mode cannot be modified in multicommand transactions.") {}
+};
+
 class CreateSnapshotInMulticommandTxException final : public QueryException {
  public:
   CreateSnapshotInMulticommandTxException()
       : QueryException("Snapshot cannot be created in multicommand transactions.") {}
 };
 
+class CreateSnapshotDisabledOnDiskStorage final : public QueryException {
+ public:
+  CreateSnapshotDisabledOnDiskStorage() : QueryException("In the on-disk storage mode data is already persistent.") {}
+};
+
 class SettingConfigInMulticommandTxException final : public QueryException {
  public:
   SettingConfigInMulticommandTxException()
@@ -239,7 +275,7 @@ class ReplicationException : public utils::BasicException {
  public:
   using utils::BasicException::BasicException;
   explicit ReplicationException(const std::string &message)
-      : utils::BasicException("Replication Exception: {} Check the status of the replicas using 'SHOW REPLICA' query.",
+      : utils::BasicException("Replication Exception: {} Check the status of the replicas using 'SHOW REPLICAS' query.",
                               message) {}
 };
 
@@ -249,4 +285,14 @@ class TransactionQueueInMulticommandTxException : public QueryException {
       : QueryException("Transaction queue queries not allowed in multicommand transactions.") {}
 };
 
+class IndexPersistenceException : public QueryException {
+ public:
+  IndexPersistenceException() : QueryException("Persisting index on disk failed.") {}
+};
+
+class ConstraintsPersistenceException : public QueryException {
+ public:
+  ConstraintsPersistenceException() : QueryException("Persisting constraints on disk failed.") {}
+};
+
 }  // namespace memgraph::query

src/query/frame_change.hpp

@@ -0,0 +1,122 @@
+// Copyright 2023 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 "query/typed_value.hpp"
+#include "utils/memory.hpp"
+#include "utils/pmr/unordered_map.hpp"
+#include "utils/pmr/vector.hpp"
+namespace memgraph::query {
+
+// Key is hash output, value is vector of unique elements
+using CachedType = utils::pmr::unordered_map<size_t, std::vector<TypedValue>>;
+
+struct CachedValue {
+  // Cached value, this can be probably templateized
+  CachedType cache_;
+
+  explicit CachedValue(utils::MemoryResource *mem) : cache_(mem) {}
+
+  CachedValue(CachedType &&cache, memgraph::utils::MemoryResource *memory) : cache_(std::move(cache), memory) {}
+
+  CachedValue(const CachedValue &other, memgraph::utils::MemoryResource *memory) : cache_(other.cache_, memory) {}
+
+  CachedValue(CachedValue &&other, memgraph::utils::MemoryResource *memory) : cache_(std::move(other.cache_), memory) {}
+
+  CachedValue(CachedValue &&other) noexcept = delete;
+
+  /// Copy construction without memgraph::utils::MemoryResource is not allowed.
+  CachedValue(const CachedValue &) = delete;
+
+  CachedValue &operator=(const CachedValue &) = delete;
+  CachedValue &operator=(CachedValue &&) = delete;
+
+  ~CachedValue() = default;
+
+  memgraph::utils::MemoryResource *GetMemoryResource() const noexcept {
+    return cache_.get_allocator().GetMemoryResource();
+  }
+
+  // Func to check if cache_ contains value
+  bool CacheValue(const TypedValue &value) {
+    if (!value.IsList()) {
+      return false;
+    }
+    const auto &list = value.ValueList();
+    TypedValue::Hash hash{};
+    for (const TypedValue &element : list) {
+      const auto key = hash(element);
+      auto &vector_values = cache_[key];
+      if (!IsValueInVec(vector_values, element)) {
+        vector_values.push_back(element);
+      }
+    }
+    return true;
+  }
+  // Func to cache_value inside cache_
+  bool ContainsValue(const TypedValue &value) const {
+    TypedValue::Hash hash{};
+    const auto key = hash(value);
+    if (cache_.contains(key)) {
+      return IsValueInVec(cache_.at(key), value);
+    }
+    return false;
+  }
+
+ private:
+  bool IsValueInVec(const std::vector<TypedValue> &vec_values, const TypedValue &value) const {
+    return std::any_of(vec_values.begin(), vec_values.end(), [&value](auto &vec_value) {
+      const auto is_value_equal = vec_value == value;
+      if (is_value_equal.IsNull()) return false;
+      return is_value_equal.ValueBool();
+    });
+  }
+};
+
+// Class tracks keys for which user can cache values which help with faster search or faster retrieval
+// in the future.
+class FrameChangeCollector {
+ public:
+  explicit FrameChangeCollector(utils::MemoryResource *mem) : tracked_values_(mem){};
+
+  // Add tracking key to cache later value
+  CachedValue &AddTrackingKey(const std::string &key) {
+    const auto &[it, _] = tracked_values_.emplace(key, tracked_values_.get_allocator().GetMemoryResource());
+    return it->second;
+  }
+
+  // Is key tracked
+  bool IsKeyTracked(const std::string &key) const { return tracked_values_.contains(key); }
+
+  // Is value for given key cached
+  bool IsKeyValueCached(const std::string &key) const {
+    return tracked_values_.contains(key) && !tracked_values_.at(key).cache_.empty();
+  }
+
+  // Reset value for tracking key
+  bool ResetTrackingValue(const std::string &key) {
+    if (tracked_values_.contains(key)) {
+      tracked_values_.erase(key);
+      AddTrackingKey(key);
+    }
+
+    return true;
+  }
+
+  // Get value cached for tracking key, throws if key is not in tracked
+  CachedValue &GetCachedValue(const std::string &key) { return tracked_values_.at(key); }
+
+  // Checks for keys tracked
+  bool IsTrackingValues() const { return !tracked_values_.empty(); }
+
+ private:
+  // Key is output of utils::GetFrameChangeId, value is utils::pmr::unordered_map
+  memgraph::utils::pmr::unordered_map<std::string, CachedValue> tracked_values_;
+};
+}  // namespace memgraph::query

src/query/frontend/ast/ast.cpp

@@ -114,12 +114,18 @@ constexpr utils::TypeInfo query::ListLiteral::kType{utils::TypeId::AST_LIST_LITE
 constexpr utils::TypeInfo query::MapLiteral::kType{utils::TypeId::AST_MAP_LITERAL, "MapLiteral",
                                                    &query::BaseLiteral::kType};
 
+constexpr utils::TypeInfo query::MapProjectionLiteral::kType{utils::TypeId::AST_MAP_PROJECTION_LITERAL,
+                                                             "MapProjectionLiteral", &query::BaseLiteral::kType};
+
 constexpr utils::TypeInfo query::Identifier::kType{utils::TypeId::AST_IDENTIFIER, "Identifier",
                                                    &query::Expression::kType};
 
 constexpr utils::TypeInfo query::PropertyLookup::kType{utils::TypeId::AST_PROPERTY_LOOKUP, "PropertyLookup",
                                                        &query::Expression::kType};
 
+constexpr utils::TypeInfo query::AllPropertiesLookup::kType{utils::TypeId::AST_ALL_PROPERTIES_LOOKUP,
+                                                            "AllPropertiesLookup", &query::Expression::kType};
+
 constexpr utils::TypeInfo query::LabelsTest::kType{utils::TypeId::AST_LABELS_TEST, "LabelsTest",
                                                    &query::Expression::kType};
 
@@ -243,6 +249,9 @@ constexpr utils::TypeInfo query::TriggerQuery::kType{utils::TypeId::AST_TRIGGER_
 constexpr utils::TypeInfo query::IsolationLevelQuery::kType{utils::TypeId::AST_ISOLATION_LEVEL_QUERY,
                                                             "IsolationLevelQuery", &query::Query::kType};
 
+constexpr utils::TypeInfo query::StorageModeQuery::kType{utils::TypeId::AST_STORAGE_MODE_QUERY, "StorageModeQuery",
+                                                         &query::Query::kType};
+
 constexpr utils::TypeInfo query::CreateSnapshotQuery::kType{utils::TypeId::AST_CREATE_SNAPSHOT_QUERY,
                                                             "CreateSnapshotQuery", &query::Query::kType};
 

src/query/frontend/ast/ast.hpp

@@ -1063,8 +1063,9 @@ class MapLiteral : public memgraph::query::BaseLiteral {
   DEFVISITABLE(ExpressionVisitor<void>);
   bool Accept(HierarchicalTreeVisitor &visitor) override {
     if (visitor.PreVisit(*this)) {
-      for (auto pair : elements_)
+      for (auto pair : elements_) {
         if (!pair.second->Accept(visitor)) break;
+      }
     }
     return visitor.PostVisit(*this);
   }
@@ -1087,6 +1088,60 @@ class MapLiteral : public memgraph::query::BaseLiteral {
   friend class AstStorage;
 };
 
+struct MapProjectionData {
+  Expression *map_variable;
+  std::unordered_map<PropertyIx, Expression *> elements;
+};
+
+class MapProjectionLiteral : public memgraph::query::BaseLiteral {
+ public:
+  static const utils::TypeInfo kType;
+  const utils::TypeInfo &GetTypeInfo() const override { return kType; }
+
+  MapProjectionLiteral() = default;
+
+  DEFVISITABLE(ExpressionVisitor<TypedValue>);
+  DEFVISITABLE(ExpressionVisitor<TypedValue *>);
+  DEFVISITABLE(ExpressionVisitor<void>);
+  bool Accept(HierarchicalTreeVisitor &visitor) override {
+    if (visitor.PreVisit(*this)) {
+      for (auto pair : elements_) {
+        if (!pair.second) continue;
+
+        if (!pair.second->Accept(visitor)) break;
+      }
+    }
+    return visitor.PostVisit(*this);
+  }
+
+  Expression *map_variable_;
+  std::unordered_map<PropertyIx, Expression *> elements_;
+
+  MapProjectionLiteral *Clone(AstStorage *storage) const override {
+    MapProjectionLiteral *object = storage->Create<MapProjectionLiteral>();
+    object->map_variable_ = map_variable_;
+
+    for (const auto &entry : elements_) {
+      auto key = storage->GetPropertyIx(entry.first.name);
+
+      if (!entry.second) {
+        object->elements_[key] = nullptr;
+        continue;
+      }
+
+      object->elements_[key] = entry.second->Clone(storage);
+    }
+    return object;
+  }
+
+ protected:
+  explicit MapProjectionLiteral(Expression *map_variable, std::unordered_map<PropertyIx, Expression *> &&elements)
+      : map_variable_(map_variable), elements_(std::move(elements)) {}
+
+ private:
+  friend class AstStorage;
+};
+
 class Identifier : public memgraph::query::Expression {
  public:
   static const utils::TypeInfo kType;
@@ -1158,6 +1213,38 @@ class PropertyLookup : public memgraph::query::Expression {
   friend class AstStorage;
 };
 
+class AllPropertiesLookup : public memgraph::query::Expression {
+ public:
+  static const utils::TypeInfo kType;
+  const utils::TypeInfo &GetTypeInfo() const override { return kType; }
+
+  AllPropertiesLookup() = default;
+
+  DEFVISITABLE(ExpressionVisitor<TypedValue>);
+  DEFVISITABLE(ExpressionVisitor<TypedValue *>);
+  DEFVISITABLE(ExpressionVisitor<void>);
+  bool Accept(HierarchicalTreeVisitor &visitor) override {
+    if (visitor.PreVisit(*this)) {
+      expression_->Accept(visitor);
+    }
+    return visitor.PostVisit(*this);
+  }
+
+  memgraph::query::Expression *expression_{nullptr};
+
+  AllPropertiesLookup *Clone(AstStorage *storage) const override {
+    AllPropertiesLookup *object = storage->Create<AllPropertiesLookup>();
+    object->expression_ = expression_ ? expression_->Clone(storage) : nullptr;
+    return object;
+  }
+
+ protected:
+  explicit AllPropertiesLookup(Expression *expression) : expression_(expression) {}
+
+ private:
+  friend class AstStorage;
+};
+
 class LabelsTest : public memgraph::query::Expression {
  public:
   static const utils::TypeInfo kType;
@@ -2714,6 +2801,7 @@ class AuthQuery : public memgraph::query::Query {
     MODULE_READ,
     MODULE_WRITE,
     WEBSOCKET,
+    STORAGE_MODE,
     TRANSACTION_MANAGEMENT
   };
 
@@ -2777,14 +2865,15 @@ const std::vector<AuthQuery::Privilege> kPrivilegesAll = {
     AuthQuery::Privilege::FREE_MEMORY, AuthQuery::Privilege::TRIGGER,
     AuthQuery::Privilege::CONFIG,      AuthQuery::Privilege::STREAM,
     AuthQuery::Privilege::MODULE_READ, AuthQuery::Privilege::MODULE_WRITE,
-    AuthQuery::Privilege::WEBSOCKET,   AuthQuery::Privilege::TRANSACTION_MANAGEMENT};
+    AuthQuery::Privilege::WEBSOCKET,   AuthQuery::Privilege::TRANSACTION_MANAGEMENT,
+    AuthQuery::Privilege::STORAGE_MODE};
 
 class InfoQuery : public memgraph::query::Query {
  public:
   static const utils::TypeInfo kType;
   const utils::TypeInfo &GetTypeInfo() const override { return kType; }
 
-  enum class InfoType { STORAGE, INDEX, CONSTRAINT };
+  enum class InfoType { STORAGE, INDEX, CONSTRAINT, BUILD };
 
   DEFVISITABLE(QueryVisitor<void>);
 
@@ -2896,7 +2985,7 @@ class LockPathQuery : public memgraph::query::Query {
   static const utils::TypeInfo kType;
   const utils::TypeInfo &GetTypeInfo() const override { return kType; }
 
-  enum class Action { LOCK_PATH, UNLOCK_PATH };
+  enum class Action { LOCK_PATH, UNLOCK_PATH, STATUS };
 
   LockPathQuery() = default;
 
@@ -2933,6 +3022,7 @@ class LoadCsv : public memgraph::query::Clause {
   bool ignore_bad_;
   memgraph::query::Expression *delimiter_{nullptr};
   memgraph::query::Expression *quote_{nullptr};
+  memgraph::query::Expression *nullif_{nullptr};
   memgraph::query::Identifier *row_var_{nullptr};
 
   LoadCsv *Clone(AstStorage *storage) const override {
@@ -2942,18 +3032,20 @@ class LoadCsv : public memgraph::query::Clause {
     object->ignore_bad_ = ignore_bad_;
     object->delimiter_ = delimiter_ ? delimiter_->Clone(storage) : nullptr;
     object->quote_ = quote_ ? quote_->Clone(storage) : nullptr;
+    object->nullif_ = nullif_;
     object->row_var_ = row_var_ ? row_var_->Clone(storage) : nullptr;
     return object;
   }
 
  protected:
   explicit LoadCsv(Expression *file, bool with_header, bool ignore_bad, Expression *delimiter, Expression *quote,
-                   Identifier *row_var)
+                   Expression *nullif, Identifier *row_var)
       : file_(file),
         with_header_(with_header),
         ignore_bad_(ignore_bad),
         delimiter_(delimiter),
         quote_(quote),
+        nullif_(nullif),
         row_var_(row_var) {
     DMG_ASSERT(row_var, "LoadCsv cannot take nullptr for identifier");
   }
@@ -3046,6 +3138,29 @@ class IsolationLevelQuery : public memgraph::query::Query {
   friend class AstStorage;
 };
 
+class StorageModeQuery : public memgraph::query::Query {
+ public:
+  static const utils::TypeInfo kType;
+  const utils::TypeInfo &GetTypeInfo() const override { return kType; }
+
+  enum class StorageMode { IN_MEMORY_TRANSACTIONAL, IN_MEMORY_ANALYTICAL, ON_DISK_TRANSACTIONAL };
+
+  StorageModeQuery() = default;
+
+  DEFVISITABLE(QueryVisitor<void>);
+
+  memgraph::query::StorageModeQuery::StorageMode storage_mode_;
+
+  StorageModeQuery *Clone(AstStorage *storage) const override {
+    StorageModeQuery *object = storage->Create<StorageModeQuery>();
+    object->storage_mode_ = storage_mode_;
+    return object;
+  }
+
+ private:
+  friend class AstStorage;
+};
+
 class CreateSnapshotQuery : public memgraph::query::Query {
  public:
   static const utils::TypeInfo kType;

src/query/frontend/ast/ast_visitor.hpp

@@ -22,6 +22,7 @@ class CypherUnion;
 class NamedExpression;
 class Identifier;
 class PropertyLookup;
+class AllPropertiesLookup;
 class LabelsTest;
 class Aggregation;
 class Function;
@@ -44,6 +45,7 @@ class EdgeAtom;
 class PrimitiveLiteral;
 class ListLiteral;
 class MapLiteral;
+class MapProjectionLiteral;
 class OrOperator;
 class XorOperator;
 class AndOperator;
@@ -89,6 +91,7 @@ class LoadCsv;
 class FreeMemoryQuery;
 class TriggerQuery;
 class IsolationLevelQuery;
+class StorageModeQuery;
 class CreateSnapshotQuery;
 class StreamQuery;
 class SettingQuery;
@@ -105,9 +108,10 @@ using TreeCompositeVisitor = utils::CompositeVisitor<
     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, Exists, CallSubquery, CypherQuery>;
+    MapProjectionLiteral, PropertyLookup, AllPropertiesLookup, 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, Exists, CallSubquery, CypherQuery>;
 
 using TreeLeafVisitor = utils::LeafVisitor<Identifier, PrimitiveLiteral, ParameterLookup>;
 
@@ -121,19 +125,20 @@ class HierarchicalTreeVisitor : public TreeCompositeVisitor, public TreeLeafVisi
 
 template <class TResult>
 class ExpressionVisitor
-    : public 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, Exists> {};
+    : public 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, MapProjectionLiteral, PropertyLookup, AllPropertiesLookup,
+                            LabelsTest, Aggregation, Function, Reduce, Coalesce, Extract, All, Single, Any, None,
+                            ParameterLookup, Identifier, PrimitiveLiteral, RegexMatch, Exists> {};
 
 template <class TResult>
 class QueryVisitor
     : public utils::Visitor<TResult, CypherQuery, ExplainQuery, ProfileQuery, IndexQuery, AuthQuery, InfoQuery,
                             ConstraintQuery, DumpQuery, ReplicationQuery, LockPathQuery, FreeMemoryQuery, TriggerQuery,
                             IsolationLevelQuery, CreateSnapshotQuery, StreamQuery, SettingQuery, VersionQuery,
-                            ShowConfigQuery, TransactionQueueQuery, AnalyzeGraphQuery> {};
+                            ShowConfigQuery, TransactionQueueQuery, StorageModeQuery, AnalyzeGraphQuery> {};
 
 }  // namespace memgraph::query

src/query/frontend/ast/cypher_main_visitor.cpp

@@ -124,6 +124,9 @@ antlrcpp::Any CypherMainVisitor::visitInfoQuery(MemgraphCypher::InfoQueryContext
   } else if (ctx->constraintInfo()) {
     info_query->info_type_ = InfoQuery::InfoType::CONSTRAINT;
     return info_query;
+  } else if (ctx->buildInfo()) {
+    info_query->info_type_ = InfoQuery::InfoType::BUILD;
+    return info_query;
   } else {
     throw utils::NotYetImplemented("Info query: '{}'", ctx->getText());
   }
@@ -325,7 +328,9 @@ antlrcpp::Any CypherMainVisitor::visitShowReplicas(MemgraphCypher::ShowReplicasC
 
 antlrcpp::Any CypherMainVisitor::visitLockPathQuery(MemgraphCypher::LockPathQueryContext *ctx) {
   auto *lock_query = storage_->Create<LockPathQuery>();
-  if (ctx->LOCK()) {
+  if (ctx->STATUS()) {
+    lock_query->action_ = LockPathQuery::Action::STATUS;
+  } else if (ctx->LOCK()) {
     lock_query->action_ = LockPathQuery::Action::LOCK_PATH;
   } else if (ctx->UNLOCK()) {
     lock_query->action_ = LockPathQuery::Action::UNLOCK_PATH;
@@ -357,6 +362,11 @@ antlrcpp::Any CypherMainVisitor::visitLoadCsv(MemgraphCypher::LoadCsvContext *ct
   // handle skip bad row option
   load_csv->ignore_bad_ = ctx->IGNORE() && ctx->BAD();
 
+  // handle character sequence which will correspond to nulls
+  if (ctx->NULLIF()) {
+    load_csv->nullif_ = std::any_cast<Expression *>(ctx->nullif()->accept(this));
+  }
+
   // handle delimiter
   if (ctx->DELIMITER()) {
     if (ctx->delimiter()->literal()->StringLiteral()) {
@@ -487,6 +497,23 @@ antlrcpp::Any CypherMainVisitor::visitIsolationLevelQuery(MemgraphCypher::Isolat
   return isolation_level_query;
 }
 
+antlrcpp::Any CypherMainVisitor::visitStorageModeQuery(MemgraphCypher::StorageModeQueryContext *ctx) {
+  auto *storage_mode_query = storage_->Create<StorageModeQuery>();
+
+  storage_mode_query->storage_mode_ = std::invoke([mode = ctx->storageMode()]() {
+    if (mode->IN_MEMORY_ANALYTICAL()) {
+      return StorageModeQuery::StorageMode::IN_MEMORY_ANALYTICAL;
+    }
+    if (mode->IN_MEMORY_TRANSACTIONAL()) {
+      return StorageModeQuery::StorageMode::IN_MEMORY_TRANSACTIONAL;
+    }
+    return StorageModeQuery::StorageMode::ON_DISK_TRANSACTIONAL;
+  });
+
+  query_ = storage_mode_query;
+  return storage_mode_query;
+}
+
 antlrcpp::Any CypherMainVisitor::visitCreateSnapshotQuery(MemgraphCypher::CreateSnapshotQueryContext *ctx) {
   query_ = storage_->Create<CreateSnapshotQuery>();
   return query_;
@@ -1511,6 +1538,7 @@ antlrcpp::Any CypherMainVisitor::visitPrivilege(MemgraphCypher::PrivilegeContext
   if (ctx->MODULE_WRITE()) return AuthQuery::Privilege::MODULE_WRITE;
   if (ctx->WEBSOCKET()) return AuthQuery::Privilege::WEBSOCKET;
   if (ctx->TRANSACTION_MANAGEMENT()) return AuthQuery::Privilege::TRANSACTION_MANAGEMENT;
+  if (ctx->STORAGE_MODE()) return AuthQuery::Privilege::STORAGE_MODE;
   LOG_FATAL("Should not get here - unknown privilege!");
 }
 
@@ -1681,6 +1709,38 @@ antlrcpp::Any CypherMainVisitor::visitMapLiteral(MemgraphCypher::MapLiteralConte
   return map;
 }
 
+antlrcpp::Any CypherMainVisitor::visitMapProjectionLiteral(MemgraphCypher::MapProjectionLiteralContext *ctx) {
+  MapProjectionData map_projection_data;
+
+  map_projection_data.map_variable =
+      storage_->Create<Identifier>(std::any_cast<std::string>(ctx->variable()->accept(this)));
+  for (auto *map_el : ctx->mapElement()) {
+    if (map_el->propertyLookup()) {
+      auto key = std::any_cast<PropertyIx>(map_el->propertyLookup()->propertyKeyName()->accept(this));
+      auto property = std::any_cast<PropertyIx>(map_el->propertyLookup()->accept(this));
+      auto *property_lookup = storage_->Create<PropertyLookup>(map_projection_data.map_variable, property);
+      map_projection_data.elements.insert_or_assign(key, property_lookup);
+    }
+    if (map_el->allPropertiesLookup()) {
+      auto key = AddProperty("*");
+      auto *all_properties_lookup = storage_->Create<AllPropertiesLookup>(map_projection_data.map_variable);
+      map_projection_data.elements.insert_or_assign(key, all_properties_lookup);
+    }
+    if (map_el->variable()) {
+      auto key = AddProperty(std::any_cast<std::string>(map_el->variable()->accept(this)));
+      auto *variable = storage_->Create<Identifier>(std::any_cast<std::string>(map_el->variable()->accept(this)));
+      map_projection_data.elements.insert_or_assign(key, variable);
+    }
+    if (map_el->propertyKeyValuePair()) {
+      auto key = std::any_cast<PropertyIx>(map_el->propertyKeyValuePair()->propertyKeyName()->accept(this));
+      auto *value = std::any_cast<Expression *>(map_el->propertyKeyValuePair()->expression()->accept(this));
+      map_projection_data.elements.insert_or_assign(key, value);
+    }
+  }
+
+  return map_projection_data;
+}
+
 antlrcpp::Any CypherMainVisitor::visitListLiteral(MemgraphCypher::ListLiteralContext *ctx) {
   std::vector<Expression *> expressions;
   for (auto *expr_ctx : ctx->expression()) {
@@ -2261,6 +2321,10 @@ antlrcpp::Any CypherMainVisitor::visitLiteral(MemgraphCypher::LiteralContext *ct
   } else if (ctx->listLiteral()) {
     return static_cast<Expression *>(
         storage_->Create<ListLiteral>(std::any_cast<std::vector<Expression *>>(ctx->listLiteral()->accept(this))));
+  } else if (ctx->mapProjectionLiteral()) {
+    auto map_projection_data = std::any_cast<MapProjectionData>(ctx->mapProjectionLiteral()->accept(this));
+    return static_cast<Expression *>(storage_->Create<MapProjectionLiteral>(map_projection_data.map_variable,
+                                                                            std::move(map_projection_data.elements)));
   } else {
     return static_cast<Expression *>(storage_->Create<MapLiteral>(
         std::any_cast<std::unordered_map<PropertyIx, Expression *>>(ctx->mapLiteral()->accept(this))));

src/query/frontend/ast/cypher_main_visitor.hpp

@@ -15,8 +15,6 @@
 #include <unordered_set>
 #include <utility>
 
-#include <antlr4-runtime.h>
-
 #include "query/frontend/ast/ast.hpp"
 #include "query/frontend/opencypher/generated/MemgraphCypherBaseVisitor.h"
 #include "utils/exceptions.hpp"
@@ -263,6 +261,11 @@ class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
    */
   antlrcpp::Any visitIsolationLevelQuery(MemgraphCypher::IsolationLevelQueryContext *ctx) override;
 
+  /**
+   * @return StorageModeQuery*
+   */
+  antlrcpp::Any visitStorageModeQuery(MemgraphCypher::StorageModeQueryContext *ctx) override;
+
   /**
    * @return CreateSnapshotQuery*
    */
@@ -603,6 +606,11 @@ class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
    */
   antlrcpp::Any visitMapLiteral(MemgraphCypher::MapLiteralContext *ctx) override;
 
+  /**
+   * @return MapProjectionData
+   */
+  antlrcpp::Any visitMapProjectionLiteral(MemgraphCypher::MapProjectionLiteralContext *ctx) override;
+
   /**
    * @return vector<Expression*>
    */

src/query/frontend/ast/pretty_print.cpp

@@ -54,6 +54,7 @@ class ExpressionPrettyPrinter : public ExpressionVisitor<void> {
   void Visit(IfOperator &op) override;
   void Visit(ListLiteral &op) override;
   void Visit(MapLiteral &op) override;
+  void Visit(MapProjectionLiteral &op) override;
   void Visit(LabelsTest &op) override;
   void Visit(Aggregation &op) override;
   void Visit(Function &op) override;
@@ -68,6 +69,7 @@ class ExpressionPrettyPrinter : public ExpressionVisitor<void> {
   void Visit(Identifier &op) override;
   void Visit(PrimitiveLiteral &op) override;
   void Visit(PropertyLookup &op) override;
+  void Visit(AllPropertiesLookup &op) override;
   void Visit(ParameterLookup &op) override;
   void Visit(NamedExpression &op) override;
   void Visit(RegexMatch &op) override;
@@ -89,6 +91,8 @@ void PrintObject(std::ostream *out, Aggregation::Op op);
 
 void PrintObject(std::ostream *out, Expression *expr);
 
+void PrintObject(std::ostream *out, AllPropertiesLookup *apl);
+
 void PrintObject(std::ostream *out, Identifier *expr);
 
 void PrintObject(std::ostream *out, const storage::PropertyValue &value);
@@ -122,6 +126,15 @@ void PrintObject(std::ostream *out, Expression *expr) {
   }
 }
 
+void PrintObject(std::ostream *out, AllPropertiesLookup *apl) {
+  if (apl) {
+    ExpressionPrettyPrinter printer{out};
+    *out << ".*";
+  } else {
+    *out << "<null>";
+  }
+}
+
 void PrintObject(std::ostream *out, Identifier *expr) { PrintObject(out, static_cast<Expression *>(expr)); }
 
 void PrintObject(std::ostream *out, const storage::PropertyValue &value) {
@@ -249,6 +262,17 @@ void ExpressionPrettyPrinter::Visit(MapLiteral &op) {
   PrintObject(out_, map);
 }
 
+void ExpressionPrettyPrinter::Visit(MapProjectionLiteral &op) {
+  std::map<std::string, Expression *> map_projection_elements;
+  for (const auto &kv : op.elements_) {
+    map_projection_elements[kv.first.name] = kv.second;
+  }
+  PrintObject(out_, op.map_variable_);
+  PrintObject(out_, map_projection_elements);
+}
+
+void ExpressionPrettyPrinter::Visit(AllPropertiesLookup &op) { PrintObject(out_, &op); }
+
 void ExpressionPrettyPrinter::Visit(LabelsTest &op) { PrintOperator(out_, "LabelsTest", op.expression_); }
 
 void ExpressionPrettyPrinter::Visit(Aggregation &op) { PrintOperator(out_, "Aggregation", op.op_); }

src/query/frontend/opencypher/grammar/Cypher.g4

@@ -46,7 +46,9 @@ indexInfo : INDEX INFO ;
 
 constraintInfo : CONSTRAINT INFO ;
 
-infoQuery : SHOW ( storageInfo | indexInfo | constraintInfo ) ;
+buildInfo : BUILD INFO ;
+
+infoQuery : SHOW ( storageInfo | indexInfo | constraintInfo | buildInfo) ;
 
 explainQuery : EXPLAIN cypherQuery ;
 
@@ -248,6 +250,7 @@ literal : numberLiteral
         | booleanLiteral
         | CYPHERNULL
         | mapLiteral
+        | mapProjectionLiteral
         | listLiteral
         ;
 
@@ -290,6 +293,8 @@ patternComprehension : '[' ( variable '=' )? relationshipsPattern ( WHERE expres
 
 propertyLookup : '.' ( propertyKeyName ) ;
 
+allPropertiesLookup : '.' '*' ;
+
 caseExpression : ( ( CASE ( caseAlternatives )+ ) | ( CASE test=expression ( caseAlternatives )+ ) ) ( ELSE else_expression=expression )? END ;
 
 caseAlternatives : WHEN when_expression=expression THEN then_expression=expression ;
@@ -302,12 +307,22 @@ numberLiteral : doubleLiteral
 
 mapLiteral : '{' ( propertyKeyName ':' expression ( ',' propertyKeyName ':' expression )* )? '}' ;
 
+mapProjectionLiteral : variable '{' ( mapElement ( ',' mapElement )* )? '}' ;
+
+mapElement : propertyLookup
+           | allPropertiesLookup
+           | variable
+           | propertyKeyValuePair
+           ;
+
 parameter : '$' ( symbolicName | DecimalLiteral ) ;
 
 propertyExpression : atom ( propertyLookup )+ ;
 
 propertyKeyName : symbolicName ;
 
+propertyKeyValuePair : propertyKeyName ':' expression ;
+
 integerLiteral : DecimalLiteral
                | OctalLiteral
                | HexadecimalLiteral

src/query/frontend/opencypher/grammar/MemgraphCypher.g4

@@ -31,6 +31,7 @@ memgraphCypherKeyword : cypherKeyword
                       | BATCH_SIZE
                       | BEFORE
                       | BOOTSTRAP_SERVERS
+                      | BUILD
                       | CHECK
                       | CLEAR
                       | COMMIT
@@ -58,7 +59,10 @@ memgraphCypherKeyword : cypherKeyword
                       | GRANT
                       | HEADER
                       | IDENTIFIED
+                      | NULLIF
                       | ISOLATION
+                      | IN_MEMORY_ANALYTICAL
+                      | IN_MEMORY_TRANSACTIONAL
                       | KAFKA
                       | LABELS
                       | LEVEL
@@ -88,6 +92,8 @@ memgraphCypherKeyword : cypherKeyword
                       | SNAPSHOT
                       | START
                       | STATS
+                      | STATUS
+                      | STORAGE
                       | STREAM
                       | STREAMS
                       | SYNC
@@ -127,6 +133,7 @@ query : cypherQuery
       | freeMemoryQuery
       | triggerQuery
       | isolationLevelQuery
+      | storageModeQuery
       | createSnapshotQuery
       | streamQuery
       | settingQuery
@@ -218,6 +225,7 @@ loadCsv : LOAD CSV FROM csvFile ( WITH | NO ) HEADER
          ( IGNORE BAD ) ?
          ( DELIMITER delimiter ) ?
          ( QUOTE quote ) ?
+         ( NULLIF nullif ) ?
          AS rowVar ;
 
 csvFile : literal ;
@@ -226,6 +234,8 @@ delimiter : literal ;
 
 quote : literal ;
 
+nullif : literal ;
+
 rowVar : variable ;
 
 userOrRoleName : symbolicName ;
@@ -277,6 +287,7 @@ privilege : CREATE
           | MODULE_WRITE
           | WEBSOCKET
           | TRANSACTION_MANAGEMENT
+          | STORAGE_MODE
           ;
 
 granularPrivilege : NOTHING | READ | UPDATE | CREATE_DELETE ;
@@ -329,7 +340,7 @@ dropReplica : DROP REPLICA replicaName ;
 
 showReplicas  : SHOW REPLICAS ;
 
-lockPathQuery : ( LOCK | UNLOCK ) DATA DIRECTORY ;
+lockPathQuery : ( LOCK | UNLOCK ) DATA DIRECTORY | DATA DIRECTORY LOCK STATUS;
 
 freeMemoryQuery : FREE MEMORY ;
 
@@ -354,6 +365,10 @@ isolationLevelScope : GLOBAL | SESSION | NEXT ;
 
 isolationLevelQuery : SET isolationLevelScope TRANSACTION ISOLATION LEVEL isolationLevel ;
 
+storageMode : IN_MEMORY_ANALYTICAL | IN_MEMORY_TRANSACTIONAL | ON_DISK_TRANSACTIONAL ;
+
+storageModeQuery : STORAGE MODE storageMode ;
+
 createSnapshotQuery : CREATE SNAPSHOT ;
 
 streamName : symbolicName ;

src/query/frontend/opencypher/grammar/MemgraphCypherLexer.g4

@@ -25,103 +25,111 @@ import CypherLexer ;
 
 UNDERSCORE : '_' ;
 
-AFTER               : A F T E R ;
-ALTER               : A L T E R ;
-ANALYZE             : A N A L Y Z E ;
-ASYNC               : A S Y N C ;
-AUTH                : A U T H ;
-BAD                 : B A D ;
-BATCH_INTERVAL      : B A T C H UNDERSCORE I N T E R V A L ;
-BATCH_LIMIT         : B A T C H UNDERSCORE L I M I T ;
-BATCH_SIZE          : B A T C H UNDERSCORE S I Z E ;
-BEFORE              : B E F O R E ;
-BOOTSTRAP_SERVERS   : B O O T S T R A P UNDERSCORE S E R V E R S ;
-CALL                : C A L L ;
-CHECK               : C H E C K ;
-CLEAR               : C L E A R ;
-COMMIT              : C O M M I T ;
-COMMITTED           : C O M M I T T E D ;
-CONFIG              : C O N F I G ;
-CONFIGS             : C O N F I G S;
-CONSUMER_GROUP      : C O N S U M E R UNDERSCORE G R O U P ;
-CREATE_DELETE       : C R E A T E UNDERSCORE D E L E T E ;
-CREDENTIALS         : C R E D E N T I A L S ;
-CSV                 : C S V ;
-DATA                : D A T A ;
-DELIMITER           : D E L I M I T E R ;
-DATABASE            : D A T A B A S E ;
-DENY                : D E N Y ;
-DIRECTORY           : D I R E C T O R Y ;
-DROP                : D R O P ;
-DUMP                : D U M P ;
-DURABILITY          : D U R A B I L I T Y ;
-EDGE_TYPES          : E D G E UNDERSCORE T Y P E S ;
-EXECUTE             : E X E C U T E ;
-FOR                 : F O R ;
-FOREACH             : F O R E A C H;
-FREE                : F R E E ;
-FREE_MEMORY         : F R E E UNDERSCORE M E M O R Y ;
-FROM                : F R O M ;
-GLOBAL              : G L O B A L ;
-GRANT               : G R A N T ;
-GRAPH               : G R A P H ;
-GRANTS              : G R A N T S ;
-HEADER              : H E A D E R ;
-IDENTIFIED          : I D E N T I F I E D ;
-IGNORE              : I G N O R E ;
-ISOLATION           : I S O L A T I O N ;
-KAFKA               : K A F K A ;
-LABELS              : L A B E L S ;
-LEVEL               : L E V E L ;
-LOAD                : L O A D ;
-LOCK                : L O C K ;
-MAIN                : M A I N ;
-MODE                : M O D E ;
-MODULE_READ         : M O D U L E UNDERSCORE R E A D ;
-MODULE_WRITE        : M O D U L E UNDERSCORE W R I T E ;
-NEXT                : N E X T ;
-NO                  : N O ;
-NOTHING             : N O T H I N G ;
-PASSWORD            : P A S S W O R D ;
-PORT                : P O R T ;
-PRIVILEGES          : P R I V I L E G E S ;
-PULSAR              : P U L S A R ;
-READ                : R E A D ;
-READ_FILE           : R E A D UNDERSCORE F I L E ;
-REGISTER            : R E G I S T E R ;
-REPLICA             : R E P L I C A ;
-REPLICAS            : R E P L I C A S ;
-REPLICATION         : R E P L I C A T I O N ;
-REVOKE              : R E V O K E ;
-ROLE                : R O L E ;
-ROLES               : R O L E S ;
-QUOTE               : Q U O T E ;
-SERVICE_URL         : S E R V I C E UNDERSCORE U R L ;
-SESSION             : S E S S I O N ;
-SETTING             : S E T T I N G ;
-SETTINGS            : S E T T I N G S ;
-SNAPSHOT            : S N A P S H O T ;
-START               : S T A R T ;
-STATISTICS          : S T A T I S T I C S ;
-STATS               : S T A T S ;
-STOP                : S T O P ;
-STREAM              : S T R E A M ;
-STREAMS             : S T R E A M S ;
-SYNC                : S Y N C ;
-TERMINATE           : T E R M I N A T E ;
-TIMEOUT             : T I M E O U T ;
-TO                  : T O ;
-TOPICS              : T O P I C S;
-TRANSACTION         : T R A N S A C T I O N ;
-TRANSACTION_MANAGEMENT : T R A N S A C T I O N UNDERSCORE M A N A G E M E N T ;
-TRANSACTIONS        : T R A N S A C T I O N S ;
-TRANSFORM           : T R A N S F O R M ;
-TRIGGER             : T R I G G E R ;
-TRIGGERS            : T R I G G E R S ;
-UNCOMMITTED         : U N C O M M I T T E D ;
-UNLOCK              : U N L O C K ;
-UPDATE              : U P D A T E ;
-USER                : U S E R ;
-USERS               : U S E R S ;
-VERSION             : V E R S I O N ;
-WEBSOCKET           : W E B S O C K E T ;
+AFTER                   : A F T E R ;
+ALTER                   : A L T E R ;
+ANALYZE                 : A N A L Y Z E ;
+ASYNC                   : A S Y N C ;
+AUTH                    : A U T H ;
+BAD                     : B A D ;
+BATCH_INTERVAL          : B A T C H UNDERSCORE I N T E R V A L ;
+BATCH_LIMIT             : B A T C H UNDERSCORE L I M I T ;
+BATCH_SIZE              : B A T C H UNDERSCORE S I Z E ;
+BEFORE                  : B E F O R E ;
+BUILD                   : B U I L D ;
+BOOTSTRAP_SERVERS       : B O O T S T R A P UNDERSCORE S E R V E R S ;
+CALL                    : C A L L ;
+CHECK                   : C H E C K ;
+CLEAR                   : C L E A R ;
+COMMIT                  : C O M M I T ;
+COMMITTED               : C O M M I T T E D ;
+CONFIG                  : C O N F I G ;
+CONFIGS                 : C O N F I G S;
+CONSUMER_GROUP          : C O N S U M E R UNDERSCORE G R O U P ;
+CREATE_DELETE           : C R E A T E UNDERSCORE D E L E T E ;
+CREDENTIALS             : C R E D E N T I A L S ;
+CSV                     : C S V ;
+DATA                    : D A T A ;
+DELIMITER               : D E L I M I T E R ;
+DATABASE                : D A T A B A S E ;
+DENY                    : D E N Y ;
+DIRECTORY               : D I R E C T O R Y ;
+DROP                    : D R O P ;
+DUMP                    : D U M P ;
+DURABILITY              : D U R A B I L I T Y ;
+EDGE_TYPES              : E D G E UNDERSCORE T Y P E S ;
+EXECUTE                 : E X E C U T E ;
+FOR                     : F O R ;
+FOREACH                 : F O R E A C H;
+FREE                    : F R E E ;
+FREE_MEMORY             : F R E E UNDERSCORE M E M O R Y ;
+FROM                    : F R O M ;
+GLOBAL                  : G L O B A L ;
+GRANT                   : G R A N T ;
+GRAPH                   : G R A P H ;
+GRANTS                  : G R A N T S ;
+HEADER                  : H E A D E R ;
+IDENTIFIED              : I D E N T I F I E D ;
+IGNORE                  : I G N O R E ;
+ISOLATION               : I S O L A T I O N ;
+IN_MEMORY_ANALYTICAL    : I N UNDERSCORE M E M O R Y UNDERSCORE A N A L Y T I C A L ;
+IN_MEMORY_TRANSACTIONAL : I N UNDERSCORE M E M O R Y UNDERSCORE T R A N S A C T I O N A L ;
+KAFKA                   : K A F K A ;
+LABELS                  : L A B E L S ;
+LEVEL                   : L E V E L ;
+LOAD                    : L O A D ;
+LOCK                    : L O C K ;
+MAIN                    : M A I N ;
+MODE                    : M O D E ;
+MODULE_READ             : M O D U L E UNDERSCORE R E A D ;
+MODULE_WRITE            : M O D U L E UNDERSCORE W R I T E ;
+NEXT                    : N E X T ;
+NO                      : N O ;
+NOTHING                 : N O T H I N G ;
+ON_DISK_TRANSACTIONAL   : O N UNDERSCORE D I S K UNDERSCORE T R A N S A C T I O N A L ;
+NULLIF                  : N U L L I F ;
+PASSWORD                : P A S S W O R D ;
+PORT                    : P O R T ;
+PRIVILEGES              : P R I V I L E G E S ;
+PULSAR                  : P U L S A R ;
+READ                    : R E A D ;
+READ_FILE               : R E A D UNDERSCORE F I L E ;
+REGISTER                : R E G I S T E R ;
+REPLICA                 : R E P L I C A ;
+REPLICAS                : R E P L I C A S ;
+REPLICATION             : R E P L I C A T I O N ;
+REVOKE                  : R E V O K E ;
+ROLE                    : R O L E ;
+ROLES                   : R O L E S ;
+QUOTE                   : Q U O T E ;
+SERVICE_URL             : S E R V I C E UNDERSCORE U R L ;
+SESSION                 : S E S S I O N ;
+SETTING                 : S E T T I N G ;
+SETTINGS                : S E T T I N G S ;
+SNAPSHOT                : S N A P S H O T ;
+START                   : S T A R T ;
+STATISTICS              : S T A T I S T I C S ;
+STATS                   : S T A T S ;
+STATUS                  : S T A T U S ;
+STOP                    : S T O P ;
+STORAGE                 : S T O R A G E;
+STORAGE_MODE            : S T O R A G E UNDERSCORE MODE;
+STREAM                  : S T R E A M ;
+STREAMS                 : S T R E A M S ;
+SYNC                    : S Y N C ;
+TERMINATE               : T E R M I N A T E ;
+TIMEOUT                 : T I M E O U T ;
+TO                      : T O ;
+TOPICS                  : T O P I C S;
+TRANSACTION             : T R A N S A C T I O N ;
+TRANSACTION_MANAGEMENT  : T R A N S A C T I O N UNDERSCORE M A N A G E M E N T ;
+TRANSACTIONS            : T R A N S A C T I O N S ;
+TRANSFORM               : T R A N S F O R M ;
+TRIGGER                 : T R I G G E R ;
+TRIGGERS                : T R I G G E R S ;
+UNCOMMITTED             : U N C O M M I T T E D ;
+UNLOCK                  : U N L O C K ;
+UPDATE                  : U P D A T E ;
+USER                    : U S E R ;
+USERS                   : U S E R S ;
+VERSION                 : V E R S I O N ;
+WEBSOCKET               : W E B S O C K E T ;

src/query/frontend/semantic/required_privileges.cpp

@@ -43,6 +43,7 @@ class PrivilegeExtractor : public QueryVisitor<void>, public HierarchicalTreeVis
         AddPrivilege(AuthQuery::Privilege::INDEX);
         break;
       case InfoQuery::InfoType::STORAGE:
+      case InfoQuery::InfoType::BUILD:
         AddPrivilege(AuthQuery::Privilege::STATS);
         break;
       case InfoQuery::InfoType::CONSTRAINT:
@@ -78,6 +79,8 @@ class PrivilegeExtractor : public QueryVisitor<void>, public HierarchicalTreeVis
 
   void Visit(IsolationLevelQuery &isolation_level_query) override { AddPrivilege(AuthQuery::Privilege::CONFIG); }
 
+  void Visit(StorageModeQuery & /*storage_mode_query*/) override { AddPrivilege(AuthQuery::Privilege::STORAGE_MODE); }
+
   void Visit(CreateSnapshotQuery &create_snapshot_query) override { AddPrivilege(AuthQuery::Privilege::DURABILITY); }
 
   void Visit(SettingQuery & /*setting_query*/) override { AddPrivilege(AuthQuery::Privilege::CONFIG); }

src/query/frontend/semantic/symbol_generator.cpp

@@ -157,25 +157,34 @@ void SymbolGenerator::VisitReturnBody(ReturnBody &body, Where *where) {
 // Query
 
 bool SymbolGenerator::PreVisit(SingleQuery &) {
-  prev_return_names_ = curr_return_names_;
-  curr_return_names_.clear();
+  auto &scope = scopes_.back();
+
+  scope.prev_return_names = scope.curr_return_names;
+  scope.curr_return_names.clear();
   return true;
 }
 
 // Union
 
 bool SymbolGenerator::PreVisit(CypherUnion &) {
-  scopes_.back() = Scope();
+  auto next_scope = Scope();
+  next_scope.curr_return_names = scopes_.back().curr_return_names;
+
+  scopes_.pop_back();
+  scopes_.push_back(next_scope);
+
   return true;
 }
 
 bool SymbolGenerator::PostVisit(CypherUnion &cypher_union) {
-  if (prev_return_names_ != curr_return_names_) {
+  auto &scope = scopes_.back();
+
+  if (scope.prev_return_names != scope.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_) {
+  for (const auto &name : scope.curr_return_names) {
     auto symbol = CreateSymbol(name, false);
     cypher_union.union_symbols_.push_back(symbol);
   }
@@ -259,7 +268,9 @@ bool SymbolGenerator::PreVisit(Return &ret) {
 }
 
 bool SymbolGenerator::PostVisit(Return &) {
-  for (const auto &name_symbol : scopes_.back().symbols) curr_return_names_.insert(name_symbol.first);
+  auto &scope = scopes_.back();
+
+  for (const auto &name_symbol : scope.symbols) scope.curr_return_names.insert(name_symbol.first);
   return true;
 }