Add debugging tools

Co-authored-by: Josip Mrden <josip.mrden@memgraph.io>

.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

@@ -437,7 +437,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:
@@ -177,6 +182,23 @@ jobs:
           name: fedora-36
           path: build/output/fedora-36/memgraph*.rpm
 
+  amzn-2:
+    runs-on: [self-hosted, DockerMgBuild, X64]
+    timeout-minutes: 60
+    steps:
+      - name: "Set up repository"
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # Required because of release/get_version.py
+      - name: "Build package"
+        run: |
+          ./release/package/run.sh package amzn-2
+      - name: "Upload package"
+        uses: actions/upload-artifact@v3
+        with:
+          name: amzn-2
+          path: build/output/amzn-2/memgraph*.rpm
+
   debian-11-arm:
     runs-on: [self-hosted, DockerMgBuild, ARM64, strange]
     timeout-minutes: 60
@@ -191,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:
@@ -208,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_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 .

.gitignore

@@ -34,9 +34,6 @@ TAGS
 *.fas
 *.fasl
 
-# LCP generated C++ files
-*.lcp.cpp
-
 src/database/distributed/serialization.hpp
 src/database/single_node_ha/serialization.hpp
 src/distributed/bfs_rpc_messages.hpp
@@ -50,15 +47,11 @@ src/distributed/pull_produce_rpc_messages.hpp
 src/distributed/storage_gc_rpc_messages.hpp
 src/distributed/token_sharing_rpc_messages.hpp
 src/distributed/updates_rpc_messages.hpp
-src/query/frontend/ast/ast.hpp
-src/query/distributed/frontend/ast/ast_serialization.hpp
 src/durability/distributed/state_delta.hpp
 src/durability/single_node/state_delta.hpp
 src/durability/single_node_ha/state_delta.hpp
-src/query/frontend/semantic/symbol.hpp
 src/query/distributed/frontend/semantic/symbol_serialization.hpp
 src/query/distributed/plan/ops.hpp
-src/query/plan/operator.hpp
 src/raft/log_entry.hpp
 src/raft/raft_rpc_messages.hpp
 src/raft/snapshot_metadata.hpp

.pre-commit-config.yaml

@@ -1,16 +1,17 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v2.3.0
+    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
-    rev: 22.8.0
+    rev: 23.1.0
     hooks:
       - id: black
   - repo: https://github.com/pycqa/isort
-    rev: 5.10.1
+    rev: 5.12.0
     hooks:
       - id: isort
         name: isort (python)

CMakeLists.txt

@@ -231,7 +231,17 @@ endif()
 message(STATUS "CMake build type: ${CMAKE_BUILD_TYPE}")
 # -----------------------------------------------------------------------------
 
-set(MG_ARCH "x86_64" CACHE STRING "Host architecture to build Memgraph on. Supported values are x86_64 (default), ARM64.")
+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")
+        set(MG_ARCH "ARM64" CACHE STRING ${MG_ARCH_DESCR})
+    else()
+        set(MG_ARCH "x86_64" CACHE STRING ${MG_ARCH_DESCR})
+    endif()
+endif()
+message(STATUS "MG_ARCH: ${MG_ARCH}")
 
 # setup external dependencies -------------------------------------------------
 

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"

environment/os/amzn-2.sh

@@ -0,0 +1,156 @@
+#!/bin/bash
+
+set -Eeuo pipefail
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+source "$DIR/../util.sh"
+
+check_operating_system "amzn-2"
+check_architecture "x86_64"
+
+TOOLCHAIN_BUILD_DEPS=(
+    gcc gcc-c++ make # generic build tools
+    wget # used for archive download
+    gnupg2 # used for archive signature verification
+    tar gzip bzip2 xz unzip # used for archive unpacking
+    zlib-devel # zlib library used for all builds
+    expat-devel xz-devel python3-devel texinfo
+    curl libcurl-devel # for cmake
+    readline-devel # for cmake and llvm
+    libffi-devel libxml2-devel # for llvm
+    libedit-devel pcre-devel automake bison # for swig
+    file
+    openssl-devel
+    gmp-devel
+    gperf
+    diffutils
+    patch
+    libipt libipt-devel # intel
+    perl # for openssl
+)
+
+TOOLCHAIN_RUN_DEPS=(
+    make # generic build tools
+    tar gzip bzip2 xz # used for archive unpacking
+    zlib # zlib library used for all builds
+    expat xz-libs python3 # for gdb
+    readline # for cmake and llvm
+    libffi libxml2 # for llvm
+    openssl-devel
+)
+
+MEMGRAPH_BUILD_DEPS=(
+    git # source code control
+    make # build system
+    wget # for downloading libs
+    libuuid-devel java-11-openjdk # required by antlr
+    readline-devel # for memgraph console
+    python3-devel # for query modules
+    openssl-devel
+    libseccomp-devel
+    python3 python3-pip nmap-ncat # for tests
+    #
+    # IMPORTANT: python3-yaml does NOT exist on CentOS
+    # Install it using `pip3 install PyYAML`
+    #
+    PyYAML # Package name here does not correspond to the yum package!
+    libcurl-devel # mg-requests
+    rpm-build rpmlint # for RPM package building
+    doxygen graphviz # source documentation generators
+    which nodejs golang zip unzip java-11-openjdk-devel # for driver tests
+    autoconf # for jemalloc code generation
+    libtool  # for protobuf code generation
+)
+
+list() {
+    echo "$1"
+}
+
+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=""
+    for pkg in $1; do
+        if [ "$pkg" == "PyYAML" ]; then
+            if ! python3 -c "import yaml" >/dev/null 2>/dev/null; then
+                missing="$pkg $missing"
+            fi
+            continue
+        fi
+        if ! yum list installed "$pkg" >/dev/null 2>/dev/null; then
+            missing="$pkg $missing"
+        fi
+    done
+    if [ "$missing" != "" ]; then
+        echo "MISSING PACKAGES: $missing"
+        exit 1
+    fi
+    LD_LIBRARY_PATH=${OLD_LD_LIBRARY_PATH}
+}
+
+install() {
+    cd "$DIR"
+    if [ "$EUID" -ne 0 ]; then
+        echo "Please run as root."
+        exit 1
+    fi
+    # If GitHub Actions runner is installed, append LANG to the environment.
+    # Python related tests don't work without the LANG export.
+    if [ -d "/home/gh/actions-runner" ]; then
+        echo "LANG=en_US.utf8" >> /home/gh/actions-runner/.env
+    else
+        echo "NOTE: export LANG=en_US.utf8"
+    fi
+    yum update -y
+    for pkg in $1; do
+        if [ "$pkg" == libipt ]; then
+            if ! yum list installed libipt >/dev/null 2>/dev/null; then
+                yum install -y http://repo.okay.com.mx/centos/8/x86_64/release/libipt-1.6.1-8.el8.x86_64.rpm
+            fi
+            continue
+        fi
+        if [ "$pkg" == libipt-devel ]; then
+            if ! yum list installed libipt-devel >/dev/null 2>/dev/null; then
+                yum install -y http://repo.okay.com.mx/centos/8/x86_64/release/libipt-devel-1.6.1-8.el8.x86_64.rpm
+            fi
+            continue
+        fi
+        if [ "$pkg" == nodejs ]; then
+            curl -sL https://rpm.nodesource.com/setup_16.x | bash -
+            if ! yum list installed nodejs >/dev/null 2>/dev/null; then
+                yum install -y nodejs
+            fi
+            continue
+        fi
+        if [ "$pkg" == PyYAML ]; then
+            if [ -z ${SUDO_USER+x} ]; then # Running as root (e.g. Docker).
+                pip3 install --user PyYAML
+            else # Running using sudo.
+                sudo -H -u "$SUDO_USER" bash -c "pip3 install --user PyYAML"
+            fi
+            continue
+        fi
+        if [ "$pkg" == nodejs ]; then
+            curl -sL https://rpm.nodesource.com/setup_16.x | bash -
+            if ! yum list installed nodejs >/dev/null 2>/dev/null; then
+                yum install -y nodejs
+            fi
+            continue
+        fi
+        if [ "$pkg" == java-11-openjdk ]; then
+            amazon-linux-extras install -y java-openjdk11
+            continue
+        fi
+        if [ "$pkg" == java-11-openjdk-devel ]; then
+            amazon-linux-extras install -y java-openjdk11
+            yum install -y java-11-openjdk-devel
+            continue
+        fi
+        yum install -y "$pkg"
+    done
+}
+
+deps=$2"[*]"
+"$1" "${!deps}"

environment/toolchain/v4.sh

@@ -415,6 +415,34 @@ if [ ! -f $PREFIX/bin/gdb ]; then
                 --with-intel-pt \
                 --enable-tui \
                 --with-python=python3
+    elif [[ "${DISTRO}" == "amzn-2" ]]; then
+        # Remove readline, gdb does not compile
+        env \
+            CC=gcc \
+            CXX=g++ \
+            CFLAGS="-g -O2 -fstack-protector-strong -Wformat -Werror=format-security" \
+            CXXFLAGS="-g -O2 -fstack-protector-strong -Wformat -Werror=format-security" \
+            CPPFLAGS="-Wdate-time -D_FORTIFY_SOURCE=2 -fPIC" \
+            LDFLAGS="-Wl,-z,relro" \
+            PYTHON="" \
+            ../configure \
+                --build=x86_64-linux-gnu \
+                --host=x86_64-linux-gnu \
+                --prefix=$PREFIX \
+                --disable-maintainer-mode \
+                --disable-dependency-tracking \
+                --disable-silent-rules \
+                --disable-gdbtk \
+                --disable-shared \
+                --without-guile \
+                --with-system-gdbinit=$PREFIX/etc/gdb/gdbinit \
+                --with-expat \
+                --with-system-zlib \
+                --with-lzma \
+                --with-babeltrace \
+                --with-intel-pt \
+                --enable-tui \
+                --with-python=python3
     else
         # https://buildd.debian.org/status/fetch.php?pkg=gdb&arch=amd64&ver=8.2.1-2&stamp=1550831554&raw=0
         env \
@@ -1143,119 +1171,121 @@ if [ ! -f $PREFIX/include/libaio.h ]; then
     popd
 fi
 
-log_tool_name "folly $FBLIBS_VERSION"
-if [ ! -d $PREFIX/include/folly ]; then
-    if [ -d folly-$FBLIBS_VERSION ]; then
-        rm -rf folly-$FBLIBS_VERSION
+if [[ "${DISTRO}" != "amzn-2" ]]; then
+    log_tool_name "folly $FBLIBS_VERSION"
+    if [ ! -d $PREFIX/include/folly ]; then
+        if [ -d folly-$FBLIBS_VERSION ]; then
+            rm -rf folly-$FBLIBS_VERSION
+        fi
+        mkdir folly-$FBLIBS_VERSION
+        tar -xzf ../archives/folly-$FBLIBS_VERSION.tar.gz -C folly-$FBLIBS_VERSION
+        pushd folly-$FBLIBS_VERSION
+        patch -p1 < ../../folly.patch
+        # build is used by facebook builder
+        mkdir _build
+        pushd _build
+        cmake .. $COMMON_CMAKE_FLAGS \
+            -DBOOST_LINK_STATIC=ON \
+            -DBUILD_TESTS=OFF \
+            -DGFLAGS_NOTHREADS=OFF \
+            -DCXX_STD="c++20"
+        make -j$CPUS install
+        popd && popd
     fi
-    mkdir folly-$FBLIBS_VERSION
-    tar -xzf ../archives/folly-$FBLIBS_VERSION.tar.gz -C folly-$FBLIBS_VERSION
-    pushd folly-$FBLIBS_VERSION
-    patch -p1 < ../../folly.patch
-    # build is used by facebook builder
-    mkdir _build
-    pushd _build
-    cmake .. $COMMON_CMAKE_FLAGS \
-        -DBOOST_LINK_STATIC=ON \
-        -DBUILD_TESTS=OFF \
-        -DGFLAGS_NOTHREADS=OFF \
-        -DCXX_STD="c++20"
-    make -j$CPUS install
-    popd && popd
-fi
 
-log_tool_name "fizz $FBLIBS_VERSION"
-if [ ! -d $PREFIX/include/fizz ]; then
-    if [ -d fizz-$FBLIBS_VERSION ]; then
-        rm -rf fizz-$FBLIBS_VERSION
+    log_tool_name "fizz $FBLIBS_VERSION"
+    if [ ! -d $PREFIX/include/fizz ]; then
+        if [ -d fizz-$FBLIBS_VERSION ]; then
+            rm -rf fizz-$FBLIBS_VERSION
+        fi
+        mkdir fizz-$FBLIBS_VERSION
+        tar -xzf ../archives/fizz-$FBLIBS_VERSION.tar.gz -C fizz-$FBLIBS_VERSION
+        pushd fizz-$FBLIBS_VERSION
+        # build is used by facebook builder
+        mkdir _build
+        pushd _build
+        cmake ../fizz $COMMON_CMAKE_FLAGS \
+            -DBUILD_TESTS=OFF \
+            -DBUILD_EXAMPLES=OFF \
+            -DGFLAGS_NOTHREADS=OFF
+        make -j$CPUS install
+        popd && popd
     fi
-    mkdir fizz-$FBLIBS_VERSION
-    tar -xzf ../archives/fizz-$FBLIBS_VERSION.tar.gz -C fizz-$FBLIBS_VERSION
-    pushd fizz-$FBLIBS_VERSION
-    # build is used by facebook builder
-    mkdir _build
-    pushd _build
-    cmake ../fizz $COMMON_CMAKE_FLAGS \
-        -DBUILD_TESTS=OFF \
-        -DBUILD_EXAMPLES=OFF \
-        -DGFLAGS_NOTHREADS=OFF
-    make -j$CPUS install
-    popd && popd
-fi
 
-log_tool_name "wangle FBLIBS_VERSION"
-if [ ! -d $PREFIX/include/wangle ]; then
-    if [ -d wangle-$FBLIBS_VERSION ]; then
-        rm -rf wangle-$FBLIBS_VERSION
+    log_tool_name "wangle FBLIBS_VERSION"
+    if [ ! -d $PREFIX/include/wangle ]; then
+        if [ -d wangle-$FBLIBS_VERSION ]; then
+            rm -rf wangle-$FBLIBS_VERSION
+        fi
+        mkdir wangle-$FBLIBS_VERSION
+        tar -xzf ../archives/wangle-$FBLIBS_VERSION.tar.gz -C wangle-$FBLIBS_VERSION
+        pushd wangle-$FBLIBS_VERSION
+        # build is used by facebook builder
+        mkdir _build
+        pushd _build
+        cmake ../wangle $COMMON_CMAKE_FLAGS \
+            -DBUILD_TESTS=OFF \
+            -DBUILD_EXAMPLES=OFF \
+            -DGFLAGS_NOTHREADS=OFF
+        make -j$CPUS install
+        popd && popd
     fi
-    mkdir wangle-$FBLIBS_VERSION
-    tar -xzf ../archives/wangle-$FBLIBS_VERSION.tar.gz -C wangle-$FBLIBS_VERSION
-    pushd wangle-$FBLIBS_VERSION
-    # build is used by facebook builder
-    mkdir _build
-    pushd _build
-    cmake ../wangle $COMMON_CMAKE_FLAGS \
-        -DBUILD_TESTS=OFF \
-        -DBUILD_EXAMPLES=OFF \
-        -DGFLAGS_NOTHREADS=OFF
-    make -j$CPUS install
-    popd && popd
-fi
 
-log_tool_name "proxygen $FBLIBS_VERSION"
-if [ ! -d $PREFIX/include/proxygen ]; then
-    if [ -d proxygen-$FBLIBS_VERSION ]; then
-        rm -rf proxygen-$FBLIBS_VERSION
+    log_tool_name "proxygen $FBLIBS_VERSION"
+    if [ ! -d $PREFIX/include/proxygen ]; then
+        if [ -d proxygen-$FBLIBS_VERSION ]; then
+            rm -rf proxygen-$FBLIBS_VERSION
+        fi
+        mkdir proxygen-$FBLIBS_VERSION
+        tar -xzf ../archives/proxygen-$FBLIBS_VERSION.tar.gz -C proxygen-$FBLIBS_VERSION
+        pushd proxygen-$FBLIBS_VERSION
+        patch -p1 < ../../proxygen.patch
+        # build is used by facebook builder
+        mkdir _build
+        pushd _build
+        cmake .. $COMMON_CMAKE_FLAGS \
+            -DBUILD_TESTS=OFF \
+            -DBUILD_SAMPLES=OFF \
+            -DGFLAGS_NOTHREADS=OFF \
+            -DBUILD_QUIC=OFF
+        make -j$CPUS install
+        popd && popd
     fi
-    mkdir proxygen-$FBLIBS_VERSION
-    tar -xzf ../archives/proxygen-$FBLIBS_VERSION.tar.gz -C proxygen-$FBLIBS_VERSION
-    pushd proxygen-$FBLIBS_VERSION
-    patch -p1 < ../../proxygen.patch
-    # build is used by facebook builder
-    mkdir _build
-    pushd _build
-    cmake .. $COMMON_CMAKE_FLAGS \
-        -DBUILD_TESTS=OFF \
-        -DBUILD_SAMPLES=OFF \
-        -DGFLAGS_NOTHREADS=OFF \
-        -DBUILD_QUIC=OFF
-    make -j$CPUS install
-    popd && popd
-fi
 
-log_tool_name "flex $FBLIBS_VERSION"
-if [ ! -f $PREFIX/include/FlexLexer.h ]; then
-    if [ -d flex-$FLEX_VERSION ]; then
-        rm -rf flex-$FLEX_VERSION
+    log_tool_name "flex $FBLIBS_VERSION"
+    if [ ! -f $PREFIX/include/FlexLexer.h ]; then
+        if [ -d flex-$FLEX_VERSION ]; then
+            rm -rf flex-$FLEX_VERSION
+        fi
+        tar -xzf ../archives/flex-$FLEX_VERSION.tar.gz
+        pushd flex-$FLEX_VERSION
+        ./configure $COMMON_CONFIGURE_FLAGS
+        make -j$CPUS install
+        popd
     fi
-    tar -xzf ../archives/flex-$FLEX_VERSION.tar.gz
-    pushd flex-$FLEX_VERSION
-    ./configure $COMMON_CONFIGURE_FLAGS
-    make -j$CPUS install
-    popd
-fi
 
-log_tool_name "fbthrift $FBLIBS_VERSION"
-if [ ! -d $PREFIX/include/thrift ]; then
-    if [ -d fbthrift-$FBLIBS_VERSION ]; then
-        rm -rf fbthrift-$FBLIBS_VERSION
+    log_tool_name "fbthrift $FBLIBS_VERSION"
+    if [ ! -d $PREFIX/include/thrift ]; then
+        if [ -d fbthrift-$FBLIBS_VERSION ]; then
+            rm -rf fbthrift-$FBLIBS_VERSION
+        fi
+        git clone --depth 1 --branch v$FBLIBS_VERSION https://github.com/facebook/fbthrift.git fbthrift-$FBLIBS_VERSION
+        pushd fbthrift-$FBLIBS_VERSION
+        # build is used by facebook builder
+        mkdir _build
+        pushd _build
+        if [ "$TOOLCHAIN_STDCXX" = "libstdc++" ]; then
+            CMAKE_CXX_FLAGS="-fsized-deallocation"
+        else
+            CMAKE_CXX_FLAGS="-fsized-deallocation -stdlib=libc++"
+        fi
+        cmake .. $COMMON_CMAKE_FLAGS \
+            -Denable_tests=OFF \
+            -DGFLAGS_NOTHREADS=OFF \
+            -DCMAKE_CXX_FLAGS="$CMAKE_CXX_FLAGS"
+        make -j$CPUS install
+        popd
     fi
-    git clone --depth 1 --branch v$FBLIBS_VERSION https://github.com/facebook/fbthrift.git fbthrift-$FBLIBS_VERSION
-    pushd fbthrift-$FBLIBS_VERSION
-    # build is used by facebook builder
-    mkdir _build
-    pushd _build
-    if [ "$TOOLCHAIN_STDCXX" = "libstdc++" ]; then
-        CMAKE_CXX_FLAGS="-fsized-deallocation"
-    else
-        CMAKE_CXX_FLAGS="-fsized-deallocation -stdlib=libc++"
-    fi
-    cmake .. $COMMON_CMAKE_FLAGS \
-        -Denable_tests=OFF \
-        -DGFLAGS_NOTHREADS=OFF \
-        -DCMAKE_CXX_FLAGS="$CMAKE_CXX_FLAGS"
-    make -j$CPUS install
-    popd
 fi
 
 popd

include/_mgp_mock.py

@@ -0,0 +1,343 @@
+import typing
+from enum import Enum
+
+import networkx as nx
+
+NX_LABEL_ATTR = "labels"
+NX_TYPE_ATTR = "type"
+
+SOURCE_TYPE_KAFKA = "SOURCE_TYPE_KAFKA"
+SOURCE_TYPE_PULSAR = "SOURCE_TYPE_PULSAR"
+
+"""
+This module provides helpers for the mock Python API, much like _mgp.py does for mgp.py.
+"""
+
+
+class InvalidArgumentError(Exception):
+    """
+    Signals that some of the arguments have invalid values.
+    """
+
+    pass
+
+
+class ImmutableObjectError(Exception):
+    pass
+
+
+class LogicErrorError(Exception):
+    pass
+
+
+class DeletedObjectError(Exception):
+    pass
+
+
+class EdgeConstants(Enum):
+    I_START = 0
+    I_END = 1
+    I_KEY = 2
+
+
+class Graph:
+    """Wrapper around a NetworkX MultiDiGraph instance."""
+
+    __slots__ = ("nx", "_highest_vertex_id", "_highest_edge_id", "_valid")
+
+    def __init__(self, graph: nx.MultiDiGraph) -> None:
+        if not isinstance(graph, nx.MultiDiGraph):
+            raise TypeError(f"Expected 'networkx.classes.multidigraph.MultiDiGraph', got '{type(graph)}'")
+
+        self.nx = graph
+        self._highest_vertex_id = None
+        self._highest_edge_id = None
+        self._valid = True
+
+    @property
+    def vertex_ids(self):
+        return self.nx.nodes
+
+    def vertex_is_isolate(self, vertex_id: int) -> bool:
+        return nx.is_isolate(self.nx, vertex_id)
+
+    @property
+    def vertices(self):
+        return (Vertex(node_id, self) for node_id in self.nx.nodes)
+
+    def has_node(self, node_id):
+        return self.nx.has_node(node_id)
+
+    @property
+    def edges(self):
+        return self.nx.edges
+
+    def is_valid(self) -> bool:
+        return self._valid
+
+    def get_vertex_by_id(self, vertex_id: int) -> "Vertex":
+        return Vertex(vertex_id, self)
+
+    def invalidate(self):
+        self._valid = False
+
+    def is_immutable(self) -> bool:
+        return nx.is_frozen(self.nx)
+
+    def make_immutable(self):
+        self.nx = nx.freeze(self.nx)
+
+    def _new_vertex_id(self):
+        if self._highest_vertex_id is None:
+            self._highest_vertex_id = max(vertex_id for vertex_id in self.nx.nodes)
+
+        return self._highest_vertex_id + 1
+
+    def _new_edge_id(self):
+        if self._highest_edge_id is None:
+            self._highest_edge_id = max(edge[EdgeConstants.I_KEY.value] for edge in self.nx.edges(keys=True))
+
+        return self._highest_edge_id + 1
+
+    def create_vertex(self) -> "Vertex":
+        vertex_id = self._new_vertex_id()
+
+        self.nx.add_node(vertex_id)
+        self._highest_vertex_id = vertex_id
+
+        return Vertex(vertex_id, self)
+
+    def create_edge(self, from_vertex: "Vertex", to_vertex: "Vertex", edge_type: str) -> "Edge":
+        if from_vertex.is_deleted() or to_vertex.is_deleted():
+            raise DeletedObjectError("Accessing deleted object.")
+
+        edge_id = self._new_edge_id()
+
+        from_id = from_vertex.id
+        to_id = to_vertex.id
+
+        self.nx.add_edge(from_id, to_id, key=edge_id, type=edge_type)
+        self._highest_edge_id = edge_id
+
+        return Edge((from_id, to_id, edge_id), self)
+
+    def delete_vertex(self, vertex_id: int):
+        self.nx.remove_node(vertex_id)
+
+    def delete_edge(self, from_vertex_id: int, to_vertex_id: int, edge_id: int):
+        self.nx.remove_edge(from_vertex_id, to_vertex_id, edge_id)
+
+    @property
+    def highest_vertex_id(self) -> int:
+        if self._highest_vertex_id is None:
+            self._highest_vertex_id = max(vertex_id for vertex_id in self.nx.nodes) + 1
+
+        return self._highest_vertex_id
+
+    @property
+    def highest_edge_id(self) -> int:
+        if self._highest_edge_id is None:
+            self._highest_edge_id = max(edge[EdgeConstants.I_KEY.value] for edge in self.nx.edges(keys=True))
+
+        return self._highest_edge_id + 1
+
+
+class Vertex:
+    """Represents a graph vertex."""
+
+    __slots__ = ("_id", "_graph")
+
+    def __init__(self, id: int, graph: Graph) -> None:
+        if not isinstance(id, int):
+            raise TypeError(f"Expected 'int', got '{type(id)}'")
+
+        if not isinstance(graph, Graph):
+            raise TypeError(f"Expected '_mgp_mock.Graph', got '{type(graph)}'")
+
+        if not graph.nx.has_node(id):
+            raise IndexError(f"Unable to find vertex with ID {id}.")
+
+        self._id = id
+        self._graph = graph
+
+    def is_valid(self) -> bool:
+        return self._graph.is_valid()
+
+    def is_deleted(self) -> bool:
+        return not self._graph.nx.has_node(self._id) and self._id <= self._graph.highest_vertex_id
+
+    @property
+    def underlying_graph(self) -> Graph:
+        return self._graph
+
+    def underlying_graph_is_mutable(self) -> bool:
+        return not nx.is_frozen(self._graph.nx)
+
+    @property
+    def labels(self) -> typing.List[int]:
+        return self._graph.nx.nodes[self._id][NX_LABEL_ATTR].split(":")
+
+    def add_label(self, label: str) -> None:
+        if nx.is_frozen(self._graph.nx):
+            raise ImmutableObjectError("Cannot modify immutable object.")
+
+        self._graph.nx.nodes[self._id][NX_LABEL_ATTR] += f":{label}"
+
+    def remove_label(self, label: str) -> None:
+        if nx.is_frozen(self._graph.nx):
+            raise ImmutableObjectError("Cannot modify immutable object.")
+
+        labels = self._graph.nx.nodes[self._id][NX_LABEL_ATTR]
+        if labels.startswith(f"{label}:"):
+            labels = "\n" + labels  # pseudo-string starter
+            self._graph.nx.nodes[self._id][NX_LABEL_ATTR] = labels.replace(f"\n{label}:", "")
+        elif labels.endswith(f":{label}"):
+            labels += "\n"  # pseudo-string terminator
+            self._graph.nx.nodes[self._id][NX_LABEL_ATTR] = labels.replace(f":{label}\n", "")
+        else:
+            self._graph.nx.nodes[self._id][NX_LABEL_ATTR] = labels.replace(f":{label}:", ":")
+
+    @property
+    def id(self) -> int:
+        return self._id
+
+    @property
+    def properties(self):
+        return (
+            (key, value)
+            for key, value in self._graph.nx.nodes[self._id].items()
+            if key not in (NX_LABEL_ATTR, NX_TYPE_ATTR)
+        )
+
+    def get_property(self, property_name: str):
+        return self._graph.nx.nodes[self._id][property_name]
+
+    def set_property(self, property_name: str, value: object):
+        self._graph.nx.nodes[self._id][property_name] = value
+
+    @property
+    def in_edges(self) -> typing.Iterable["Edge"]:
+        return [Edge(edge, self._graph) for edge in self._graph.nx.in_edges(self._id, keys=True)]
+
+    @property
+    def out_edges(self) -> typing.Iterable["Edge"]:
+        return [Edge(edge, self._graph) for edge in self._graph.nx.out_edges(self._id, keys=True)]
+
+
+class Edge:
+    """Represents a graph edge."""
+
+    __slots__ = ("_edge", "_graph")
+
+    def __init__(self, edge: typing.Tuple[int, int, int], graph: Graph) -> None:
+        if not isinstance(edge, typing.Tuple):
+            raise TypeError(f"Expected 'Tuple', got '{type(edge)}'")
+
+        if not isinstance(graph, Graph):
+            raise TypeError(f"Expected '_mgp_mock.Graph', got '{type(graph)}'")
+
+        if not graph.nx.has_edge(*edge):
+            raise IndexError(f"Unable to find edge with ID {edge[EdgeConstants.I_KEY.value]}.")
+
+        self._edge = edge
+        self._graph = graph
+
+    def is_valid(self) -> bool:
+        return self._graph.is_valid()
+
+    def is_deleted(self) -> bool:
+        return (
+            not self._graph.nx.has_edge(*self._edge)
+            and self._edge[EdgeConstants.I_KEY.value] <= self._graph.highest_edge_id
+        )
+
+    def underlying_graph_is_mutable(self) -> bool:
+        return not nx.is_frozen(self._graph.nx)
+
+    @property
+    def id(self) -> int:
+        return self._edge[EdgeConstants.I_KEY.value]
+
+    @property
+    def edge(self) -> typing.Tuple[int, int, int]:
+        return self._edge
+
+    @property
+    def start_id(self) -> int:
+        return self._edge[EdgeConstants.I_START.value]
+
+    @property
+    def end_id(self) -> int:
+        return self._edge[EdgeConstants.I_END.value]
+
+    def get_type_name(self):
+        return self._graph.nx.get_edge_data(*self._edge)[NX_TYPE_ATTR]
+
+    def from_vertex(self) -> Vertex:
+        return Vertex(self.start_id, self._graph)
+
+    def to_vertex(self) -> Vertex:
+        return Vertex(self.end_id, self._graph)
+
+    @property
+    def properties(self):
+        return (
+            (key, value)
+            for key, value in self._graph.nx.edges[self._edge].items()
+            if key not in (NX_LABEL_ATTR, NX_TYPE_ATTR)
+        )
+
+    def get_property(self, property_name: str):
+        return self._graph.nx.edges[self._edge][property_name]
+
+    def set_property(self, property_name: str, value: object):
+        self._graph.nx.edges[self._edge][property_name] = value
+
+
+class Path:
+    """Represents a path comprised of `Vertex` and `Edge` instances."""
+
+    __slots__ = ("_vertices", "_edges", "_graph")
+    __create_key = object()
+
+    def __init__(self, create_key, vertex_id: int, graph: Graph) -> None:
+        assert create_key == Path.__create_key, "Path objects must be created using Path.make_with_start"
+
+        self._vertices = [vertex_id]
+        self._edges = []
+        self._graph = graph
+
+    @classmethod
+    def make_with_start(cls, vertex: Vertex) -> "Path":
+        if not isinstance(vertex, Vertex):
+            raise TypeError(f"Expected 'Vertex', got '{type(vertex)}'")
+
+        if not isinstance(vertex.underlying_graph, Graph):
+            raise TypeError(f"Expected '_mgp_mock.Graph', got '{type(vertex.underlying_graph)}'")
+
+        if not vertex.underlying_graph.nx.has_node(vertex._id):
+            raise IndexError(f"Unable to find vertex with ID {vertex._id}.")
+
+        return Path(cls.__create_key, vertex._id, vertex.underlying_graph)
+
+    def is_valid(self) -> bool:
+        return self._graph.is_valid()
+
+    def underlying_graph_is_mutable(self) -> bool:
+        return not nx.is_frozen(self._graph.nx)
+
+    def expand(self, edge: Edge):
+        if edge.start_id != self._vertices[-1]:
+            raise LogicErrorError("Logic error.")
+
+        self._vertices.append(edge.end_id)
+        self._edges.append((edge.start_id, edge.end_id, edge.id))
+
+    def vertex_at(self, index: int) -> Vertex:
+        return Vertex(self._vertices[index], self._graph)
+
+    def edge_at(self, index: int) -> Edge:
+        return Edge(self._edges[index], self._graph)
+
+    def size(self) -> int:
+        return len(self._edges)

include/mgp.hpp

@@ -55,6 +55,15 @@ class NotEnoughMemoryException : public std::exception {
   const char *what() const throw() { return "Not enough memory!"; }
 };
 
+class MustAbortException : public std::exception {
+ public:
+  explicit MustAbortException(const std::string &message) : message_(message) {}
+  const char *what() const noexcept override { return message_.c_str(); }
+
+ private:
+  std::string message_;
+};
+
 // Forward declarations
 class Nodes;
 using GraphNodes = Nodes;
@@ -141,6 +150,10 @@ class Graph {
   /// @brief Deletes a relationship from the graph.
   void DeleteRelationship(const Relationship &relationship);
 
+  bool MustAbort() const;
+
+  void CheckMustAbort() const;
+
  private:
   mgp_graph *graph_;
 };
@@ -1572,6 +1585,14 @@ inline Id::Id(int64_t id) : id_(id) {}
 
 inline Graph::Graph(mgp_graph *graph) : graph_(graph) {}
 
+inline bool Graph::MustAbort() const { return must_abort(graph_); }
+
+inline void Graph::CheckMustAbort() const {
+  if (MustAbort()) {
+    throw MustAbortException("Query was asked to abort.");
+  }
+}
+
 inline int64_t Graph::Order() const {
   int64_t i = 0;
   for (const auto _ : Nodes()) {

init

@@ -14,7 +14,6 @@ function print_help () {
     echo "Optional arguments:"
     echo -e "  -h\tdisplay this help and exit"
     echo -e "  --without-libs-setup\tskip the step for setting up libs"
-    echo -e "  --wsl-quicklisp-proxy \"host:port\"\tquicklist HTTP proxy (this flag + HTTP proxy are required on WSL)"
 }
 
 function setup_virtualenv () {
@@ -35,7 +34,6 @@ function setup_virtualenv () {
     popd > /dev/null
 }
 
-wsl_quicklisp_proxy=""
 setup_libs=true
 if [[ $# -eq 1 && "$1" == "-h" ]]; then
     print_help
@@ -43,16 +41,6 @@ if [[ $# -eq 1 && "$1" == "-h" ]]; then
 else
     while(($#)); do
         case "$1" in
-          --wsl-quicklisp-proxy)
-              shift
-              if [[ $# -eq 0 ]]; then
-                  echo "Missing proxy URL"
-                  print_help
-                  exit 1
-              fi
-              wsl_quicklisp_proxy=":proxy \"http://$1/\""
-              shift
-          ;;
           --without-libs-setup)
               shift
               setup_libs=false
@@ -79,41 +67,16 @@ echo "All packages are in-place..."
 # create a default build directory
 mkdir -p ./build
 
-# quicklisp package manager for Common Lisp
-quicklisp_install_dir="$HOME/quicklisp"
-if [[ -v QUICKLISP_HOME ]]; then
-  quicklisp_install_dir="${QUICKLISP_HOME}"
-fi
-
-if [[ ! -f "${quicklisp_install_dir}/setup.lisp" ]]; then
-  wget -nv https://beta.quicklisp.org/quicklisp.lisp -O quicklisp.lisp || exit 1
-  echo \
-  "
-  (load \"${DIR}/quicklisp.lisp\")
-  (quicklisp-quickstart:install $wsl_quicklisp_proxy :path \"${quicklisp_install_dir}\")
-  " | sbcl --script || exit 1
-  rm -rf quicklisp.lisp || exit 1
-fi
-ln -Tfs "$DIR/src/lisp" "${quicklisp_install_dir}/local-projects/lcp"
-# Install LCP dependencies
-# TODO: We should at some point cache or have a mirror of packages we use.
-# TODO: move the installation of LCP's dependencies into ./setup.sh
-echo \
-  "
-  (load \"${quicklisp_install_dir}/setup.lisp\")
-  (ql:quickload '(:lcp :lcp/test) :silent t)
-  " | sbcl --script
-
 if [[ "$setup_libs" == "true" ]]; then
-    # Setup libs (download).
-    cd libs
-    ./cleanup.sh
-    ./setup.sh
-    cd ..
+  # Setup libs (download).
+  cd libs
+  ./cleanup.sh
+  ./setup.sh
+  cd ..
 fi
 
 # Fix for centos 7 during release
-if [ "${DISTRO}" = "centos-7" ] || [ "${DISTRO}" = "debian-11" ]; then
+if [ "${DISTRO}" = "centos-7" ] || [ "${DISTRO}" = "debian-11" ] || [ "${DISTRO}" = "amzn-2" ]; then
   python3 -m pip uninstall -y virtualenv
   python3 -m pip install virtualenv
 fi
@@ -143,15 +106,18 @@ for hook in $(find $DIR/.githooks -type f -printf "%f\n"); do
   echo "Added $hook hook"
 done;
 
-# Install precommit hook
-python3 -m pip install pre-commit
-python3 -m pre_commit install
-
-# Install py format tools
-echo "Install black formatter"
-python3 -m pip install black==22.8.*
-echo "Install isort"
-python3 -m pip install isort==5.10.*
+# 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" ] && [ "${DISTRO}" != "amzn-2" ]; then
+  python3 -m pip install pre-commit
+  python3 -m pre_commit install
+  # Install py format tools for usage during the development.
+  echo "Install black formatter"
+  python3 -m pip install black==23.1.*
+  echo "Install isort"
+  python3 -m pip install isort==5.12.*
+fi
 
 # Link `include/mgp.py` with `release/mgp/mgp.py`
 ln -v -f include/mgp.py release/mgp/mgp.py

libs/.gitignore

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

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,7 +117,7 @@ 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"
@@ -142,7 +142,7 @@ 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"
@@ -180,9 +180,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 +192,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

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-26-01
+CHANGE DATE:            2027-18-05
 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

@@ -1,6 +1,10 @@
 # Install systemd service (must use absolute path).
 install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/memgraph.service
-        DESTINATION /lib/systemd/system)
+    DESTINATION /lib/systemd/system)
+
+# Set parameters to recognize the host distro
+cmake_host_system_information(RESULT DISTRO QUERY DISTRIB_NAME)
+cmake_host_system_information(RESULT DISTRO_VERSION QUERY DISTRIB_VERSION)
 
 # ---- Setup CPack --------
 
@@ -12,10 +16,11 @@ set(CPACK_PACKAGE_DESCRIPTION_SUMMARY
 
 # Setting arhitecture extension for deb packages
 set(MG_ARCH_EXTENSION_DEB "all")
-if (${MG_ARCH} STREQUAL "x86_64")
+
+if(${MG_ARCH} STREQUAL "x86_64")
     set(MG_ARCH_EXTENSION_DEB "amd64")
-elseif (${MG_ARCH} STREQUAL "ARM64")
-    set(MG_ARCH_EXTENSION_DEB  "arm64")
+elseif(${MG_ARCH} STREQUAL "ARM64")
+    set(MG_ARCH_EXTENSION_DEB "arm64")
 endif()
 
 # DEB specific
@@ -34,21 +39,24 @@ set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA
     "${CMAKE_CURRENT_SOURCE_DIR}/debian/postrm;"
     "${CMAKE_CURRENT_SOURCE_DIR}/debian/postinst;")
 set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
+
 # Description formatting is important, summary must be followed with a newline and 1 space.
 set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}
  Contains Memgraph, the graph database. It aims to deliver developers the
  speed, simplicity and scale required to build the next generation of
  applications driver by real-time connected data.")
+
 # Add `openssl` package to dependencies list. Used to generate SSL certificates.
 # 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")
 
 # Setting arhitecture extension for rpm packages
 set(MG_ARCH_EXTENSION_RPM "noarch")
-if (${MG_ARCH} STREQUAL "x86_64")
+
+if(${MG_ARCH} STREQUAL "x86_64")
     set(MG_ARCH_EXTENSION_RPM "x86_64")
-elseif (${MG_ARCH} STREQUAL "ARM64")
-    set(MG_ARCH_EXTENSION_RPM  "aarch64")
+elseif(${MG_ARCH} STREQUAL "ARM64")
+    set(MG_ARCH_EXTENSION_RPM "aarch64")
 endif()
 
 # RPM specific
@@ -56,18 +64,26 @@ set(CPACK_RPM_PACKAGE_URL https://memgraph.com)
 set(CPACK_RPM_PACKAGE_VERSION "${MEMGRAPH_VERSION_RPM}")
 set(CPACK_RPM_FILE_NAME "memgraph-${MEMGRAPH_VERSION_RPM}-1.${MG_ARCH_EXTENSION_RPM}.rpm")
 set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION
-  /var /var/lib /var/log /etc/logrotate.d
-  /lib /lib/systemd /lib/systemd/system /lib/systemd/system/memgraph.service)
+    /var /var/lib /var/log /etc/logrotate.d
+    /lib /lib/systemd /lib/systemd/system /lib/systemd/system/memgraph.service)
 set(CPACK_RPM_PACKAGE_REQUIRES_PRE "shadow-utils")
 set(CPACK_RPM_USER_BINARY_SPECFILE "${CMAKE_CURRENT_SOURCE_DIR}/rpm/memgraph.spec.in")
 set(CPACK_RPM_PACKAGE_LICENSE "Memgraph License")
+
 # Description formatting is important, no line must be greater than 80 characters.
 set(CPACK_RPM_PACKAGE_DESCRIPTION "Contains Memgraph, the graph database.
 It aims to deliver developers the speed, simplicity and scale required to build
 the next generation of applications driver by real-time connected data.")
+
 # Add `openssl` package to dependencies list. Used to generate SSL certificates.
 # We also depend on `python3` because we embed it in Memgraph.
-set(CPACK_RPM_PACKAGE_REQUIRES "openssl >= 1.0.0, curl >= 7.29.0, python3 >= 3.5.0, libstdc++ >= 6, logrotate")
+set(CPACK_RPM_PACKAGE_REQUIRES "openssl >= 1.0.0, curl >= 7.29.0, python3 >= 3.5.0, 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()
 
 # All variables must be set before including.
 include(CPack)

release/package/amzn-2/Dockerfile

@@ -0,0 +1,14 @@
+FROM amazonlinux:2
+
+ARG TOOLCHAIN_VERSION
+
+RUN yum -y update \
+    && yum install -y wget git tar
+# Do NOT be smart here and clean the cache because the container is used in the
+# stateful context.
+
+RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-amzn-2-x86_64.tar.gz \
+    -O ${TOOLCHAIN_VERSION}-binaries-amzn-2-x86_64.tar.gz \
+    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-amzn-2-x86_64.tar.gz -C /opt
+
+ENTRYPOINT ["sleep", "infinity"]

release/package/docker-compose.yml

@@ -32,3 +32,7 @@ services:
     build:
       context: fedora-36
     container_name: "mgbuild_fedora-36"
+  mgbuild_amzn-2:
+    build:
+      context: amzn-2
+    container_name: "mgbuild_amzn-2"

release/package/run.sh

@@ -3,7 +3,14 @@
 set -Eeuo pipefail
 
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-SUPPORTED_OS=(centos-7 centos-9 debian-10 debian-11 ubuntu-18.04 ubuntu-20.04 ubuntu-22.04 debian-11-arm fedora-36 ubuntu-22.04-arm)
+SUPPORTED_OS=(
+    centos-7 centos-9
+    debian-10 debian-11 debian-11-arm
+    ubuntu-18.04 ubuntu-20.04 ubuntu-22.04 ubuntu-22.04-arm
+    fedora-36
+    amzn-2
+)
+
 PROJECT_ROOT="$SCRIPT_DIR/../.."
 TOOLCHAIN_VERSION="toolchain-v4"
 ACTIVATE_TOOLCHAIN="source /opt/${TOOLCHAIN_VERSION}/activate"
@@ -23,7 +30,7 @@ make_package () {
     echo "Building Memgraph for $os on $build_container..."
 
     package_command=""
-    if [[ "$os" =~ ^"centos".* ]] || [[ "$os" =~ ^"fedora".* ]]; then
+    if [[ "$os" =~ ^"centos".* ]] || [[ "$os" =~ ^"fedora".* ]] || [[ "$os" =~ ^"amzn".* ]]; then
         docker exec "$build_container" bash -c "yum -y update"
         package_command=" cpack -G RPM --config ../CPackConfig.cmake && rpmlint --file='../../release/rpm/rpmlintrc' memgraph*.rpm "
     fi

src/CMakeLists.txt

@@ -1,7 +1,6 @@
 # CMake configuration for the main memgraph library and executable
 
 # add memgraph sub libraries, ordered by dependency
-add_subdirectory(lisp)
 add_subdirectory(utils)
 add_subdirectory(requests)
 add_subdirectory(io)
@@ -106,6 +105,10 @@ install(PROGRAMS $<TARGET_FILE:memgraph>
 # Install Python source for supporting our embedded Python.
 install(FILES ${CMAKE_SOURCE_DIR}/include/mgp.py
         DESTINATION lib/memgraph/python_support)
+install(FILES ${CMAKE_SOURCE_DIR}/include/mgp_mock.py
+        DESTINATION lib/memgraph/python_support)
+install(FILES ${CMAKE_SOURCE_DIR}/include/_mgp_mock.py
+        DESTINATION lib/memgraph/python_support)
 
 # Install the includes file for writing custom procedures in C and C++>
 install(FILES ${CMAKE_SOURCE_DIR}/include/mg_procedure.h

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

@@ -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
@@ -16,6 +16,7 @@
 #include "auth/crypto.hpp"
 #include "auth/exceptions.hpp"
 #include "license/license.hpp"
+#include "query/constants.hpp"
 #include "utils/cast.hpp"
 #include "utils/logging.hpp"
 #include "utils/settings.hpp"
@@ -34,13 +35,19 @@ namespace memgraph::auth {
 namespace {
 
 // Constant list of all available permissions.
-const std::vector<Permission> kPermissionsAll = {
-    Permission::MATCH,      Permission::CREATE,    Permission::MERGE,       Permission::DELETE,
-    Permission::SET,        Permission::REMOVE,    Permission::INDEX,       Permission::STATS,
-    Permission::CONSTRAINT, Permission::DUMP,      Permission::AUTH,        Permission::REPLICATION,
-    Permission::DURABILITY, Permission::READ_FILE, Permission::FREE_MEMORY, Permission::TRIGGER,
-    Permission::CONFIG,     Permission::STREAM,    Permission::MODULE_READ, Permission::MODULE_WRITE,
-    Permission::WEBSOCKET};
+const std::vector<Permission> kPermissionsAll = {Permission::MATCH,       Permission::CREATE,
+                                                 Permission::MERGE,       Permission::DELETE,
+                                                 Permission::SET,         Permission::REMOVE,
+                                                 Permission::INDEX,       Permission::STATS,
+                                                 Permission::CONSTRAINT,  Permission::DUMP,
+                                                 Permission::AUTH,        Permission::REPLICATION,
+                                                 Permission::DURABILITY,  Permission::READ_FILE,
+                                                 Permission::FREE_MEMORY, Permission::TRIGGER,
+                                                 Permission::CONFIG,      Permission::STREAM,
+                                                 Permission::MODULE_READ, Permission::MODULE_WRITE,
+                                                 Permission::WEBSOCKET,   Permission::TRANSACTION_MANAGEMENT,
+                                                 Permission::STORAGE_MODE};
+
 }  // namespace
 
 std::string PermissionToString(Permission permission) {
@@ -87,6 +94,10 @@ std::string PermissionToString(Permission permission) {
       return "MODULE_WRITE";
     case Permission::WEBSOCKET:
       return "WEBSOCKET";
+    case Permission::TRANSACTION_MANAGEMENT:
+      return "TRANSACTION_MANAGEMENT";
+    case Permission::STORAGE_MODE:
+      return "STORAGE_MODE";
   }
 }
 
@@ -264,7 +275,7 @@ PermissionLevel FineGrainedAccessPermissions::Has(const std::string &permission,
 
 void FineGrainedAccessPermissions::Grant(const std::string &permission,
                                          const FineGrainedPermission fine_grained_permission) {
-  if (permission == kAsterisk) {
+  if (permission == query::kAsterisk) {
     global_permission_ = CalculateGrant(fine_grained_permission);
   } else {
     permissions_[permission] = CalculateGrant(fine_grained_permission);
@@ -272,7 +283,7 @@ void FineGrainedAccessPermissions::Grant(const std::string &permission,
 }
 
 void FineGrainedAccessPermissions::Revoke(const std::string &permission) {
-  if (permission == kAsterisk) {
+  if (permission == query::kAsterisk) {
     permissions_.clear();
     global_permission_ = std::nullopt;
   } else {

src/auth/models.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
@@ -15,7 +15,6 @@
 #include <json/json.hpp>
 
 namespace memgraph::auth {
-const std::string kAsterisk = "*";
 // These permissions must have values that are applicable for usage in a
 // bitmask.
 // clang-format off
@@ -40,7 +39,9 @@ enum class Permission : uint64_t {
   STREAM       = 1U << 17U,
   MODULE_READ  = 1U << 18U,
   MODULE_WRITE = 1U << 19U,
-  WEBSOCKET    = 1U << 20U
+  WEBSOCKET    = 1U << 20U,
+  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/glue/auth.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
@@ -58,6 +58,10 @@ 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/auth_checker.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
@@ -15,6 +15,7 @@
 #include "auth/models.hpp"
 #include "glue/auth.hpp"
 #include "license/license.hpp"
+#include "query/constants.hpp"
 #include "query/frontend/ast/ast.hpp"
 #include "utils/synchronized.hpp"
 
@@ -38,7 +39,7 @@ bool IsUserAuthorizedGloballyLabels(const memgraph::auth::User &user,
   if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
     return true;
   }
-  return user.GetFineGrainedAccessLabelPermissions().Has(memgraph::auth::kAsterisk, fine_grained_permission) ==
+  return user.GetFineGrainedAccessLabelPermissions().Has(memgraph::query::kAsterisk, fine_grained_permission) ==
          memgraph::auth::PermissionLevel::GRANT;
 }
 
@@ -47,7 +48,7 @@ bool IsUserAuthorizedGloballyEdges(const memgraph::auth::User &user,
   if (!memgraph::license::global_license_checker.IsEnterpriseValidFast()) {
     return true;
   }
-  return user.GetFineGrainedAccessEdgeTypePermissions().Has(memgraph::auth::kAsterisk, fine_grained_permission) ==
+  return user.GetFineGrainedAccessEdgeTypePermissions().Has(memgraph::query::kAsterisk, fine_grained_permission) ==
          memgraph::auth::PermissionLevel::GRANT;
 }
 
@@ -84,6 +85,7 @@ bool AuthChecker::IsUserAuthorized(const std::optional<std::string> &username,
 
   return maybe_user.has_value() && IsUserAuthorized(*maybe_user, privileges);
 }
+
 #ifdef MG_ENTERPRISE
 std::unique_ptr<memgraph::query::FineGrainedAuthChecker> AuthChecker::GetFineGrainedAuthChecker(
     const std::string &username, const memgraph::query::DbAccessor *dba) const {

src/glue/auth_checker.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
@@ -26,9 +26,11 @@ class AuthChecker : public query::AuthChecker {
 
   bool IsUserAuthorized(const std::optional<std::string> &username,
                         const std::vector<query::AuthQuery::Privilege> &privileges) const override;
+
 #ifdef MG_ENTERPRISE
   std::unique_ptr<memgraph::query::FineGrainedAuthChecker> GetFineGrainedAuthChecker(
       const std::string &username, const memgraph::query::DbAccessor *dba) const override;
+
 #endif
   [[nodiscard]] static bool IsUserAuthorized(const memgraph::auth::User &user,
                                              const std::vector<memgraph::query::AuthQuery::Privilege> &privileges);

src/glue/auth_handler.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
@@ -18,6 +18,7 @@
 #include "auth/models.hpp"
 #include "glue/auth.hpp"
 #include "license/license.hpp"
+#include "query/constants.hpp"
 
 namespace {
 
@@ -253,19 +254,18 @@ bool AuthQueryHandler::CreateUser(const std::string &username, const std::option
 
     if (first_user) {
       spdlog::info("{} is first created user. Granting all privileges.", username);
-      GrantPrivilege(username, memgraph::query::kPrivilegesAll
+      GrantPrivilege(
+          username, memgraph::query::kPrivilegesAll
 #ifdef MG_ENTERPRISE
-                     ,
-                     {{{memgraph::query::AuthQuery::FineGrainedPrivilege::CREATE_DELETE, {memgraph::auth::kAsterisk}}}},
-                     {
-                       {
-                         {
-                           memgraph::query::AuthQuery::FineGrainedPrivilege::CREATE_DELETE, {
-                             memgraph::auth::kAsterisk
-                           }
-                         }
-                       }
-                     }
+          ,
+          {{{memgraph::query::AuthQuery::FineGrainedPrivilege::CREATE_DELETE, {memgraph::query::kAsterisk}}}},
+          {
+            {
+              {
+                memgraph::query::AuthQuery::FineGrainedPrivilege::CREATE_DELETE, { memgraph::query::kAsterisk }
+              }
+            }
+          }
 #endif
       );
     }

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->db) {}
+
+  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

@@ -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,11 +36,13 @@
 
 #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"
@@ -57,6 +59,7 @@
 #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"
@@ -103,42 +106,6 @@ 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 "
@@ -290,21 +277,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 +304,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 +364,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 +390,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;
 }
@@ -513,6 +500,10 @@ void InitFromCypherlFile(memgraph::query::InterpreterContext &ctx, std::string c
   }
 }
 
+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:
@@ -522,6 +513,7 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
       : 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),
 #if MG_ENTERPRISE
@@ -529,21 +521,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();
@@ -555,7 +567,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(
@@ -674,6 +686,7 @@ 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_;
   std::optional<memgraph::auth::User> user_;
@@ -686,6 +699,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.
@@ -880,7 +895,10 @@ 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},
+                     .restore_replicas_on_startup = true,
+                     .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()}};
   if (FLAGS_storage_snapshot_interval_sec == 0) {
     if (FLAGS_storage_wal_enabled) {
@@ -992,8 +1010,9 @@ int main(int argc, char **argv) {
     });
     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;
     });
@@ -1009,6 +1028,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
@@ -1018,14 +1074,22 @@ 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
@@ -1039,6 +1103,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/query/CMakeLists.txt

@@ -1,13 +1,7 @@
-define_add_lcp(add_lcp_query lcp_query_cpp_files generated_lcp_query_files)
-
-add_lcp_query(frontend/ast/ast.lcp)
-add_lcp_query(frontend/semantic/symbol.lcp)
-add_lcp_query(plan/operator.lcp)
-
-add_custom_target(generate_lcp_query DEPENDS ${generated_lcp_query_files})
-
 set(mg_query_sources
-    ${lcp_query_cpp_files}
+    frontend/ast/ast.cpp
+    frontend/semantic/symbol.cpp
+    plan/operator_type_info.cpp
     common.cpp
     cypher_query_interpreter.cpp
     dump.cpp
@@ -46,7 +40,6 @@ set(mg_query_sources
 find_package(Boost REQUIRED)
 
 add_library(mg-query STATIC ${mg_query_sources})
-add_dependencies(mg-query generate_lcp_query)
 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)

src/query/auth_checker.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

src/query/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
@@ -16,4 +16,6 @@
 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;
 }  // namespace memgraph::query

src/query/context.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,8 +22,19 @@
 #include "query/trigger.hpp"
 #include "utils/async_timer.hpp"
 
+#include "query/frame_change.hpp"
+
 namespace memgraph::query {
 
+enum class TransactionStatus {
+  IDLE,
+  ACTIVE,
+  VERIFYING,
+  TERMINATED,
+  STARTED_COMMITTING,
+  STARTED_ROLLBACK,
+};
+
 struct EvaluationContext {
   /// Memory for allocations during evaluation of a *single* Pull call.
   ///
@@ -66,12 +77,14 @@ struct ExecutionContext {
   SymbolTable symbol_table;
   EvaluationContext evaluation_context;
   std::atomic<bool> *is_shutting_down{nullptr};
+  std::atomic<TransactionStatus> *transaction_status{nullptr};
   bool is_profile_query{false};
   std::chrono::duration<double> profile_execution_time;
   plan::ProfilingStats stats;
   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};
@@ -82,7 +95,9 @@ static_assert(std::is_move_assignable_v<ExecutionContext>, "ExecutionContext mus
 static_assert(std::is_move_constructible_v<ExecutionContext>, "ExecutionContext must be move constructible!");
 
 inline bool MustAbort(const ExecutionContext &context) noexcept {
-  return (context.is_shutting_down != nullptr && context.is_shutting_down->load(std::memory_order_acquire)) ||
+  return (context.transaction_status != nullptr &&
+          context.transaction_status->load(std::memory_order_acquire) == TransactionStatus::TERMINATED) ||
+         (context.is_shutting_down != nullptr && context.is_shutting_down->load(std::memory_order_acquire)) ||
          context.timer.IsExpired();
 }
 

src/query/db_accessor.hpp

@@ -430,6 +430,25 @@ class DbAccessor final {
     return accessor_->LabelPropertyIndexExists(label, prop);
   }
 
+  std::optional<storage::IndexStats> 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>> DeleteIndexStatsForLabels(
+      const std::span<std::string> labels) {
+    return accessor_->DeleteIndexStatsForLabels(labels);
+  }
+
+  void SetIndexStats(const storage::LabelId &label, const storage::PropertyId &property,
+                     const storage::IndexStats &stats) {
+    accessor_->SetIndexStats(label, property, stats);
+  }
+
   int64_t VerticesCount() const { return accessor_->ApproximateVertexCount(); }
 
   int64_t VerticesCount(storage::LabelId label) const { return accessor_->ApproximateVertexCount(label); }

src/query/exceptions.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
@@ -120,9 +120,8 @@ class HintedAbortError : public utils::BasicException {
   using utils::BasicException::BasicException;
   HintedAbortError()
       : utils::BasicException(
-            "Transaction was asked to abort, most likely because it was "
-            "executing longer than time specified by "
-            "--query-execution-timeout-sec flag.") {}
+            "Transaction was asked to abort either because it was executing longer than time specified or another user "
+            "asked it to abort.") {}
 };
 
 class ExplicitTransactionUsageException : public QueryRuntimeException {
@@ -212,6 +211,21 @@ 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()
@@ -230,6 +244,12 @@ class VersionInfoInMulticommandTxException : public QueryException {
       : QueryException("Version info query not allowed in multicommand transactions.") {}
 };
 
+class AnalyzeGraphInMulticommandTxException : public QueryException {
+ public:
+  AnalyzeGraphInMulticommandTxException()
+      : QueryException("Analyze graph query not allowed in multicommand transactions.") {}
+};
+
 class ReplicationException : public utils::BasicException {
  public:
   using utils::BasicException::BasicException;
@@ -237,4 +257,11 @@ class ReplicationException : public utils::BasicException {
       : utils::BasicException("Replication Exception: {} Check the status of the replicas using 'SHOW REPLICA' query.",
                               message) {}
 };
+
+class TransactionQueueInMulticommandTxException : public QueryException {
+ public:
+  TransactionQueueInMulticommandTxException()
+      : QueryException("Transaction queue queries not allowed in multicommand transactions.") {}
+};
+
 }  // 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

@@ -0,0 +1,282 @@
+// 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/frontend/ast/ast.hpp"
+#include "query/frontend/ast/ast_visitor.hpp"
+#include "utils/typeinfo.hpp"
+
+namespace memgraph {
+
+constexpr utils::TypeInfo query::LabelIx::kType{utils::TypeId::AST_LABELIX, "LabelIx", nullptr};
+
+constexpr utils::TypeInfo query::PropertyIx::kType{utils::TypeId::AST_PROPERTYIX, "PropertyIx", nullptr};
+
+constexpr utils::TypeInfo query::EdgeTypeIx::kType{utils::TypeId::AST_EDGETYPEIX, "EdgeTypeIx", nullptr};
+
+constexpr utils::TypeInfo query::Tree::kType{utils::TypeId::AST_TREE, "Tree", nullptr};
+
+constexpr utils::TypeInfo query::Expression::kType{utils::TypeId::AST_EXPRESSION, "Expression", &query::Tree::kType};
+
+constexpr utils::TypeInfo query::Where::kType{utils::TypeId::AST_WHERE, "Where", &query::Tree::kType};
+
+constexpr utils::TypeInfo query::BinaryOperator::kType{utils::TypeId::AST_BINARY_OPERATOR, "BinaryOperator",
+                                                       &query::Expression::kType};
+
+constexpr utils::TypeInfo query::UnaryOperator::kType{utils::TypeId::AST_UNARY_OPERATOR, "UnaryOperator",
+                                                      &query::Expression::kType};
+
+constexpr utils::TypeInfo query::OrOperator::kType{utils::TypeId::AST_OR_OPERATOR, "OrOperator",
+                                                   &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::XorOperator::kType{utils::TypeId::AST_XOR_OPERATOR, "XorOperator",
+                                                    &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::AndOperator::kType{utils::TypeId::AST_AND_OPERATOR, "AndOperator",
+                                                    &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::AdditionOperator::kType{utils::TypeId::AST_ADDITION_OPERATOR, "AdditionOperator",
+                                                         &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::SubtractionOperator::kType{utils::TypeId::AST_SUBTRACTION_OPERATOR,
+                                                            "SubtractionOperator", &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::MultiplicationOperator::kType{utils::TypeId::AST_MULTIPLICATION_OPERATOR,
+                                                               "MultiplicationOperator", &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::DivisionOperator::kType{utils::TypeId::AST_DIVISION_OPERATOR, "DivisionOperator",
+                                                         &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::ModOperator::kType{utils::TypeId::AST_MOD_OPERATOR, "ModOperator",
+                                                    &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::NotEqualOperator::kType{utils::TypeId::AST_NOT_EQUAL_OPERATOR, "NotEqualOperator",
+                                                         &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::EqualOperator::kType{utils::TypeId::AST_EQUAL_OPERATOR, "EqualOperator",
+                                                      &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::LessOperator::kType{utils::TypeId::AST_LESS_OPERATOR, "LessOperator",
+                                                     &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::GreaterOperator::kType{utils::TypeId::AST_GREATER_OPERATOR, "GreaterOperator",
+                                                        &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::LessEqualOperator::kType{utils::TypeId::AST_LESS_EQUAL_OPERATOR, "LessEqualOperator",
+                                                          &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::GreaterEqualOperator::kType{utils::TypeId::AST_GREATER_EQUAL_OPERATOR,
+                                                             "GreaterEqualOperator", &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::InListOperator::kType{utils::TypeId::AST_IN_LIST_OPERATOR, "InListOperator",
+                                                       &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::SubscriptOperator::kType{utils::TypeId::AST_SUBSCRIPT_OPERATOR, "SubscriptOperator",
+                                                          &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::NotOperator::kType{utils::TypeId::AST_NOT_OPERATOR, "NotOperator",
+                                                    &query::UnaryOperator::kType};
+
+constexpr utils::TypeInfo query::UnaryPlusOperator::kType{utils::TypeId::AST_UNARY_PLUS_OPERATOR, "UnaryPlusOperator",
+                                                          &query::UnaryOperator::kType};
+
+constexpr utils::TypeInfo query::UnaryMinusOperator::kType{utils::TypeId::AST_UNARY_MINUS_OPERATOR,
+                                                           "UnaryMinusOperator", &query::UnaryOperator::kType};
+
+constexpr utils::TypeInfo query::IsNullOperator::kType{utils::TypeId::AST_IS_NULL_OPERATOR, "IsNullOperator",
+                                                       &query::UnaryOperator::kType};
+
+constexpr utils::TypeInfo query::Aggregation::kType{utils::TypeId::AST_AGGREGATION, "Aggregation",
+                                                    &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::ListSlicingOperator::kType{utils::TypeId::AST_LIST_SLICING_OPERATOR,
+                                                            "ListSlicingOperator", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::IfOperator::kType{utils::TypeId::AST_IF_OPERATOR, "IfOperator",
+                                                   &query::Expression::kType};
+
+constexpr utils::TypeInfo query::BaseLiteral::kType{utils::TypeId::AST_BASE_LITERAL, "BaseLiteral",
+                                                    &query::Expression::kType};
+
+constexpr utils::TypeInfo query::PrimitiveLiteral::kType{utils::TypeId::AST_PRIMITIVE_LITERAL, "PrimitiveLiteral",
+                                                         &query::BaseLiteral::kType};
+
+constexpr utils::TypeInfo query::ListLiteral::kType{utils::TypeId::AST_LIST_LITERAL, "ListLiteral",
+                                                    &query::BaseLiteral::kType};
+
+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};
+
+constexpr utils::TypeInfo query::Function::kType{utils::TypeId::AST_FUNCTION, "Function", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::Reduce::kType{utils::TypeId::AST_REDUCE, "Reduce", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::Coalesce::kType{utils::TypeId::AST_COALESCE, "Coalesce", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::Extract::kType{utils::TypeId::AST_EXTRACT, "Extract", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::All::kType{utils::TypeId::AST_ALL, "All", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::Single::kType{utils::TypeId::AST_SINGLE, "Single", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::Any::kType{utils::TypeId::AST_ANY, "Any", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::None::kType{utils::TypeId::AST_NONE, "None", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::ParameterLookup::kType{utils::TypeId::AST_PARAMETER_LOOKUP, "ParameterLookup",
+                                                        &query::Expression::kType};
+
+constexpr utils::TypeInfo query::RegexMatch::kType{utils::TypeId::AST_REGEX_MATCH, "RegexMatch",
+                                                   &query::Expression::kType};
+
+constexpr utils::TypeInfo query::NamedExpression::kType{utils::TypeId::AST_NAMED_EXPRESSION, "NamedExpression",
+                                                        &query::Tree::kType};
+
+constexpr utils::TypeInfo query::PatternAtom::kType{utils::TypeId::AST_PATTERN_ATOM, "PatternAtom",
+                                                    &query::Tree::kType};
+
+constexpr utils::TypeInfo query::NodeAtom::kType{utils::TypeId::AST_NODE_ATOM, "NodeAtom", &query::PatternAtom::kType};
+
+constexpr utils::TypeInfo query::EdgeAtom::Lambda::kType{utils::TypeId::AST_EDGE_ATOM_LAMBDA, "Lambda", nullptr};
+
+constexpr utils::TypeInfo query::EdgeAtom::kType{utils::TypeId::AST_EDGE_ATOM, "EdgeAtom", &query::PatternAtom::kType};
+
+constexpr utils::TypeInfo query::Pattern::kType{utils::TypeId::AST_PATTERN, "Pattern", &query::Tree::kType};
+
+constexpr utils::TypeInfo query::Clause::kType{utils::TypeId::AST_CLAUSE, "Clause", &query::Tree::kType};
+
+constexpr utils::TypeInfo query::SingleQuery::kType{utils::TypeId::AST_SINGLE_QUERY, "SingleQuery",
+                                                    &query::Tree::kType};
+
+constexpr utils::TypeInfo query::CypherUnion::kType{utils::TypeId::AST_CYPHER_UNION, "CypherUnion",
+                                                    &query::Tree::kType};
+
+constexpr utils::TypeInfo query::Query::kType{utils::TypeId::AST_QUERY, "Query", &query::Tree::kType};
+
+constexpr utils::TypeInfo query::CypherQuery::kType{utils::TypeId::AST_CYPHER_QUERY, "CypherQuery",
+                                                    &query::Query::kType};
+
+constexpr utils::TypeInfo query::ExplainQuery::kType{utils::TypeId::AST_EXPLAIN_QUERY, "ExplainQuery",
+                                                     &query::Query::kType};
+
+constexpr utils::TypeInfo query::ProfileQuery::kType{utils::TypeId::AST_PROFILE_QUERY, "ProfileQuery",
+                                                     &query::Query::kType};
+
+constexpr utils::TypeInfo query::IndexQuery::kType{utils::TypeId::AST_INDEX_QUERY, "IndexQuery", &query::Query::kType};
+
+constexpr utils::TypeInfo query::Create::kType{utils::TypeId::AST_CREATE, "Create", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::CallProcedure::kType{utils::TypeId::AST_CALL_PROCEDURE, "CallProcedure",
+                                                      &query::Clause::kType};
+
+constexpr utils::TypeInfo query::Match::kType{utils::TypeId::AST_MATCH, "Match", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::SortItem::kType{utils::TypeId::AST_SORT_ITEM, "SortItem", nullptr};
+
+constexpr utils::TypeInfo query::ReturnBody::kType{utils::TypeId::AST_RETURN_BODY, "ReturnBody", nullptr};
+
+constexpr utils::TypeInfo query::Return::kType{utils::TypeId::AST_RETURN, "Return", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::With::kType{utils::TypeId::AST_WITH, "With", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::Delete::kType{utils::TypeId::AST_DELETE, "Delete", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::SetProperty::kType{utils::TypeId::AST_SET_PROPERTY, "SetProperty",
+                                                    &query::Clause::kType};
+
+constexpr utils::TypeInfo query::SetProperties::kType{utils::TypeId::AST_SET_PROPERTIES, "SetProperties",
+                                                      &query::Clause::kType};
+
+constexpr utils::TypeInfo query::SetLabels::kType{utils::TypeId::AST_SET_LABELS, "SetLabels", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::RemoveProperty::kType{utils::TypeId::AST_REMOVE_PROPERTY, "RemoveProperty",
+                                                       &query::Clause::kType};
+
+constexpr utils::TypeInfo query::RemoveLabels::kType{utils::TypeId::AST_REMOVE_LABELS, "RemoveLabels",
+                                                     &query::Clause::kType};
+
+constexpr utils::TypeInfo query::Merge::kType{utils::TypeId::AST_MERGE, "Merge", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::Unwind::kType{utils::TypeId::AST_UNWIND, "Unwind", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::AuthQuery::kType{utils::TypeId::AST_AUTH_QUERY, "AuthQuery", &query::Query::kType};
+
+constexpr utils::TypeInfo query::InfoQuery::kType{utils::TypeId::AST_INFO_QUERY, "InfoQuery", &query::Query::kType};
+
+constexpr utils::TypeInfo query::Constraint::kType{utils::TypeId::AST_CONSTRAINT, "Constraint", nullptr};
+
+constexpr utils::TypeInfo query::ConstraintQuery::kType{utils::TypeId::AST_CONSTRAINT_QUERY, "ConstraintQuery",
+                                                        &query::Query::kType};
+
+constexpr utils::TypeInfo query::DumpQuery::kType{utils::TypeId::AST_DUMP_QUERY, "DumpQuery", &query::Query::kType};
+
+constexpr utils::TypeInfo query::ReplicationQuery::kType{utils::TypeId::AST_REPLICATION_QUERY, "ReplicationQuery",
+                                                         &query::Query::kType};
+
+constexpr utils::TypeInfo query::LockPathQuery::kType{utils::TypeId::AST_LOCK_PATH_QUERY, "LockPathQuery",
+                                                      &query::Query::kType};
+
+constexpr utils::TypeInfo query::LoadCsv::kType{utils::TypeId::AST_LOAD_CSV, "LoadCsv", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::FreeMemoryQuery::kType{utils::TypeId::AST_FREE_MEMORY_QUERY, "FreeMemoryQuery",
+                                                        &query::Query::kType};
+
+constexpr utils::TypeInfo query::TriggerQuery::kType{utils::TypeId::AST_TRIGGER_QUERY, "TriggerQuery",
+                                                     &query::Query::kType};
+
+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};
+
+constexpr utils::TypeInfo query::StreamQuery::kType{utils::TypeId::AST_STREAM_QUERY, "StreamQuery",
+                                                    &query::Query::kType};
+
+constexpr utils::TypeInfo query::SettingQuery::kType{utils::TypeId::AST_SETTING_QUERY, "SettingQuery",
+                                                     &query::Query::kType};
+
+constexpr utils::TypeInfo query::VersionQuery::kType{utils::TypeId::AST_VERSION_QUERY, "VersionQuery",
+                                                     &query::Query::kType};
+
+constexpr utils::TypeInfo query::Foreach::kType{utils::TypeId::AST_FOREACH, "Foreach", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::ShowConfigQuery::kType{utils::TypeId::AST_SHOW_CONFIG_QUERY, "ShowConfigQuery",
+                                                        &query::Query::kType};
+
+constexpr utils::TypeInfo query::AnalyzeGraphQuery::kType{utils::TypeId::AST_ANALYZE_GRAPH_QUERY, "AnalyzeGraphQuery",
+                                                          &query::Query::kType};
+
+constexpr utils::TypeInfo query::TransactionQueueQuery::kType{utils::TypeId::AST_TRANSACTION_QUEUE_QUERY,
+                                                              "TransactionQueueQuery", &query::Query::kType};
+
+constexpr utils::TypeInfo query::Exists::kType{utils::TypeId::AST_EXISTS, "Exists", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::CallSubquery::kType{utils::TypeId::AST_CALL_SUBQUERY, "CallSubquery",
+                                                     &query::Clause::kType};
+}  // namespace memgraph

src/query/frontend/ast/ast.lcp

@@ -1237,7 +1237,9 @@ cpp<#
    (token-position :int32_t :initval -1 :scope :public
                    :documentation "This field contains token position of first token in named expression used to create name_. If NamedExpression object is not created from query or it is aliased leave this value at -1.")
    (symbol-pos :int32_t :initval -1 :scope :public
-               :documentation "Symbol table position of the symbol this NamedExpression is mapped to."))
+               :documentation "Symbol table position of the symbol this NamedExpression is mapped to.")
+   (is-aliased :bool :initval "false" :scope :public
+               :documentation "True if the variable is aliased"))
   (:public
     #>cpp
     using utils::Visitable<ExpressionVisitor<TypedValue>>::Accept;
@@ -1620,7 +1622,7 @@ cpp<#
   (:clone :ignore-other-base-classes t)
   (:type-info :ignore-other-base-classes t))
 
-(lcp:define-class cypher-query (query)
+(lcp:define-class cypher-query (query "::utils::Visitable<HierarchicalTreeVisitor>")
   ((single-query "SingleQuery *" :initval "nullptr" :scope :public
                  :slk-save #'slk-save-ast-pointer
                  :slk-load (slk-load-ast-pointer "SingleQuery")
@@ -1639,13 +1641,25 @@ cpp<#
     CypherQuery() = default;
 
     DEFVISITABLE(QueryVisitor<void>);
+
+    bool Accept(HierarchicalTreeVisitor &visitor) override {
+      if (visitor.PreVisit(*this)) {
+        single_query_->Accept(visitor);
+        for (auto *cypher_union : cypher_unions_) {
+          cypher_union->Accept(visitor);
+        }
+      }
+
+      return visitor.PostVisit(*this);
+    }
     cpp<#)
   (:private
     #>cpp
     friend class AstStorage;
     cpp<#)
-  (:serialize (:slk))
-  (:clone))
+  (:serialize (:slk :ignore-other-base-classes t))
+  (:clone :ignore-other-base-classes t)
+  (:type-info :ignore-other-base-classes t))
 
 (lcp:define-class explain-query (query)
   ((cypher-query "CypherQuery *" :initval "nullptr" :scope :public
@@ -2284,7 +2298,7 @@ cpp<#
     (lcp:define-enum privilege
         (create delete match merge set remove index stats auth constraint
          dump replication durability read_file free_memory trigger config stream module_read module_write
-         websocket)
+         websocket transaction_management)
       (:serialize))
     (lcp:define-enum fine-grained-privilege
         (nothing read update create_delete)
@@ -2333,7 +2347,7 @@ 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::WEBSOCKET,   AuthQuery::Privilege::TRANSACTION_MANAGEMENT};
 cpp<#
 
 (lcp:define-class info-query (query)
@@ -2403,6 +2417,26 @@ cpp<#
   (:serialize (:slk))
   (:clone))
 
+(lcp:define-class analyze-graph-query (query)
+  ((action "Action" :scope :public)
+  (labels "std::vector<std::string>" :scope :public))
+
+  (:public
+    (lcp:define-enum action
+        (analyze delete)
+      (:serialize))
+    #>cpp
+    AnalyzeGraphQuery() = default;
+
+    DEFVISITABLE(QueryVisitor<void>);
+    cpp<#)
+  (:private
+    #>cpp
+    friend class AstStorage;
+    cpp<#)
+  (:serialize (:slk))
+  (:clone))
+
 (lcp:define-class replication-query (query)
   ((action "Action" :scope :public)
    (role "ReplicationRole" :scope :public)
@@ -2661,6 +2695,26 @@ cpp<#
   (:serialize (:slk))
   (:clone))
 
+(lcp:define-class transaction-queue-query (query)
+  ((action "Action" :scope :public)
+  (transaction_id_list "std::vector<Expression*>" :scope :public))
+
+  (:public
+    (lcp:define-enum action
+        (show-transactions terminate-transactions)
+      (:serialize))
+    #>cpp
+    TransactionQueueQuery() = default;
+
+    DEFVISITABLE(QueryVisitor<void>);
+    cpp<#)
+  (:private
+    #>cpp
+    friend class AstStorage;
+    cpp<#)
+  (:serialize (:slk))
+  (:clone))
+
 (lcp:define-class version-query (query) ()
   (:public
     #>cpp
@@ -2711,5 +2765,64 @@ cpp<#
   (:serialize (:slk))
   (:clone))
 
+(lcp:define-class exists (expression)
+  ((pattern "Pattern *" :initval "nullptr" :scope :public
+             :slk-save #'slk-save-ast-pointer
+             :slk-load (slk-load-ast-pointer "Pattern"))
+   (symbol-pos :int32_t :initval -1 :scope :public
+               :documentation "Symbol table position of the symbol this Aggregation is mapped to."))
+
+  (:public
+    #>cpp
+    Exists() = default;
+
+    DEFVISITABLE(ExpressionVisitor<TypedValue>);
+    DEFVISITABLE(ExpressionVisitor<TypedValue*>);
+    DEFVISITABLE(ExpressionVisitor<void>);
+    bool Accept(HierarchicalTreeVisitor &visitor) override {
+      if (visitor.PreVisit(*this)) {
+        pattern_->Accept(visitor);
+      }
+      return visitor.PostVisit(*this);
+    }
+    Exists *MapTo(const Symbol &symbol) {
+      symbol_pos_ = symbol.position();
+      return this;
+    }
+    cpp<#)
+  (:protected
+    #>cpp
+    Exists(Pattern * pattern) : pattern_(pattern) {}
+    cpp<#)
+  (:private
+    #>cpp
+    friend class AstStorage;
+    cpp<#)
+  (:serialize (:slk))
+  (:clone))
+
+(lcp:define-class call-subquery (clause)
+  ((cypher-query "CypherQuery *" :scope :public
+          :slk-save #'slk-save-ast-pointer
+          :slk-load (slk-load-ast-pointer "CypherQuery")))
+  (:public
+    #>cpp
+    CallSubquery() = default;
+
+    bool Accept(HierarchicalTreeVisitor &visitor) override {
+      if (visitor.PreVisit(*this)) {
+        cypher_query_->Accept(visitor);
+      }
+      return visitor.PostVisit(*this);
+    }
+
+    cpp<#)
+  (:private
+    #>cpp
+    friend class AstStorage;
+    cpp<#)
+  (:serialize (:slk))
+  (:clone))
+
 (lcp:pop-namespace) ;; namespace query
 (lcp:pop-namespace) ;; namespace memgraph

src/query/frontend/ast/ast_visitor.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,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,21 +91,27 @@ class LoadCsv;
 class FreeMemoryQuery;
 class TriggerQuery;
 class IsolationLevelQuery;
+class StorageModeQuery;
 class CreateSnapshotQuery;
 class StreamQuery;
 class SettingQuery;
 class VersionQuery;
 class Foreach;
 class ShowConfigQuery;
+class CallSubquery;
+class AnalyzeGraphQuery;
+class TransactionQueueQuery;
+class Exists;
 
 using TreeCompositeVisitor = utils::CompositeVisitor<
     SingleQuery, CypherUnion, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator, AdditionOperator,
     SubtractionOperator, MultiplicationOperator, DivisionOperator, ModOperator, NotEqualOperator, EqualOperator,
     LessOperator, GreaterOperator, LessEqualOperator, GreaterEqualOperator, InListOperator, SubscriptOperator,
     ListSlicingOperator, IfOperator, UnaryPlusOperator, UnaryMinusOperator, IsNullOperator, ListLiteral, MapLiteral,
-    PropertyLookup, LabelsTest, Aggregation, Function, Reduce, Coalesce, Extract, All, Single, Any, None, CallProcedure,
-    Create, Match, Return, With, Pattern, NodeAtom, EdgeAtom, Delete, Where, SetProperty, SetProperties, SetLabels,
-    RemoveProperty, RemoveLabels, Merge, Unwind, RegexMatch, LoadCsv, Foreach>;
+    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>;
 
@@ -117,18 +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> {};
+    : 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> {};
+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, StorageModeQuery, AnalyzeGraphQuery> {};
 
 }  // namespace memgraph::query

src/query/frontend/ast/cypher_main_visitor.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
@@ -11,8 +11,10 @@
 
 #include "query/frontend/ast/cypher_main_visitor.hpp"
 #include <support/Any.h>
+#include <tree/ParseTreeVisitor.h>
 
 #include <algorithm>
+#include <any>
 #include <climits>
 #include <codecvt>
 #include <cstring>
@@ -122,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());
   }
@@ -239,6 +244,23 @@ antlrcpp::Any CypherMainVisitor::visitDumpQuery(MemgraphCypher::DumpQueryContext
   return dump_query;
 }
 
+antlrcpp::Any CypherMainVisitor::visitAnalyzeGraphQuery(MemgraphCypher::AnalyzeGraphQueryContext *ctx) {
+  auto *analyze_graph_query = storage_->Create<AnalyzeGraphQuery>();
+  if (ctx->listOfColonSymbolicNames()) {
+    analyze_graph_query->labels_ =
+        std::any_cast<std::vector<std::string>>(ctx->listOfColonSymbolicNames()->accept(this));
+  } else {
+    analyze_graph_query->labels_.emplace_back("*");
+  }
+  if (ctx->DELETE()) {
+    analyze_graph_query->action_ = AnalyzeGraphQuery::Action::DELETE;
+  } else {
+    analyze_graph_query->action_ = AnalyzeGraphQuery::Action::ANALYZE;
+  }
+  query_ = analyze_graph_query;
+  return analyze_graph_query;
+}
+
 antlrcpp::Any CypherMainVisitor::visitReplicationQuery(MemgraphCypher::ReplicationQueryContext *ctx) {
   MG_ASSERT(ctx->children.size() == 1, "ReplicationQuery should have exactly one child!");
   auto *replication_query = std::any_cast<ReplicationQuery *>(ctx->children[0]->accept(this));
@@ -306,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;
@@ -468,6 +492,20 @@ 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;
+    }
+    return StorageModeQuery::StorageMode::IN_MEMORY_TRANSACTIONAL;
+  });
+
+  query_ = storage_mode_query;
+  return storage_mode_query;
+}
+
 antlrcpp::Any CypherMainVisitor::visitCreateSnapshotQuery(MemgraphCypher::CreateSnapshotQueryContext *ctx) {
   query_ = storage_->Create<CreateSnapshotQuery>();
   return query_;
@@ -631,6 +669,7 @@ void GetTopicNames(auto &destination, MemgraphCypher::TopicNamesContext *topic_n
     destination = std::any_cast<Expression *>(topic_names_ctx->accept(&visitor));
   }
 }
+
 }  // namespace
 
 antlrcpp::Any CypherMainVisitor::visitKafkaCreateStreamConfig(MemgraphCypher::KafkaCreateStreamConfigContext *ctx) {
@@ -883,6 +922,34 @@ antlrcpp::Any CypherMainVisitor::visitShowSettings(MemgraphCypher::ShowSettingsC
   return setting_query;
 }
 
+antlrcpp::Any CypherMainVisitor::visitTransactionQueueQuery(MemgraphCypher::TransactionQueueQueryContext *ctx) {
+  MG_ASSERT(ctx->children.size() == 1, "TransactionQueueQuery should have exactly one child!");
+  auto *transaction_queue_query = std::any_cast<TransactionQueueQuery *>(ctx->children[0]->accept(this));
+  query_ = transaction_queue_query;
+  return transaction_queue_query;
+}
+
+antlrcpp::Any CypherMainVisitor::visitShowTransactions(MemgraphCypher::ShowTransactionsContext * /*ctx*/) {
+  auto *transaction_shower = storage_->Create<TransactionQueueQuery>();
+  transaction_shower->action_ = TransactionQueueQuery::Action::SHOW_TRANSACTIONS;
+  return transaction_shower;
+}
+
+antlrcpp::Any CypherMainVisitor::visitTerminateTransactions(MemgraphCypher::TerminateTransactionsContext *ctx) {
+  auto *terminator = storage_->Create<TransactionQueueQuery>();
+  terminator->action_ = TransactionQueueQuery::Action::TERMINATE_TRANSACTIONS;
+  terminator->transaction_id_list_ = std::any_cast<std::vector<Expression *>>(ctx->transactionIdList()->accept(this));
+  return terminator;
+}
+
+antlrcpp::Any CypherMainVisitor::visitTransactionIdList(MemgraphCypher::TransactionIdListContext *ctx) {
+  std::vector<Expression *> transaction_ids;
+  for (auto *transaction_id : ctx->transactionId()) {
+    transaction_ids.push_back(std::any_cast<Expression *>(transaction_id->accept(this)));
+  }
+  return transaction_ids;
+}
+
 antlrcpp::Any CypherMainVisitor::visitVersionQuery(MemgraphCypher::VersionQueryContext * /*ctx*/) {
   auto *version_query = storage_->Create<VersionQuery>();
   query_ = version_query;
@@ -941,6 +1008,10 @@ antlrcpp::Any CypherMainVisitor::visitSingleQuery(MemgraphCypher::SingleQueryCon
         calls_write_procedure = true;
         has_update = true;
       }
+    } else if (const auto *call_subquery = utils::Downcast<CallSubquery>(clause); call_subquery != nullptr) {
+      if (has_return) {
+        throw SemanticException("CALL can't be put after RETURN clause.");
+      }
     } else if (utils::IsSubtype(clause_type, Unwind::kType)) {
       check_write_procedure("UNWIND");
       if (has_update || has_return) {
@@ -1053,6 +1124,9 @@ antlrcpp::Any CypherMainVisitor::visitClause(MemgraphCypher::ClauseContext *ctx)
   if (ctx->foreach ()) {
     return static_cast<Clause *>(std::any_cast<Foreach *>(ctx->foreach ()->accept(this)));
   }
+  if (ctx->callSubquery()) {
+    return static_cast<Clause *>(std::any_cast<CallSubquery *>(ctx->callSubquery()->accept(this)));
+  }
   // TODO: implement other clauses.
   throw utils::NotYetImplemented("clause '{}'", ctx->getText());
   return 0;
@@ -1410,19 +1484,23 @@ antlrcpp::Any CypherMainVisitor::visitEntityPrivilegeList(MemgraphCypher::Entity
   return result;
 }
 
+antlrcpp::Any CypherMainVisitor::visitListOfColonSymbolicNames(MemgraphCypher::ListOfColonSymbolicNamesContext *ctx) {
+  std::vector<std::string> symbolic_names;
+  for (auto *symbolic_name : ctx->colonSymbolicName()) {
+    symbolic_names.push_back(std::any_cast<std::string>(symbolic_name->symbolicName()->accept(this)));
+  }
+  return symbolic_names;
+}
+
 /**
  * @return std::vector<std::string>
  */
 antlrcpp::Any CypherMainVisitor::visitEntitiesList(MemgraphCypher::EntitiesListContext *ctx) {
   std::vector<std::string> entities;
-  if (ctx->listOfEntities()) {
-    for (auto *entity : ctx->listOfEntities()->entity()) {
-      entities.push_back(std::any_cast<std::string>(entity->symbolicName()->accept(this)));
-    }
-  } else {
-    entities.emplace_back("*");
+  if (ctx->listOfColonSymbolicNames()) {
+    return ctx->listOfColonSymbolicNames()->accept(this);
   }
-
+  entities.emplace_back("*");
   return entities;
 }
 
@@ -1451,6 +1529,8 @@ antlrcpp::Any CypherMainVisitor::visitPrivilege(MemgraphCypher::PrivilegeContext
   if (ctx->MODULE_READ()) return AuthQuery::Privilege::MODULE_READ;
   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!");
 }
 
@@ -1543,6 +1623,7 @@ antlrcpp::Any CypherMainVisitor::visitReturnItem(MemgraphCypher::ReturnItemConte
   named_expr->expression_ = std::any_cast<Expression *>(ctx->expression()->accept(this));
   MG_ASSERT(named_expr->expression_);
   if (ctx->variable()) {
+    named_expr->is_aliased_ = true;
     named_expr->name_ = std::string(std::any_cast<std::string>(ctx->variable()->accept(this)));
     users_identifiers.insert(named_expr->name_);
   } else {
@@ -1620,6 +1701,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()) {
@@ -2160,7 +2273,10 @@ antlrcpp::Any CypherMainVisitor::visitAtom(MemgraphCypher::AtomContext *ctx) {
     auto *list = std::any_cast<Expression *>(ctx->extractExpression()->idInColl()->expression()->accept(this));
     auto *expr = std::any_cast<Expression *>(ctx->extractExpression()->expression()->accept(this));
     return static_cast<Expression *>(storage_->Create<Extract>(ident, list, expr));
+  } else if (ctx->existsExpression()) {
+    return std::any_cast<Expression *>(ctx->existsExpression()->accept(this));
   }
+
   // TODO: Implement this. We don't support comprehensions, filtering... at
   // the moment.
   throw utils::NotYetImplemented("atom expression '{}'", ctx->getText());
@@ -2197,6 +2313,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))));
@@ -2204,6 +2324,17 @@ antlrcpp::Any CypherMainVisitor::visitLiteral(MemgraphCypher::LiteralContext *ct
   return visitChildren(ctx);
 }
 
+antlrcpp::Any CypherMainVisitor::visitExistsExpression(MemgraphCypher::ExistsExpressionContext *ctx) {
+  auto *exists = storage_->Create<Exists>();
+  exists->pattern_ = std::any_cast<Pattern *>(ctx->patternPart()->accept(this));
+
+  if (exists->pattern_->identifier_) {
+    throw SyntaxException("Identifiers are not supported in exists(...).");
+  }
+
+  return static_cast<Expression *>(exists);
+}
+
 antlrcpp::Any CypherMainVisitor::visitParenthesizedExpression(MemgraphCypher::ParenthesizedExpressionContext *ctx) {
   return std::any_cast<Expression *>(ctx->expression()->accept(this));
 }
@@ -2498,6 +2629,20 @@ antlrcpp::Any CypherMainVisitor::visitShowConfigQuery(MemgraphCypher::ShowConfig
   return query_;
 }
 
+antlrcpp::Any CypherMainVisitor::visitCallSubquery(MemgraphCypher::CallSubqueryContext *ctx) {
+  auto *call_subquery = storage_->Create<CallSubquery>();
+
+  MG_ASSERT(ctx->cypherQuery(), "Expected query inside subquery clause");
+
+  if (ctx->cypherQuery()->queryMemoryLimit()) {
+    throw SyntaxException("Memory limit cannot be set on subqueries!");
+  }
+
+  call_subquery->cypher_query_ = std::any_cast<CypherQuery *>(ctx->cypherQuery()->accept(this));
+
+  return call_subquery;
+}
+
 LabelIx CypherMainVisitor::AddLabel(const std::string &name) { return storage_->GetLabelIx(name); }
 
 PropertyIx CypherMainVisitor::AddProperty(const std::string &name) { return storage_->GetPropertyIx(name); }

src/query/frontend/ast/cypher_main_visitor.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
@@ -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"
@@ -183,6 +181,16 @@ class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
    */
   antlrcpp::Any visitDumpQuery(MemgraphCypher::DumpQueryContext *ctx) override;
 
+  /**
+  @return std::vector<std::string>
+  */
+  antlrcpp::Any visitListOfColonSymbolicNames(MemgraphCypher::ListOfColonSymbolicNamesContext *ctx) override;
+
+  /**
+   * @return AnalyzeGraphQuery*
+   */
+  antlrcpp::Any visitAnalyzeGraphQuery(MemgraphCypher::AnalyzeGraphQueryContext *ctx) override;
+
   /**
    * @return ReplicationQuery*
    */
@@ -253,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*
    */
@@ -358,6 +371,26 @@ class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
    */
   antlrcpp::Any visitShowSettings(MemgraphCypher::ShowSettingsContext *ctx) override;
 
+  /**
+   * @return TransactionQueueQuery*
+   */
+  antlrcpp::Any visitTransactionQueueQuery(MemgraphCypher::TransactionQueueQueryContext *ctx) override;
+
+  /**
+   * @return ShowTransactions*
+   */
+  antlrcpp::Any visitShowTransactions(MemgraphCypher::ShowTransactionsContext *ctx) override;
+
+  /**
+   * @return TerminateTransactions*
+   */
+  antlrcpp::Any visitTerminateTransactions(MemgraphCypher::TerminateTransactionsContext *ctx) override;
+
+  /**
+   * @return TransactionIdList*
+   */
+  antlrcpp::Any visitTransactionIdList(MemgraphCypher::TransactionIdListContext *ctx) override;
+
   /**
    * @return VersionQuery*
    */
@@ -573,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*>
    */
@@ -763,6 +801,11 @@ class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
    */
   antlrcpp::Any visitParameter(MemgraphCypher::ParameterContext *ctx) override;
 
+  /**
+   * @return Exists* (Expression)
+   */
+  antlrcpp::Any visitExistsExpression(MemgraphCypher::ExistsExpressionContext *ctx) override;
+
   /**
    * @return Expression*
    */
@@ -887,6 +930,11 @@ class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
    */
   antlrcpp::Any visitShowConfigQuery(MemgraphCypher::ShowConfigQueryContext *ctx) override;
 
+  /**
+   * @return CallSubquery*
+   */
+  antlrcpp::Any visitCallSubquery(MemgraphCypher::CallSubqueryContext *ctx) override;
+
  public:
   Query *query() { return query_; }
   const static std::string kAnonPrefix;

src/query/frontend/ast/pretty_print.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
@@ -54,12 +54,14 @@ 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;
   void Visit(Reduce &op) override;
   void Visit(Coalesce &op) override;
   void Visit(Extract &op) override;
+  void Visit(Exists &op) override;
   void Visit(All &op) override;
   void Visit(Single &op) override;
   void Visit(Any &op) override;
@@ -67,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;
@@ -88,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);
@@ -121,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) {
@@ -248,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_); }
@@ -264,6 +289,8 @@ void ExpressionPrettyPrinter::Visit(Extract &op) {
   PrintOperator(out_, "Extract", op.identifier_, op.list_, op.expression_);
 }
 
+void ExpressionPrettyPrinter::Visit(Exists & /*op*/) { PrintOperator(out_, "Exists", "expression"); }
+
 void ExpressionPrettyPrinter::Visit(All &op) {
   PrintOperator(out_, "All", op.identifier_, op.list_expression_, op.where_->expression_);
 }

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 ;
 
@@ -236,6 +238,7 @@ atom : literal
      | ( ANY '(' filterExpression ')' )
      | ( NONE '(' filterExpression ')' )
      | ( SINGLE '(' filterExpression ')' )
+     | ( EXISTS '(' existsExpression ')' )
      | relationshipsPattern
      | parenthesizedExpression
      | functionInvocation
@@ -247,6 +250,7 @@ literal : numberLiteral
         | booleanLiteral
         | CYPHERNULL
         | mapLiteral
+        | mapProjectionLiteral
         | listLiteral
         ;
 
@@ -275,6 +279,8 @@ reduceExpression : accumulator=variable '=' initial=expression ',' idInColl '|'
 
 extractExpression : idInColl '|' expression ;
 
+existsExpression : patternPart ;
+
 idInColl : variable IN expression ;
 
 functionInvocation : functionName '(' ( DISTINCT )? ( expression ( ',' expression )* )? ')' ;
@@ -287,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 ;
@@ -299,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

@@ -22,6 +22,7 @@ import Cypher ;
 memgraphCypherKeyword : cypherKeyword
                       | AFTER
                       | ALTER
+                      | ANALYZE
                       | ASYNC
                       | AUTH
                       | BAD
@@ -30,6 +31,7 @@ memgraphCypherKeyword : cypherKeyword
                       | BATCH_SIZE
                       | BEFORE
                       | BOOTSTRAP_SERVERS
+                      | BUILD
                       | CHECK
                       | CLEAR
                       | COMMIT
@@ -53,10 +55,13 @@ memgraphCypherKeyword : cypherKeyword
                       | FREE
                       | FROM
                       | GLOBAL
+                      | GRAPH
                       | GRANT
                       | HEADER
                       | IDENTIFIED
                       | ISOLATION
+                      | IN_MEMORY_ANALYTICAL
+                      | IN_MEMORY_TRANSACTIONAL
                       | KAFKA
                       | LABELS
                       | LEVEL
@@ -86,6 +91,8 @@ memgraphCypherKeyword : cypherKeyword
                       | SNAPSHOT
                       | START
                       | STATS
+                      | STATUS
+                      | STORAGE
                       | STREAM
                       | STREAMS
                       | SYNC
@@ -102,6 +109,8 @@ memgraphCypherKeyword : cypherKeyword
                       | USER
                       | USERS
                       | VERSION
+                      | TERMINATE
+                      | TRANSACTIONS
                       ;
 
 symbolicName : UnescapedSymbolicName
@@ -117,16 +126,19 @@ query : cypherQuery
       | constraintQuery
       | authQuery
       | dumpQuery
+      | analyzeGraphQuery
       | replicationQuery
       | lockPathQuery
       | freeMemoryQuery
       | triggerQuery
       | isolationLevelQuery
+      | storageModeQuery
       | createSnapshotQuery
       | streamQuery
       | settingQuery
       | versionQuery
       | showConfigQuery
+      | transactionQueueQuery
       ;
 
 authQuery : createRole
@@ -170,6 +182,7 @@ clause : cypherMatch
        | callProcedure
        | loadCsv
        | foreach
+       | callSubquery
        ;
 
 updateClause : set
@@ -182,6 +195,8 @@ updateClause : set
 
 foreach :  FOREACH '(' variable IN expression '|' updateClause+  ')' ;
 
+callSubquery : CALL '{' cypherQuery '}' ;
+
 streamQuery : checkStream
             | createStream
             | dropStream
@@ -197,6 +212,14 @@ settingQuery : setSetting
              | showSettings
              ;
 
+transactionQueueQuery : showTransactions
+                      | terminateTransactions
+                      ;
+
+showTransactions : SHOW TRANSACTIONS ;
+
+terminateTransactions : TERMINATE TRANSACTIONS transactionIdList;
+
 loadCsv : LOAD CSV FROM csvFile ( WITH | NO ) HEADER
          ( IGNORE BAD ) ?
          ( DELIMITER delimiter ) ?
@@ -259,6 +282,8 @@ privilege : CREATE
           | MODULE_READ
           | MODULE_WRITE
           | WEBSOCKET
+          | TRANSACTION_MANAGEMENT
+          | STORAGE_MODE
           ;
 
 granularPrivilege : NOTHING | READ | UPDATE | CREATE_DELETE ;
@@ -279,11 +304,11 @@ revokePrivilegesList : privilegeOrEntities ( ',' privilegeOrEntities )* ;
 
 privilegesList : privilege ( ',' privilege )* ;
 
-entitiesList : ASTERISK | listOfEntities ;
+entitiesList : ASTERISK | listOfColonSymbolicNames ;
 
-listOfEntities : entity ( ',' entity )* ;
+listOfColonSymbolicNames : colonSymbolicName ( ',' colonSymbolicName )* ;
 
-entity : COLON symbolicName ;
+colonSymbolicName : COLON symbolicName ;
 
 showPrivileges : SHOW PRIVILEGES FOR userOrRole=userOrRoleName ;
 
@@ -293,6 +318,8 @@ showUsersForRole : SHOW USERS FOR role=userOrRoleName ;
 
 dumpQuery: DUMP DATABASE ;
 
+analyzeGraphQuery: ANALYZE GRAPH ( ON LABELS ( listOfColonSymbolicNames | ASTERISK ) ) ? ( DELETE STATISTICS ) ? ;
+
 setReplicationRole  : SET REPLICATION ROLE TO ( MAIN | REPLICA )
                       ( WITH PORT port=literal ) ? ;
 
@@ -309,7 +336,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 ;
 
@@ -334,6 +361,10 @@ isolationLevelScope : GLOBAL | SESSION | NEXT ;
 
 isolationLevelQuery : SET isolationLevelScope TRANSACTION ISOLATION LEVEL isolationLevel ;
 
+storageMode : IN_MEMORY_ANALYTICAL | IN_MEMORY_TRANSACTIONAL ;
+
+storageModeQuery : STORAGE MODE storageMode ;
+
 createSnapshotQuery : CREATE SNAPSHOT ;
 
 streamName : symbolicName ;
@@ -402,3 +433,7 @@ showSettings : SHOW DATABASE SETTINGS ;
 showConfigQuery : SHOW CONFIG ;
 
 versionQuery : SHOW VERSION ;
+
+transactionIdList : transactionId ( ',' transactionId )* ;
+
+transactionId : literal ;

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

@@ -25,96 +25,109 @@ import CypherLexer ;
 
 UNDERSCORE : '_' ;
 
-AFTER               : A F T E R ;
-ALTER               : A L T E R ;
-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 ;
-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 ;
-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 ;
-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 ;
-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 ;
-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 ;
-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 ;
-EDGE_TYPES          : E D G E UNDERSCORE T Y P E S ;
+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 ;
+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

@@ -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
@@ -25,13 +25,15 @@ class PrivilegeExtractor : public QueryVisitor<void>, public HierarchicalTreeVis
 
   std::vector<AuthQuery::Privilege> privileges() { return privileges_; }
 
-  void Visit(IndexQuery &) override { AddPrivilege(AuthQuery::Privilege::INDEX); }
+  void Visit(IndexQuery & /*unused*/) override { AddPrivilege(AuthQuery::Privilege::INDEX); }
 
-  void Visit(AuthQuery &) override { AddPrivilege(AuthQuery::Privilege::AUTH); }
+  void Visit(AnalyzeGraphQuery & /*unused*/) override { AddPrivilege(AuthQuery::Privilege::INDEX); }
 
-  void Visit(ExplainQuery &query) override { query.cypher_query_->Accept(*this); }
+  void Visit(AuthQuery & /*unused*/) override { AddPrivilege(AuthQuery::Privilege::AUTH); }
 
-  void Visit(ProfileQuery &query) override { query.cypher_query_->Accept(*this); }
+  void Visit(ExplainQuery &query) override { query.cypher_query_->Accept(dynamic_cast<QueryVisitor &>(*this)); }
+
+  void Visit(ProfileQuery &query) override { query.cypher_query_->Accept(dynamic_cast<QueryVisitor &>(*this)); }
 
   void Visit(InfoQuery &info_query) override {
     switch (info_query.info_type_) {
@@ -41,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:
@@ -76,10 +79,14 @@ 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); }
 
+  void Visit(TransactionQueueQuery & /*transaction_queue_query*/) override {}
+
   void Visit(VersionQuery & /*version_query*/) override { AddPrivilege(AuthQuery::Privilege::STATS); }
 
   bool PreVisit(Create & /*unused*/) override {

src/query/frontend/semantic/symbol.cpp

@@ -0,0 +1,18 @@
+// 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/frontend/semantic/symbol.hpp"
+#include "utils/typeinfo.hpp"
+
+namespace memgraph {
+
+constexpr utils::TypeInfo query::Symbol::kType{utils::TypeId::SYMBOL, "Symbol", nullptr};
+}  // namespace memgraph

src/query/frontend/semantic/symbol.hpp

@@ -0,0 +1,75 @@
+// 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 <string>
+
+#include "utils/typeinfo.hpp"
+
+namespace memgraph {
+
+namespace query {
+
+class Symbol {
+ public:
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  enum class Type { ANY, VERTEX, EDGE, PATH, NUMBER, EDGE_LIST };
+
+  // TODO: Generate enum to string conversion from LCP. Note, that this is
+  // displayed to the end user, so we may want to have a pretty name of each
+  // value.
+  static std::string TypeToString(Type type) {
+    const char *enum_string[] = {"Any", "Vertex", "Edge", "Path", "Number", "EdgeList"};
+    return enum_string[static_cast<int>(type)];
+  }
+
+  Symbol() {}
+  Symbol(const std::string &name, int position, bool user_declared, Type type = Type::ANY, int token_position = -1)
+      : name_(name), position_(position), user_declared_(user_declared), type_(type), token_position_(token_position) {}
+
+  bool operator==(const Symbol &other) const {
+    return position_ == other.position_ && name_ == other.name_ && type_ == other.type_;
+  }
+  bool operator!=(const Symbol &other) const { return !operator==(other); }
+
+  // TODO: Remove these since members are public
+  const auto &name() const { return name_; }
+  int position() const { return position_; }
+  Type type() const { return type_; }
+  bool user_declared() const { return user_declared_; }
+  int token_position() const { return token_position_; }
+
+  std::string name_;
+  int64_t position_;
+  bool user_declared_{true};
+  memgraph::query::Symbol::Type type_{Type::ANY};
+  int64_t token_position_{-1};
+};
+
+}  // namespace query
+}  // namespace memgraph
+namespace std {
+
+template <>
+struct hash<memgraph::query::Symbol> {
+  size_t operator()(const memgraph::query::Symbol &symbol) const {
+    size_t prime = 265443599u;
+    size_t hash = std::hash<int>{}(symbol.position());
+    hash ^= prime * std::hash<std::string>{}(symbol.name());
+    hash ^= prime * std::hash<int>{}(static_cast<int>(symbol.type()));
+    return hash;
+  }
+};
+
+}  // namespace std

src/query/frontend/semantic/symbol_generator.cpp

@@ -64,6 +64,11 @@ auto SymbolGenerator::CreateSymbol(const std::string &name, bool user_declared,
   return symbol;
 }
 
+auto SymbolGenerator::CreateAnonymousSymbol(Symbol::Type /*type*/) {
+  auto symbol = symbol_table_->CreateAnonymousSymbol();
+  return symbol;
+}
+
 auto SymbolGenerator::GetOrCreateSymbol(const std::string &name, bool user_declared, Symbol::Type type) {
   // NOLINTNEXTLINE
   for (auto scope = scopes_.rbegin(); scope != scopes_.rend(); ++scope) {
@@ -206,6 +211,33 @@ bool SymbolGenerator::PostVisit(CallProcedure &call_proc) {
   return true;
 }
 
+bool SymbolGenerator::PreVisit(CallSubquery & /*call_sub*/) {
+  scopes_.emplace_back(Scope{.in_call_subquery = true});
+  return true;
+}
+
+bool SymbolGenerator::PostVisit(CallSubquery & /*call_sub*/) {
+  // no need to set the flag to true as we are popping the scope
+  auto subquery_scope = scopes_.back();
+  scopes_.pop_back();
+  auto &main_query_scope = scopes_.back();
+
+  if (!subquery_scope.has_return) {
+    return true;
+  }
+
+  // append symbols returned in from subquery to outer scope
+  for (const auto &[symbol_name, symbol] : subquery_scope.symbols) {
+    if (main_query_scope.symbols.find(symbol_name) != main_query_scope.symbols.end()) {
+      throw SemanticException("Variable in subquery already declared in outer scope!");
+    }
+
+    main_query_scope.symbols[symbol_name] = symbol;
+  }
+
+  return true;
+}
+
 bool SymbolGenerator::PreVisit(LoadCsv &load_csv) { return false; }
 
 bool SymbolGenerator::PostVisit(LoadCsv &load_csv) {
@@ -219,6 +251,8 @@ bool SymbolGenerator::PostVisit(LoadCsv &load_csv) {
 bool SymbolGenerator::PreVisit(Return &ret) {
   auto &scope = scopes_.back();
   scope.in_return = true;
+  scope.has_return = true;
+
   VisitReturnBody(ret.body_);
   scope.in_return = false;
   return false;  // We handled the traversal ourselves.
@@ -302,6 +336,14 @@ SymbolGenerator::ReturnType SymbolGenerator::Visit(Identifier &ident) {
   if (scope.in_skip || scope.in_limit) {
     throw SemanticException("Variables are not allowed in {}.", scope.in_skip ? "SKIP" : "LIMIT");
   }
+
+  if (scope.in_exists && (scope.visiting_edge || scope.in_node_atom)) {
+    auto has_symbol = HasSymbol(ident.name_);
+    if (!has_symbol && !ConsumePredefinedIdentifier(ident.name_) && ident.user_declared_) {
+      throw SemanticException("Unbounded variables are not allowed in exists!");
+    }
+  }
+
   Symbol symbol;
   if (scope.in_pattern && !(scope.in_node_atom || scope.visiting_edge)) {
     // If we are in the pattern, and outside of a node or an edge, the
@@ -328,7 +370,8 @@ SymbolGenerator::ReturnType SymbolGenerator::Visit(Identifier &ident) {
     }
     symbol = GetOrCreateSymbol(ident.name_, ident.user_declared_, type);
   } else if (scope.in_pattern && !scope.in_pattern_atom_identifier && scope.in_match) {
-    if (scope.in_edge_range && scope.visiting_edge->identifier_->name_ == ident.name_) {
+    if (scope.in_edge_range && scope.visiting_edge && scope.visiting_edge->identifier_ &&
+        scope.visiting_edge->identifier_->name_ == ident.name_) {
       // Prevent variable path bounds to reference the identifier which is bound
       // by the variable path itself.
       throw UnboundVariableError(ident.name_);
@@ -430,6 +473,55 @@ bool SymbolGenerator::PreVisit(Extract &extract) {
   return false;
 }
 
+bool SymbolGenerator::PreVisit(Exists &exists) {
+  auto &scope = scopes_.back();
+
+  if (scope.in_set_property) {
+    throw utils::NotYetImplemented("Set property can not be used with exists, but only during matching!");
+  }
+
+  if (scope.in_with) {
+    throw utils::NotYetImplemented("WITH can not be used with exists, but only during matching!");
+  }
+
+  scope.in_exists = true;
+
+  const auto &symbol = CreateAnonymousSymbol();
+  exists.MapTo(symbol);
+
+  return true;
+}
+
+bool SymbolGenerator::PostVisit(Exists & /*exists*/) {
+  auto &scope = scopes_.back();
+  scope.in_exists = false;
+
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(NamedExpression &named_expression) {
+  if (auto &scope = scopes_.back(); scope.in_call_subquery && scope.in_return &&
+                                    !utils::Downcast<Identifier>(named_expression.expression_) &&
+                                    !named_expression.is_aliased_) {
+    throw SemanticException("Expression returned from subquery must be aliased (use AS)!");
+  }
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(SetProperty & /*set_property*/) {
+  auto &scope = scopes_.back();
+  scope.in_set_property = true;
+
+  return true;
+}
+
+bool SymbolGenerator::PostVisit(SetProperty & /*set_property*/) {
+  auto &scope = scopes_.back();
+  scope.in_set_property = false;
+
+  return true;
+}
+
 // Pattern and its subparts.
 
 bool SymbolGenerator::PreVisit(Pattern &pattern) {
@@ -439,6 +531,7 @@ bool SymbolGenerator::PreVisit(Pattern &pattern) {
     MG_ASSERT(utils::IsSubtype(*pattern.atoms_[0], NodeAtom::kType), "Expected a single NodeAtom in Pattern");
     scope.in_create_node = true;
   }
+
   return true;
 }
 

src/query/frontend/semantic/symbol_generator.hpp

@@ -50,6 +50,8 @@ class SymbolGenerator : public HierarchicalTreeVisitor {
   bool PostVisit(Create &) override;
   bool PreVisit(CallProcedure &) override;
   bool PostVisit(CallProcedure &) override;
+  bool PreVisit(CallSubquery & /*unused*/) override;
+  bool PostVisit(CallSubquery & /*unused*/) override;
   bool PreVisit(LoadCsv &) override;
   bool PostVisit(LoadCsv &) override;
   bool PreVisit(Return &) override;
@@ -64,6 +66,8 @@ class SymbolGenerator : public HierarchicalTreeVisitor {
   bool PostVisit(Match &) override;
   bool PreVisit(Foreach &) override;
   bool PostVisit(Foreach &) override;
+  bool PreVisit(SetProperty & /*set_property*/) override;
+  bool PostVisit(SetProperty & /*set_property*/) override;
 
   // Expressions
   ReturnType Visit(Identifier &) override;
@@ -79,6 +83,9 @@ class SymbolGenerator : public HierarchicalTreeVisitor {
   bool PreVisit(None &) override;
   bool PreVisit(Reduce &) override;
   bool PreVisit(Extract &) override;
+  bool PreVisit(Exists & /*exists*/) override;
+  bool PostVisit(Exists & /*exists*/) override;
+  bool PreVisit(NamedExpression & /*unused*/) override;
 
   // Pattern and its subparts.
   bool PreVisit(Pattern &) override;
@@ -113,6 +120,10 @@ class SymbolGenerator : public HierarchicalTreeVisitor {
     bool in_where{false};
     bool in_match{false};
     bool in_foreach{false};
+    bool in_exists{false};
+    bool in_set_property{false};
+    bool in_call_subquery{false};
+    bool has_return{false};
     // True when visiting a pattern atom (node or edge) identifier, which can be
     // reused or created in the pattern itself.
     bool in_pattern_atom_identifier{false};
@@ -143,6 +154,9 @@ class SymbolGenerator : public HierarchicalTreeVisitor {
   auto CreateSymbol(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY,
                     int token_position = -1);
 
+  // Returns a freshly generated anonymous symbol.
+  auto CreateAnonymousSymbol(Symbol::Type type = Symbol::Type::ANY);
+
   auto GetOrCreateSymbol(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY);
   // Returns the symbol by name. If the mapping already exists, checks if the
   // types match. Otherwise, returns a new symbol.

src/query/frontend/semantic/symbol_table.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
@@ -51,6 +51,7 @@ class SymbolTable final {
   const Symbol &at(const Identifier &ident) const { return table_.at(ident.symbol_pos_); }
   const Symbol &at(const NamedExpression &nexpr) const { return table_.at(nexpr.symbol_pos_); }
   const Symbol &at(const Aggregation &aggr) const { return table_.at(aggr.symbol_pos_); }
+  const Symbol &at(const Exists &exists) const { return table_.at(exists.symbol_pos_); }
 
   // TODO: Remove these since members are public
   int32_t max_position() const { return static_cast<int32_t>(table_.size()); }

src/query/frontend/stripped_lexer_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
@@ -145,6 +145,7 @@ const trie::Trie kKeywords = {"union",
                               "drop",
                               "show",
                               "stats",
+                              "status",
                               "unique",
                               "explain",
                               "profile",
@@ -208,7 +209,15 @@ const trie::Trie kKeywords = {"union",
                               "websocket",
                               "foreach",
                               "labels",
-                              "edge_types"};
+                              "edge_types",
+                              "off",
+                              "in_memory_transactional",
+                              "in_memory_analytical",
+                              "data",
+                              "directory",
+                              "lock",
+                              "unlock"
+                              "build"};
 
 // Unicode codepoints that are allowed at the start of the unescaped name.
 const std::bitset<kBitsetSize> kUnescapedNameAllowedStarts(

src/query/interpret/eval.hpp

@@ -13,10 +13,12 @@
 #pragma once
 
 #include <algorithm>
+#include <cstddef>
 #include <limits>
 #include <map>
 #include <optional>
 #include <regex>
+#include <string>
 #include <vector>
 
 #include "query/common.hpp"
@@ -27,7 +29,11 @@
 #include "query/frontend/semantic/symbol_table.hpp"
 #include "query/interpret/frame.hpp"
 #include "query/typed_value.hpp"
+#include "spdlog/spdlog.h"
 #include "utils/exceptions.hpp"
+#include "utils/frame_change_id.hpp"
+#include "utils/logging.hpp"
+#include "utils/pmr/unordered_map.hpp"
 
 namespace memgraph::query {
 
@@ -73,11 +79,13 @@ class ReferenceExpressionEvaluator : public ExpressionVisitor<TypedValue *> {
   UNSUCCESSFUL_VISIT(ListSlicingOperator);
   UNSUCCESSFUL_VISIT(IsNullOperator);
   UNSUCCESSFUL_VISIT(PropertyLookup);
+  UNSUCCESSFUL_VISIT(AllPropertiesLookup);
   UNSUCCESSFUL_VISIT(LabelsTest);
 
   UNSUCCESSFUL_VISIT(PrimitiveLiteral);
   UNSUCCESSFUL_VISIT(ListLiteral);
   UNSUCCESSFUL_VISIT(MapLiteral);
+  UNSUCCESSFUL_VISIT(MapProjectionLiteral);
   UNSUCCESSFUL_VISIT(Aggregation);
   UNSUCCESSFUL_VISIT(Coalesce);
   UNSUCCESSFUL_VISIT(Function);
@@ -89,6 +97,7 @@ class ReferenceExpressionEvaluator : public ExpressionVisitor<TypedValue *> {
   UNSUCCESSFUL_VISIT(None);
   UNSUCCESSFUL_VISIT(ParameterLookup);
   UNSUCCESSFUL_VISIT(RegexMatch);
+  UNSUCCESSFUL_VISIT(Exists);
 
  private:
   Frame *frame_;
@@ -99,8 +108,13 @@ class ReferenceExpressionEvaluator : public ExpressionVisitor<TypedValue *> {
 class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
  public:
   ExpressionEvaluator(Frame *frame, const SymbolTable &symbol_table, const EvaluationContext &ctx, DbAccessor *dba,
-                      storage::View view)
-      : frame_(frame), symbol_table_(&symbol_table), ctx_(&ctx), dba_(dba), view_(view) {}
+                      storage::View view, FrameChangeCollector *frame_change_collector = nullptr)
+      : frame_(frame),
+        symbol_table_(&symbol_table),
+        ctx_(&ctx),
+        dba_(dba),
+        view_(view),
+        frame_change_collector_(frame_change_collector) {}
 
   using ExpressionVisitor<TypedValue>::Visit;
 
@@ -189,25 +203,78 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
   }
 
   TypedValue Visit(InListOperator &in_list) override {
+    TypedValue *_list_ptr = nullptr;
+    TypedValue _list;
     auto literal = in_list.expression1_->Accept(*this);
-    auto _list = in_list.expression2_->Accept(*this);
-    if (_list.IsNull()) {
-      return TypedValue(ctx_->memory);
+
+    auto get_list_literal = [this, &in_list, &_list, &_list_ptr]() -> void {
+      ReferenceExpressionEvaluator reference_expression_evaluator{frame_, symbol_table_, ctx_};
+      _list_ptr = in_list.expression2_->Accept(reference_expression_evaluator);
+      if (nullptr == _list_ptr) {
+        _list = in_list.expression2_->Accept(*this);
+        _list_ptr = &_list;
+      }
+    };
+
+    auto do_list_literal_checks = [this, &literal, &_list_ptr]() -> std::optional<TypedValue> {
+      MG_ASSERT(_list_ptr, "List literal should have been defined");
+      if (_list_ptr->IsNull()) {
+        return TypedValue(ctx_->memory);
+      }
+      // Exceptions have higher priority than returning nulls when list expression
+      // is not null.
+      if (_list_ptr->type() != TypedValue::Type::List) {
+        throw QueryRuntimeException("IN expected a list, got {}.", _list_ptr->type());
+      }
+      const auto &list = _list_ptr->ValueList();
+
+      // If literal is NULL there is no need to try to compare it with every
+      // element in the list since result of every comparison will be NULL. There
+      // is one special case that we must test explicitly: if list is empty then
+      // result is false since no comparison will be performed.
+      if (list.empty()) return TypedValue(false, ctx_->memory);
+      if (literal.IsNull()) return TypedValue(ctx_->memory);
+      return {};
+    };
+
+    const auto cached_id = memgraph::utils::GetFrameChangeId(in_list);
+
+    const auto do_cache{frame_change_collector_ != nullptr && cached_id &&
+                        frame_change_collector_->IsKeyTracked(*cached_id)};
+    if (do_cache) {
+      if (!frame_change_collector_->IsKeyValueCached(*cached_id)) {
+        // Check only first time if everything is okay, later when we use
+        // cache there is no need to check again as we did check first time
+        get_list_literal();
+        auto preoperational_checks = do_list_literal_checks();
+        if (preoperational_checks) {
+          return std::move(*preoperational_checks);
+        }
+        auto &cached_value = frame_change_collector_->GetCachedValue(*cached_id);
+        cached_value.CacheValue(*_list_ptr);
+        spdlog::trace("Value cached {}", *cached_id);
+      }
+      const auto &cached_value = frame_change_collector_->GetCachedValue(*cached_id);
+
+      if (cached_value.ContainsValue(literal)) {
+        return TypedValue(true, ctx_->memory);
+      }
+      // has null
+      if (cached_value.ContainsValue(TypedValue(ctx_->memory))) {
+        return TypedValue(ctx_->memory);
+      }
+      return TypedValue(false, ctx_->memory);
     }
-    // Exceptions have higher priority than returning nulls when list expression
-    // is not null.
-    if (_list.type() != TypedValue::Type::List) {
-      throw QueryRuntimeException("IN expected a list, got {}.", _list.type());
+    // When caching is not an option, we need to evaluate list literal every time
+    // and do the checks
+    get_list_literal();
+    auto preoperational_checks = do_list_literal_checks();
+    if (preoperational_checks) {
+      return std::move(*preoperational_checks);
     }
+
     const auto &list = _list.ValueList();
-
-    // If literal is NULL there is no need to try to compare it with every
-    // element in the list since result of every comparison will be NULL. There
-    // is one special case that we must test explicitly: if list is empty then
-    // result is false since no comparison will be performed.
-    if (list.empty()) return TypedValue(false, ctx_->memory);
-    if (literal.IsNull()) return TypedValue(ctx_->memory);
-
+    spdlog::trace("Not using cache on IN LIST operator");
     auto has_null = false;
     for (const auto &element : list) {
       auto result = literal == element;
@@ -465,7 +532,101 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         throw QueryRuntimeException("Invalid property name {} for Graph", prop_name);
       }
       default:
-        throw QueryRuntimeException("Only nodes, edges, maps and temporal types have properties to be looked-up.");
+        throw QueryRuntimeException(
+            "Only nodes, edges, maps, temporal types and graphs have properties to be looked up.");
+    }
+  }
+
+  TypedValue Visit(AllPropertiesLookup &all_properties_lookup) override {
+    TypedValue::TMap result(ctx_->memory);
+
+    auto expression_result = all_properties_lookup.expression_->Accept(*this);
+    switch (expression_result.type()) {
+      case TypedValue::Type::Null:
+        return TypedValue(ctx_->memory);
+      case TypedValue::Type::Vertex: {
+        for (const auto properties = *expression_result.ValueVertex().Properties(view_);
+             const auto &[property_id, value] : properties) {
+          result.emplace(dba_->PropertyToName(property_id), value);
+        }
+        return TypedValue(result, ctx_->memory);
+      }
+      case TypedValue::Type::Edge: {
+        for (const auto properties = *expression_result.ValueEdge().Properties(view_);
+             const auto &[property_id, value] : properties) {
+          result.emplace(dba_->PropertyToName(property_id), value);
+        }
+        return TypedValue(result, ctx_->memory);
+      }
+      case TypedValue::Type::Map: {
+        for (auto &[name, value] : expression_result.ValueMap()) {
+          result.emplace(name, value);
+        }
+        return TypedValue(result, ctx_->memory);
+      }
+      case TypedValue::Type::Duration: {
+        const auto &dur = expression_result.ValueDuration();
+        result.emplace("day", TypedValue(dur.Days(), ctx_->memory));
+        result.emplace("hour", TypedValue(dur.SubDaysAsHours(), ctx_->memory));
+        result.emplace("minute", TypedValue(dur.SubDaysAsMinutes(), ctx_->memory));
+        result.emplace("second", TypedValue(dur.SubDaysAsSeconds(), ctx_->memory));
+        result.emplace("millisecond", TypedValue(dur.SubDaysAsMilliseconds(), ctx_->memory));
+        result.emplace("microseconds", TypedValue(dur.SubDaysAsMicroseconds(), ctx_->memory));
+        result.emplace("nanoseconds", TypedValue(dur.SubDaysAsNanoseconds(), ctx_->memory));
+        return TypedValue(result, ctx_->memory);
+      }
+      case TypedValue::Type::Date: {
+        const auto &date = expression_result.ValueDate();
+        result.emplace("year", TypedValue(date.year, ctx_->memory));
+        result.emplace("month", TypedValue(date.month, ctx_->memory));
+        result.emplace("day", TypedValue(date.day, ctx_->memory));
+        return TypedValue(result, ctx_->memory);
+      }
+      case TypedValue::Type::LocalTime: {
+        const auto &lt = expression_result.ValueLocalTime();
+        result.emplace("hour", TypedValue(lt.hour, ctx_->memory));
+        result.emplace("minute", TypedValue(lt.minute, ctx_->memory));
+        result.emplace("second", TypedValue(lt.second, ctx_->memory));
+        result.emplace("millisecond", TypedValue(lt.millisecond, ctx_->memory));
+        result.emplace("microsecond", TypedValue(lt.microsecond, ctx_->memory));
+        return TypedValue(result, ctx_->memory);
+      }
+      case TypedValue::Type::LocalDateTime: {
+        const auto &ldt = expression_result.ValueLocalDateTime();
+        const auto &date = ldt.date;
+        const auto &lt = ldt.local_time;
+        result.emplace("year", TypedValue(date.year, ctx_->memory));
+        result.emplace("month", TypedValue(date.month, ctx_->memory));
+        result.emplace("day", TypedValue(date.day, ctx_->memory));
+        result.emplace("hour", TypedValue(lt.hour, ctx_->memory));
+        result.emplace("minute", TypedValue(lt.minute, ctx_->memory));
+        result.emplace("second", TypedValue(lt.second, ctx_->memory));
+        result.emplace("millisecond", TypedValue(lt.millisecond, ctx_->memory));
+        result.emplace("microsecond", TypedValue(lt.microsecond, ctx_->memory));
+        return TypedValue(result, ctx_->memory);
+      }
+      case TypedValue::Type::Graph: {
+        const auto &graph = expression_result.ValueGraph();
+
+        utils::pmr::vector<TypedValue> vertices(ctx_->memory);
+        vertices.reserve(graph.vertices().size());
+        for (const auto &v : graph.vertices()) {
+          vertices.emplace_back(TypedValue(v, ctx_->memory));
+        }
+        result.emplace("nodes", TypedValue(std::move(vertices), ctx_->memory));
+
+        utils::pmr::vector<TypedValue> edges(ctx_->memory);
+        edges.reserve(graph.edges().size());
+        for (const auto &e : graph.edges()) {
+          edges.emplace_back(TypedValue(e, ctx_->memory));
+        }
+        result.emplace("edges", TypedValue(std::move(edges), ctx_->memory));
+
+        return TypedValue(result, ctx_->memory);
+      }
+      default:
+        throw QueryRuntimeException(
+            "Only nodes, edges, maps, temporal types and graphs have properties to be looked up.");
     }
   }
 
@@ -530,6 +691,30 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     return TypedValue(result, ctx_->memory);
   }
 
+  TypedValue Visit(MapProjectionLiteral &literal) override {
+    constexpr std::string_view kAllPropertiesSelector{"*"};
+
+    TypedValue::TMap result(ctx_->memory);
+    TypedValue::TMap all_properties_lookup(ctx_->memory);
+    for (const auto &[property_key, property_value] : literal.elements_) {
+      if (property_key.name == kAllPropertiesSelector.data()) {
+        auto maybe_all_properties_lookup = property_value->Accept(*this);
+
+        if (maybe_all_properties_lookup.type() != TypedValue::Type::Map) {
+          throw QueryRuntimeException("Expected a map from AllPropertiesLookup, got {}.",
+                                      maybe_all_properties_lookup.type());
+        }
+        all_properties_lookup = std::move(maybe_all_properties_lookup.ValueMap());
+        continue;
+      }
+
+      result.emplace(property_key.name, property_value->Accept(*this));
+    }
+    if (!all_properties_lookup.empty()) result.merge(all_properties_lookup);
+
+    return TypedValue(result, ctx_->memory);
+  }
+
   TypedValue Visit(Aggregation &aggregation) override {
     return TypedValue(frame_->at(symbol_table_->at(aggregation)), ctx_->memory);
   }
@@ -619,6 +804,8 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     return TypedValue(result, ctx_->memory);
   }
 
+  TypedValue Visit(Exists &exists) override { return TypedValue{frame_->at(symbol_table_->at(exists)), ctx_->memory}; }
+
   TypedValue Visit(All &all) override {
     auto list_value = all.list_expression_->Accept(*this);
     if (list_value.IsNull()) {
@@ -849,7 +1036,8 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
   DbAccessor *dba_;
   // which switching approach should be used when evaluating
   storage::View view_;
-};
+  FrameChangeCollector *frame_change_collector_;
+};  // namespace memgraph::query
 
 /// A helper function for evaluating an expression that's an int.
 ///

src/query/interpreter.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
@@ -11,6 +11,8 @@
 
 #pragma once
 
+#include <unordered_set>
+
 #include <gflags/gflags.h>
 
 #include "query/auth_checker.hpp"
@@ -37,17 +39,19 @@
 #include "utils/settings.hpp"
 #include "utils/skip_list.hpp"
 #include "utils/spin_lock.hpp"
+#include "utils/synchronized.hpp"
 #include "utils/thread_pool.hpp"
 #include "utils/timer.hpp"
 #include "utils/tsc.hpp"
 
-namespace EventCounter {
+namespace memgraph::metrics {
 extern const Event FailedQuery;
-}  // namespace EventCounter
+}  // namespace memgraph::metrics
 
 namespace memgraph::query {
 
 inline constexpr size_t kExecutionMemoryBlockSize = 1UL * 1024UL * 1024UL;
+inline constexpr size_t kExecutionPoolMaxBlockSize = 1024UL;  // 2 ^ 10
 
 class AuthQueryHandler {
  public:
@@ -169,6 +173,24 @@ class ReplicationQueryHandler {
   virtual std::vector<Replica> ShowReplicas() const = 0;
 };
 
+class AnalyzeGraphQueryHandler {
+ public:
+  AnalyzeGraphQueryHandler() = default;
+  virtual ~AnalyzeGraphQueryHandler() = default;
+
+  AnalyzeGraphQueryHandler(const AnalyzeGraphQueryHandler &) = default;
+  AnalyzeGraphQueryHandler &operator=(const AnalyzeGraphQueryHandler &) = default;
+
+  AnalyzeGraphQueryHandler(AnalyzeGraphQueryHandler &&) = default;
+  AnalyzeGraphQueryHandler &operator=(AnalyzeGraphQueryHandler &&) = default;
+
+  static std::vector<std::vector<TypedValue>> AnalyzeGraphCreateStatistics(const std::span<std::string> labels,
+                                                                           DbAccessor *execution_db_accessor);
+
+  static std::vector<std::vector<TypedValue>> AnalyzeGraphDeleteStatistics(const std::span<std::string> labels,
+                                                                           DbAccessor *execution_db_accessor);
+};
+
 /**
  * A container for data related to the preparation of a query.
  */
@@ -179,12 +201,12 @@ struct PreparedQuery {
   plan::ReadWriteTypeChecker::RWType rw_type;
 };
 
+class Interpreter;
+
 /**
  * Holds data shared between multiple `Interpreter` instances (which might be
  * running concurrently).
  *
- * Users should initialize the context but should not modify it after it has
- * been passed to an `Interpreter` instance.
  */
 struct InterpreterContext {
   explicit InterpreterContext(storage::Storage *db, InterpreterConfig config,
@@ -214,6 +236,7 @@ struct InterpreterContext {
   const InterpreterConfig config;
 
   query::stream::Streams streams;
+  utils::Synchronized<std::unordered_set<Interpreter *>, utils::SpinLock> interpreters;
 };
 
 /// Function that is used to tell all active interpreters that they should stop
@@ -235,6 +258,11 @@ class Interpreter final {
     std::optional<int> qid;
   };
 
+  std::optional<std::string> username_;
+  bool in_explicit_transaction_{false};
+  bool expect_rollback_{false};
+  std::optional<std::map<std::string, storage::PropertyValue>> metadata_{};  //!< User defined transaction metadata
+
   /**
    * Prepare a query for execution.
    *
@@ -244,7 +272,8 @@ class Interpreter final {
    * @throw query::QueryException
    */
   PrepareResult Prepare(const std::string &query, const std::map<std::string, storage::PropertyValue> &params,
-                        const std::string *username);
+                        const std::string *username,
+                        const std::map<std::string, storage::PropertyValue> &metadata = {});
 
   /**
    * Execute the last prepared query and stream *all* of the results into the
@@ -288,7 +317,12 @@ class Interpreter final {
   std::map<std::string, TypedValue> Pull(TStream *result_stream, std::optional<int> n = {},
                                          std::optional<int> qid = {});
 
-  void BeginTransaction();
+  void BeginTransaction(const std::map<std::string, storage::PropertyValue> &metadata = {});
+
+  /*
+  Returns transaction id or empty if the db_accessor is not initialized.
+  */
+  std::optional<uint64_t> GetTransactionId() const;
 
   void CommitTransaction();
 
@@ -297,21 +331,41 @@ class Interpreter final {
   void SetNextTransactionIsolationLevel(storage::IsolationLevel isolation_level);
   void SetSessionIsolationLevel(storage::IsolationLevel isolation_level);
 
+  std::vector<TypedValue> GetQueries();
+
   /**
    * Abort the current multicommand transaction.
    */
   void Abort();
 
+  std::atomic<TransactionStatus> transaction_status_{TransactionStatus::IDLE};
+
  private:
   struct QueryExecution {
     std::optional<PreparedQuery> prepared_query;
-    utils::MonotonicBufferResource execution_memory{kExecutionMemoryBlockSize};
-    utils::ResourceWithOutOfMemoryException execution_memory_with_exception{&execution_memory};
+    std::variant<utils::MonotonicBufferResource, utils::PoolResource> execution_memory;
+    utils::ResourceWithOutOfMemoryException execution_memory_with_exception;
 
     std::map<std::string, TypedValue> summary;
     std::vector<Notification> notifications;
 
-    explicit QueryExecution() = default;
+    explicit QueryExecution(utils::MonotonicBufferResource monotonic_memory)
+        : execution_memory(std::move(monotonic_memory)) {
+      std::visit(
+          [&](auto &memory_resource) {
+            execution_memory_with_exception = utils::ResourceWithOutOfMemoryException(&memory_resource);
+          },
+          execution_memory);
+    };
+
+    explicit QueryExecution(utils::PoolResource pool_resource) : execution_memory(std::move(pool_resource)) {
+      std::visit(
+          [&](auto &memory_resource) {
+            execution_memory_with_exception = utils::ResourceWithOutOfMemoryException(&memory_resource);
+          },
+          execution_memory);
+    };
+
     QueryExecution(const QueryExecution &) = delete;
     QueryExecution(QueryExecution &&) = default;
     QueryExecution &operator=(const QueryExecution &) = delete;
@@ -322,7 +376,7 @@ class Interpreter final {
       // destroy the prepared query which is using that instance
       // of execution memory.
       prepared_query.reset();
-      execution_memory.Release();
+      std::visit([](auto &memory_resource) { memory_resource.Release(); }, execution_memory);
     }
   };
 
@@ -338,6 +392,8 @@ class Interpreter final {
   // and deletion of a single query execution, i.e. when a query finishes,
   // we reset the corresponding unique_ptr.
   std::vector<std::unique_ptr<QueryExecution>> query_executions_;
+  // all queries that are run as part of the current transaction
+  utils::Synchronized<std::vector<std::string>, utils::SpinLock> transaction_queries_;
 
   InterpreterContext *interpreter_context_;
 
@@ -347,13 +403,13 @@ class Interpreter final {
   std::unique_ptr<storage::Storage::Accessor> db_accessor_;
   std::optional<DbAccessor> execution_db_accessor_;
   std::optional<TriggerContextCollector> trigger_context_collector_;
-  bool in_explicit_transaction_{false};
-  bool expect_rollback_{false};
+  std::optional<FrameChangeCollector> frame_change_collector_;
 
   std::optional<storage::IsolationLevel> interpreter_isolation_level;
   std::optional<storage::IsolationLevel> next_transaction_isolation_level;
 
-  PreparedQuery PrepareTransactionQuery(std::string_view query_upper);
+  PreparedQuery PrepareTransactionQuery(std::string_view query_upper,
+                                        const std::map<std::string, storage::PropertyValue> &metadata = {});
   void Commit();
   void AdvanceCommand();
   void AbortCommand(std::unique_ptr<QueryExecution> *query_execution);
@@ -365,12 +421,32 @@ class Interpreter final {
   }
 };
 
+class TransactionQueueQueryHandler {
+ public:
+  TransactionQueueQueryHandler() = default;
+  virtual ~TransactionQueueQueryHandler() = default;
+
+  TransactionQueueQueryHandler(const TransactionQueueQueryHandler &) = default;
+  TransactionQueueQueryHandler &operator=(const TransactionQueueQueryHandler &) = default;
+
+  TransactionQueueQueryHandler(TransactionQueueQueryHandler &&) = default;
+  TransactionQueueQueryHandler &operator=(TransactionQueueQueryHandler &&) = default;
+
+  static std::vector<std::vector<TypedValue>> ShowTransactions(const std::unordered_set<Interpreter *> &interpreters,
+                                                               const std::optional<std::string> &username,
+                                                               bool hasTransactionManagementPrivilege);
+
+  static std::vector<std::vector<TypedValue>> KillTransactions(
+      InterpreterContext *interpreter_context, const std::vector<std::string> &maybe_kill_transaction_ids,
+      const std::optional<std::string> &username, bool hasTransactionManagementPrivilege);
+};
+
 template <typename TStream>
 std::map<std::string, TypedValue> Interpreter::Pull(TStream *result_stream, std::optional<int> n,
                                                     std::optional<int> qid) {
   MG_ASSERT(in_explicit_transaction_ || !qid, "qid can be only used in explicit transaction!");
-  const int qid_value = qid ? *qid : static_cast<int>(query_executions_.size() - 1);
 
+  const int qid_value = qid ? *qid : static_cast<int>(query_executions_.size() - 1);
   if (qid_value < 0 || qid_value >= query_executions_.size()) {
     throw InvalidArgumentsException("qid", "Query with specified ID does not exist!");
   }
@@ -390,7 +466,9 @@ std::map<std::string, TypedValue> Interpreter::Pull(TStream *result_stream, std:
   try {
     // Wrap the (statically polymorphic) stream type into a common type which
     // the handler knows.
-    AnyStream stream{result_stream, &query_execution->execution_memory};
+    AnyStream stream{result_stream,
+                     std::visit([](auto &execution_memory) -> utils::MemoryResource * { return &execution_memory; },
+                                query_execution->execution_memory)};
     const auto maybe_res = query_execution->prepared_query->query_handler(&stream, n);
     // Stream is using execution memory of the query_execution which
     // can be deleted after its execution so the stream should be cleared
@@ -430,6 +508,7 @@ std::map<std::string, TypedValue> Interpreter::Pull(TStream *result_stream, std:
         // methods as we will delete summary contained in them which we need
         // after our query finished executing.
         query_executions_.clear();
+        transaction_queries_->clear();
       } else {
         // We can only clear this execution as some of the queries
         // in the transaction can be in unfinished state
@@ -440,7 +519,7 @@ std::map<std::string, TypedValue> Interpreter::Pull(TStream *result_stream, std:
     query_execution.reset(nullptr);
     throw;
   } catch (const utils::BasicException &) {
-    EventCounter::IncrementCounter(EventCounter::FailedQuery);
+    memgraph::metrics::IncrementCounter(memgraph::metrics::FailedQuery);
     AbortCommand(&query_execution);
     throw;
   }

src/query/plan/cost_estimator.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
@@ -62,6 +62,8 @@ class CostEstimator : public HierarchicalLogicalOperatorVisitor {
     static constexpr double kEdgeUniquenessFilter{1.5};
     static constexpr double kUnwind{1.3};
     static constexpr double kForeach{1.0};
+    static constexpr double kUnion{1.0};
+    static constexpr double kSubquery{1.0};
   };
 
   struct CardParam {
@@ -212,6 +214,31 @@ class CostEstimator : public HierarchicalLogicalOperatorVisitor {
     return true;
   }
 
+  bool PreVisit(Union &op) override {
+    double left_cost = EstimateCostOnBranch(&op.left_op_);
+    double right_cost = EstimateCostOnBranch(&op.right_op_);
+
+    // the number of hits in the previous operator should be the joined number of results of both parts of the union
+    cardinality_ *= (left_cost + right_cost);
+    IncrementCost(CostParam::kUnion);
+
+    return false;
+  }
+
+  bool PreVisit(Apply &op) override {
+    double input_cost = EstimateCostOnBranch(&op.input_);
+    double subquery_cost = EstimateCostOnBranch(&op.subquery_);
+
+    // if the query is a unit subquery, we don't want the cost to be zero but 1xN
+    input_cost = input_cost == 0 ? 1 : input_cost;
+    subquery_cost = subquery_cost == 0 ? 1 : subquery_cost;
+
+    cardinality_ *= input_cost * subquery_cost;
+    IncrementCost(CostParam::kSubquery);
+
+    return false;
+  }
+
   bool Visit(Once &) override { return true; }
 
   auto cost() const { return cost_; }
@@ -232,6 +259,12 @@ class CostEstimator : public HierarchicalLogicalOperatorVisitor {
 
   void IncrementCost(double param) { cost_ += param * cardinality_; }
 
+  double EstimateCostOnBranch(std::shared_ptr<LogicalOperator> *branch) {
+    CostEstimator<TDbAccessor> cost_estimator(db_accessor_, parameters);
+    (*branch)->Accept(cost_estimator);
+    return cost_estimator.cost();
+  }
+
   // converts an optional ScanAll range bound into a property value
   // if the bound is present and is a constant expression convertible to
   // a property value. otherwise returns nullopt

src/query/plan/operator.cpp

@@ -53,6 +53,7 @@
 #include "utils/likely.hpp"
 #include "utils/logging.hpp"
 #include "utils/memory.hpp"
+#include "utils/pmr/deque.hpp"
 #include "utils/pmr/list.hpp"
 #include "utils/pmr/unordered_map.hpp"
 #include "utils/pmr/unordered_set.hpp"
@@ -60,6 +61,7 @@
 #include "utils/readable_size.hpp"
 #include "utils/string.hpp"
 #include "utils/temporal.hpp"
+#include "utils/typeinfo.hpp"
 
 // macro for the default implementation of LogicalOperator::Accept
 // that accepts the visitor and visits it's input_ operator
@@ -80,7 +82,7 @@
     LOG_FATAL("Operator " #class_name " has no single input!");  \
   }
 
-namespace EventCounter {
+namespace memgraph::metrics {
 extern const Event OnceOperator;
 extern const Event CreateNodeOperator;
 extern const Event CreateExpandOperator;
@@ -116,7 +118,9 @@ extern const Event CartesianOperator;
 extern const Event CallProcedureOperator;
 extern const Event ForeachOperator;
 extern const Event EmptyResultOperator;
-}  // namespace EventCounter
+extern const Event EvaluatePatternFilterOperator;
+extern const Event ApplyOperator;
+}  // namespace memgraph::metrics
 
 namespace memgraph::query::plan {
 
@@ -167,7 +171,7 @@ bool Once::OnceCursor::Pull(Frame &, ExecutionContext &context) {
 }
 
 UniqueCursorPtr Once::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::OnceOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::OnceOperator);
 
   return MakeUniqueCursorPtr<OnceCursor>(mem);
 }
@@ -229,7 +233,7 @@ VertexAccessor &CreateLocalVertex(const NodeCreationInfo &node_info, Frame *fram
 ACCEPT_WITH_INPUT(CreateNode)
 
 UniqueCursorPtr CreateNode::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::CreateNodeOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::CreateNodeOperator);
 
   return MakeUniqueCursorPtr<CreateNodeCursor>(mem, *this, mem);
 }
@@ -279,7 +283,7 @@ CreateExpand::CreateExpand(const NodeCreationInfo &node_info, const EdgeCreation
 ACCEPT_WITH_INPUT(CreateExpand)
 
 UniqueCursorPtr CreateExpand::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::CreateNodeOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::CreateNodeOperator);
 
   return MakeUniqueCursorPtr<CreateExpandCursor>(mem, *this, mem);
 }
@@ -486,7 +490,7 @@ ScanAll::ScanAll(const std::shared_ptr<LogicalOperator> &input, Symbol output_sy
 ACCEPT_WITH_INPUT(ScanAll)
 
 UniqueCursorPtr ScanAll::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::ScanAllOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::ScanAllOperator);
 
   auto vertices = [this](Frame &, ExecutionContext &context) {
     auto *db = context.db_accessor;
@@ -509,7 +513,7 @@ ScanAllByLabel::ScanAllByLabel(const std::shared_ptr<LogicalOperator> &input, Sy
 ACCEPT_WITH_INPUT(ScanAllByLabel)
 
 UniqueCursorPtr ScanAllByLabel::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::ScanAllByLabelOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::ScanAllByLabelOperator);
 
   auto vertices = [this](Frame &, ExecutionContext &context) {
     auto *db = context.db_accessor;
@@ -539,7 +543,7 @@ ScanAllByLabelPropertyRange::ScanAllByLabelPropertyRange(const std::shared_ptr<L
 ACCEPT_WITH_INPUT(ScanAllByLabelPropertyRange)
 
 UniqueCursorPtr ScanAllByLabelPropertyRange::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::ScanAllByLabelPropertyRangeOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::ScanAllByLabelPropertyRangeOperator);
 
   auto vertices = [this](Frame &frame, ExecutionContext &context)
       -> std::optional<decltype(context.db_accessor->Vertices(view_, label_, property_, std::nullopt, std::nullopt))> {
@@ -599,7 +603,7 @@ ScanAllByLabelPropertyValue::ScanAllByLabelPropertyValue(const std::shared_ptr<L
 ACCEPT_WITH_INPUT(ScanAllByLabelPropertyValue)
 
 UniqueCursorPtr ScanAllByLabelPropertyValue::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::ScanAllByLabelPropertyValueOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::ScanAllByLabelPropertyValueOperator);
 
   auto vertices = [this](Frame &frame, ExecutionContext &context)
       -> std::optional<decltype(context.db_accessor->Vertices(view_, label_, property_, storage::PropertyValue()))> {
@@ -624,7 +628,7 @@ ScanAllByLabelProperty::ScanAllByLabelProperty(const std::shared_ptr<LogicalOper
 ACCEPT_WITH_INPUT(ScanAllByLabelProperty)
 
 UniqueCursorPtr ScanAllByLabelProperty::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::ScanAllByLabelPropertyOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::ScanAllByLabelPropertyOperator);
 
   auto vertices = [this](Frame &frame, ExecutionContext &context) {
     auto *db = context.db_accessor;
@@ -643,7 +647,7 @@ ScanAllById::ScanAllById(const std::shared_ptr<LogicalOperator> &input, Symbol o
 ACCEPT_WITH_INPUT(ScanAllById)
 
 UniqueCursorPtr ScanAllById::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::ScanAllByIdOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::ScanAllByIdOperator);
 
   auto vertices = [this](Frame &frame, ExecutionContext &context) -> std::optional<std::vector<VertexAccessor>> {
     auto *db = context.db_accessor;
@@ -698,7 +702,7 @@ Expand::Expand(const std::shared_ptr<LogicalOperator> &input, Symbol input_symbo
 ACCEPT_WITH_INPUT(Expand)
 
 UniqueCursorPtr Expand::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::ExpandOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::ExpandOperator);
 
   return MakeUniqueCursorPtr<ExpandCursor>(mem, *this, mem);
 }
@@ -1833,7 +1837,7 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
       : self_(self),
         input_cursor_(self_.input_->MakeCursor(mem)),
         visited_cost_(mem),
-        expanded_(mem),
+        total_cost_(mem),
         next_edges_(mem),
         traversal_stack_(mem),
         pq_(mem) {}
@@ -1843,6 +1847,9 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
 
     ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.db_accessor,
                                   storage::View::OLD);
+    auto create_state = [this](const VertexAccessor &vertex, int64_t depth) {
+      return std::make_pair(vertex, upper_bound_set_ ? depth : 0);
+    };
 
     // For the given (edge, direction, weight, depth) tuple checks if they
     // satisfy the "where" condition. if so, places them in the priority
@@ -1934,73 +1941,118 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
       }
     };
 
-    // Check if upper bound exists
-    upper_bound_ = self_.upper_bound_
-                       ? EvaluateInt(&evaluator, self_.upper_bound_, "Max depth in all shortest paths expansion")
-                       : std::numeric_limits<int64_t>::max();
+    std::optional<VertexAccessor> start_vertex;
+    auto *memory = context.evaluation_context.memory;
+
+    auto create_path = [this, &frame, &memory]() {
+      auto &current_level = traversal_stack_.back();
+      auto &edges_on_frame = frame[self_.common_.edge_symbol].ValueList();
+
+      // Clean out the current stack
+      if (current_level.empty()) {
+        if (!edges_on_frame.empty()) {
+          if (!self_.is_reverse_)
+            edges_on_frame.erase(edges_on_frame.end());
+          else
+            edges_on_frame.erase(edges_on_frame.begin());
+        }
+        traversal_stack_.pop_back();
+        return false;
+      }
+
+      auto [current_edge, current_edge_direction, current_weight] = current_level.back();
+      current_level.pop_back();
+
+      // Edges order depends on direction of expansion
+      if (!self_.is_reverse_)
+        edges_on_frame.emplace_back(current_edge);
+      else
+        edges_on_frame.emplace(edges_on_frame.begin(), current_edge);
+
+      auto next_vertex = current_edge_direction == EdgeAtom::Direction::IN ? current_edge.From() : current_edge.To();
+      frame[self_.total_weight_.value()] = current_weight;
+
+      if (next_edges_.find({next_vertex, traversal_stack_.size()}) != next_edges_.end()) {
+        auto next_vertex_edges = next_edges_[{next_vertex, traversal_stack_.size()}];
+        traversal_stack_.emplace_back(std::move(next_vertex_edges));
+      } else {
+        // Signal the end of iteration
+        utils::pmr::list<DirectedEdge> empty(memory);
+        traversal_stack_.emplace_back(std::move(empty));
+      }
+
+      if ((current_weight > visited_cost_.at(next_vertex)).ValueBool()) return false;
+
+      // Place destination node on the frame, handle existence flag
+      if (self_.common_.existing_node) {
+        const auto &node = frame[self_.common_.node_symbol];
+        ExpectType(self_.common_.node_symbol, node, TypedValue::Type::Vertex);
+        if (node.ValueVertex() != next_vertex) return false;
+      } else {
+        frame[self_.common_.node_symbol] = next_vertex;
+      }
+      return true;
+    };
+
+    auto create_DFS_traversal_tree = [this, &context, &memory, &create_state, &expand_from_vertex]() {
+      while (!pq_.empty()) {
+        if (MustAbort(context)) throw HintedAbortError();
+
+        const auto [current_weight, current_depth, current_vertex, directed_edge] = pq_.top();
+        pq_.pop();
+
+        const auto &[current_edge, direction, weight] = directed_edge;
+        auto current_state = create_state(current_vertex, current_depth);
+
+        auto position = total_cost_.find(current_state);
+        if (position != total_cost_.end()) {
+          if ((position->second < current_weight).ValueBool()) continue;
+        } else {
+          total_cost_.emplace(current_state, current_weight);
+          if (current_depth < upper_bound_) {
+            expand_from_vertex(current_vertex, current_weight, current_depth);
+          }
+        }
+
+        // Searching for a previous vertex in the expansion
+        auto prev_vertex = direction == EdgeAtom::Direction::IN ? current_edge.To() : current_edge.From();
+
+        // Update the parent
+        if (next_edges_.find({prev_vertex, current_depth - 1}) == next_edges_.end()) {
+          utils::pmr::list<DirectedEdge> empty(memory);
+          next_edges_[{prev_vertex, current_depth - 1}] = std::move(empty);
+        }
+        next_edges_.at({prev_vertex, current_depth - 1}).emplace_back(directed_edge);
+      }
+    };
+
+    // upper_bound_set is used when storing visited edges, because with an upper bound we also consider suboptimal paths
+    // if they are shorter in depth
+    if (self_.upper_bound_) {
+      upper_bound_ = EvaluateInt(&evaluator, self_.upper_bound_, "Max depth in all shortest path expansion");
+      upper_bound_set_ = true;
+    } else {
+      upper_bound_ = std::numeric_limits<int64_t>::max();
+      upper_bound_set_ = false;
+    }
 
     // Check if upper bound is valid
     if (upper_bound_ < 1) {
       throw QueryRuntimeException("Maximum depth in all shortest paths expansion must be at least 1.");
     }
 
-    std::optional<VertexAccessor> start_vertex;
-    auto *memory = context.evaluation_context.memory;
-
+    // On first Pull run, traversal stack and priority queue are empty, so we start a pulling stream
+    // and create a DFS traversal tree (main part of algorithm). Then we return the first path
+    // created from the DFS traversal tree (basically a DFS algorithm).
+    // On each subsequent Pull run, paths are created from the traversal stack and returned.
     while (true) {
       // Check if there is an external error.
       if (MustAbort(context)) throw HintedAbortError();
 
-      // If traversal stack if filled, the DFS traversal tree is created. Traverse the tree iteratively by
-      // preserving the traversal state on stack.
+      // The algorithm is run all at once by create_DFS_traversal_tree, after which we
+      // traverse the tree iteratively by preserving the traversal state on stack.
       while (!traversal_stack_.empty()) {
-        auto &current_level = traversal_stack_.back();
-        auto &edges_on_frame = frame[self_.common_.edge_symbol].ValueList();
-
-        // Clean out the current stack
-        if (current_level.empty()) {
-          if (!edges_on_frame.empty()) {
-            if (!self_.is_reverse_)
-              edges_on_frame.erase(edges_on_frame.end());
-            else
-              edges_on_frame.erase(edges_on_frame.begin());
-          }
-          traversal_stack_.pop_back();
-          continue;
-        }
-
-        auto [current_edge, current_edge_direction, current_weight] = current_level.back();
-        current_level.pop_back();
-
-        // Edges order depends on direction of expansion
-        if (!self_.is_reverse_)
-          edges_on_frame.emplace_back(current_edge);
-        else
-          edges_on_frame.emplace(edges_on_frame.begin(), current_edge);
-
-        auto next_vertex = current_edge_direction == EdgeAtom::Direction::IN ? current_edge.From() : current_edge.To();
-        frame[self_.total_weight_.value()] = current_weight;
-
-        if (next_edges_.find({next_vertex, traversal_stack_.size()}) != next_edges_.end()) {
-          auto next_vertex_edges = next_edges_[{next_vertex, traversal_stack_.size()}];
-          traversal_stack_.emplace_back(std::move(next_vertex_edges));
-        } else {
-          // Signal the end of iteration
-          utils::pmr::list<DirectedEdge> empty(memory);
-          traversal_stack_.emplace_back(std::move(empty));
-        }
-
-        if ((current_weight > visited_cost_.at(next_vertex)).ValueBool()) continue;
-
-        // Place destination node on the frame, handle existence flag
-        if (self_.common_.existing_node) {
-          const auto &node = frame[self_.common_.node_symbol];
-          ExpectType(self_.common_.node_symbol, node, TypedValue::Type::Vertex);
-          if (node.ValueVertex() != next_vertex) continue;
-        } else {
-          frame[self_.common_.node_symbol] = next_vertex;
-        }
-        return true;
+        if (create_path()) return true;
       }
 
       // If priority queue is empty start new pulling stream.
@@ -2021,9 +2073,9 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
 
         // Clear existing data structures.
         visited_cost_.clear();
-        expanded_.clear();
         next_edges_.clear();
         traversal_stack_.clear();
+        total_cost_.clear();
 
         expand_from_vertex(*start_vertex, TypedValue(), 0);
         visited_cost_.emplace(*start_vertex, 0);
@@ -2031,33 +2083,9 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
       }
 
       // Create a DFS traversal tree from the start node
-      while (!pq_.empty()) {
-        if (MustAbort(context)) throw HintedAbortError();
-
-        const auto [current_weight, current_depth, current_vertex, directed_edge] = pq_.top();
-        pq_.pop();
-
-        const auto &[current_edge, direction, weight] = directed_edge;
-        if (expanded_.contains(current_edge)) continue;
-        expanded_.emplace(current_edge);
-
-        // Expand only if what we've just expanded is less than max depth.
-        if (current_depth < upper_bound_) {
-          expand_from_vertex(current_vertex, current_weight, current_depth);
-        }
-
-        // Searching for a previous vertex in the expansion
-        auto prev_vertex = direction == EdgeAtom::Direction::IN ? current_edge.To() : current_edge.From();
-
-        // Update the parent
-        if (next_edges_.find({prev_vertex, current_depth - 1}) == next_edges_.end()) {
-          utils::pmr::list<DirectedEdge> empty(memory);
-          next_edges_[{prev_vertex, current_depth - 1}] = std::move(empty);
-        }
-
-        next_edges_.at({prev_vertex, current_depth - 1}).emplace_back(directed_edge);
-      }
+      create_DFS_traversal_tree();
 
+      // DFS traversal tree is create,
       if (start_vertex && next_edges_.find({*start_vertex, 0}) != next_edges_.end()) {
         auto start_vertex_edges = next_edges_[{*start_vertex, 0}];
         traversal_stack_.emplace_back(std::move(start_vertex_edges));
@@ -2070,9 +2098,9 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
   void Reset() override {
     input_cursor_->Reset();
     visited_cost_.clear();
-    expanded_.clear();
     next_edges_.clear();
     traversal_stack_.clear();
+    total_cost_.clear();
     ClearQueue();
   }
 
@@ -2082,6 +2110,7 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
 
   // Upper bound on the path length.
   int64_t upper_bound_{-1};
+  bool upper_bound_set_{false};
 
   struct AspStateHash {
     size_t operator()(const std::pair<VertexAccessor, int64_t> &key) const {
@@ -2093,8 +2122,8 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
   using NextEdgesState = std::pair<VertexAccessor, int64_t>;
   // Maps vertices to minimum weights they got in expansion.
   utils::pmr::unordered_map<VertexAccessor, TypedValue> visited_cost_;
-  // Marking the expanded edges to prevent multiple visits.
-  utils::pmr::unordered_set<EdgeAccessor> expanded_;
+  // Maps vertices to weights they got in expansion.
+  utils::pmr::unordered_map<NextEdgesState, TypedValue, AspStateHash> total_cost_;
   // Maps the vertex with the potential expansion edge.
   utils::pmr::unordered_map<NextEdgesState, utils::pmr::list<DirectedEdge>, AspStateHash> next_edges_;
   // Stack indicating the traversal level.
@@ -2143,7 +2172,7 @@ class ExpandAllShortestPathsCursor : public query::plan::Cursor {
 };
 
 UniqueCursorPtr ExpandVariable::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::ExpandVariableOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::ExpandVariableOperator);
 
   switch (type_) {
     case EdgeAtom::Type::BREADTH_FIRST:
@@ -2246,7 +2275,7 @@ class ConstructNamedPathCursor : public Cursor {
 ACCEPT_WITH_INPUT(ConstructNamedPath)
 
 UniqueCursorPtr ConstructNamedPath::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::ConstructNamedPathOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::ConstructNamedPathOperator);
 
   return MakeUniqueCursorPtr<ConstructNamedPathCursor>(mem, *this, mem);
 }
@@ -2257,21 +2286,46 @@ std::vector<Symbol> ConstructNamedPath::ModifiedSymbols(const SymbolTable &table
   return symbols;
 }
 
-Filter::Filter(const std::shared_ptr<LogicalOperator> &input, Expression *expression)
-    : input_(input ? input : std::make_shared<Once>()), expression_(expression) {}
+Filter::Filter(const std::shared_ptr<LogicalOperator> &input,
+               const std::vector<std::shared_ptr<LogicalOperator>> &pattern_filters, Expression *expression)
+    : input_(input ? input : std::make_shared<Once>()), pattern_filters_(pattern_filters), expression_(expression) {}
 
-ACCEPT_WITH_INPUT(Filter)
+bool Filter::Accept(HierarchicalLogicalOperatorVisitor &visitor) {
+  if (visitor.PreVisit(*this)) {
+    input_->Accept(visitor);
+    for (const auto &pattern_filter : pattern_filters_) {
+      pattern_filter->Accept(visitor);
+    }
+  }
+  return visitor.PostVisit(*this);
+}
 
 UniqueCursorPtr Filter::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::FilterOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::FilterOperator);
 
   return MakeUniqueCursorPtr<FilterCursor>(mem, *this, mem);
 }
 
 std::vector<Symbol> Filter::ModifiedSymbols(const SymbolTable &table) const { return input_->ModifiedSymbols(table); }
 
+static std::vector<UniqueCursorPtr> MakeCursorVector(const std::vector<std::shared_ptr<LogicalOperator>> &ops,
+                                                     utils::MemoryResource *mem) {
+  std::vector<UniqueCursorPtr> cursors;
+  cursors.reserve(ops.size());
+
+  if (!ops.empty()) {
+    for (const auto &op : ops) {
+      cursors.push_back(op->MakeCursor(mem));
+    }
+  }
+
+  return cursors;
+}
+
 Filter::FilterCursor::FilterCursor(const Filter &self, utils::MemoryResource *mem)
-    : self_(self), input_cursor_(self_.input_->MakeCursor(mem)) {}
+    : self_(self),
+      input_cursor_(self_.input_->MakeCursor(mem)),
+      pattern_filter_cursors_(MakeCursorVector(self_.pattern_filters_, mem)) {}
 
 bool Filter::FilterCursor::Pull(Frame &frame, ExecutionContext &context) {
   SCOPED_PROFILE_OP("Filter");
@@ -2279,8 +2333,11 @@ bool Filter::FilterCursor::Pull(Frame &frame, ExecutionContext &context) {
   // Like all filters, newly set values should not affect filtering of old
   // nodes and edges.
   ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.db_accessor,
-                                storage::View::OLD);
+                                storage::View::OLD, context.frame_change_collector);
   while (input_cursor_->Pull(frame, context)) {
+    for (const auto &pattern_filter_cursor : pattern_filter_cursors_) {
+      pattern_filter_cursor->Pull(frame, context);
+    }
     if (EvaluateFilter(evaluator, self_.expression_)) return true;
   }
   return false;
@@ -2290,13 +2347,46 @@ void Filter::FilterCursor::Shutdown() { input_cursor_->Shutdown(); }
 
 void Filter::FilterCursor::Reset() { input_cursor_->Reset(); }
 
+EvaluatePatternFilter::EvaluatePatternFilter(const std::shared_ptr<LogicalOperator> &input, Symbol output_symbol)
+    : input_(input), output_symbol_(output_symbol) {}
+
+ACCEPT_WITH_INPUT(EvaluatePatternFilter);
+
+UniqueCursorPtr EvaluatePatternFilter::MakeCursor(utils::MemoryResource *mem) const {
+  memgraph::metrics::IncrementCounter(memgraph::metrics::EvaluatePatternFilterOperator);
+
+  return MakeUniqueCursorPtr<EvaluatePatternFilterCursor>(mem, *this, mem);
+}
+
+EvaluatePatternFilter::EvaluatePatternFilterCursor::EvaluatePatternFilterCursor(const EvaluatePatternFilter &self,
+                                                                                utils::MemoryResource *mem)
+    : self_(self), input_cursor_(self_.input_->MakeCursor(mem)) {}
+
+std::vector<Symbol> EvaluatePatternFilter::ModifiedSymbols(const SymbolTable &table) const {
+  return input_->ModifiedSymbols(table);
+}
+
+bool EvaluatePatternFilter::EvaluatePatternFilterCursor::Pull(Frame &frame, ExecutionContext &context) {
+  SCOPED_PROFILE_OP("EvaluatePatternFilter");
+
+  input_cursor_->Reset();
+
+  frame[self_.output_symbol_] = TypedValue(input_cursor_->Pull(frame, context), context.evaluation_context.memory);
+
+  return true;
+}
+
+void EvaluatePatternFilter::EvaluatePatternFilterCursor::Shutdown() { input_cursor_->Shutdown(); }
+
+void EvaluatePatternFilter::EvaluatePatternFilterCursor::Reset() { input_cursor_->Reset(); }
+
 Produce::Produce(const std::shared_ptr<LogicalOperator> &input, const std::vector<NamedExpression *> &named_expressions)
     : input_(input ? input : std::make_shared<Once>()), named_expressions_(named_expressions) {}
 
 ACCEPT_WITH_INPUT(Produce)
 
 UniqueCursorPtr Produce::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::ProduceOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::ProduceOperator);
 
   return MakeUniqueCursorPtr<ProduceCursor>(mem, *this, mem);
 }
@@ -2320,9 +2410,13 @@ bool Produce::ProduceCursor::Pull(Frame &frame, ExecutionContext &context) {
   if (input_cursor_->Pull(frame, context)) {
     // Produce should always yield the latest results.
     ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.db_accessor,
-                                  storage::View::NEW);
-    for (auto named_expr : self_.named_expressions_) named_expr->Accept(evaluator);
-
+                                  storage::View::NEW, context.frame_change_collector);
+    for (auto *named_expr : self_.named_expressions_) {
+      if (context.frame_change_collector && context.frame_change_collector->IsKeyTracked(named_expr->name_)) {
+        context.frame_change_collector->ResetTrackingValue(named_expr->name_);
+      }
+      named_expr->Accept(evaluator);
+    }
     return true;
   }
   return false;
@@ -2339,7 +2433,7 @@ Delete::Delete(const std::shared_ptr<LogicalOperator> &input_, const std::vector
 ACCEPT_WITH_INPUT(Delete)
 
 UniqueCursorPtr Delete::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::DeleteOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::DeleteOperator);
 
   return MakeUniqueCursorPtr<DeleteCursor>(mem, *this, mem);
 }
@@ -2491,7 +2585,7 @@ SetProperty::SetProperty(const std::shared_ptr<LogicalOperator> &input, storage:
 ACCEPT_WITH_INPUT(SetProperty)
 
 UniqueCursorPtr SetProperty::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::SetPropertyOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::SetPropertyOperator);
 
   return MakeUniqueCursorPtr<SetPropertyCursor>(mem, *this, mem);
 }
@@ -2574,7 +2668,7 @@ SetProperties::SetProperties(const std::shared_ptr<LogicalOperator> &input, Symb
 ACCEPT_WITH_INPUT(SetProperties)
 
 UniqueCursorPtr SetProperties::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::SetPropertiesOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::SetPropertiesOperator);
 
   return MakeUniqueCursorPtr<SetPropertiesCursor>(mem, *this, mem);
 }
@@ -2771,7 +2865,7 @@ SetLabels::SetLabels(const std::shared_ptr<LogicalOperator> &input, Symbol input
 ACCEPT_WITH_INPUT(SetLabels)
 
 UniqueCursorPtr SetLabels::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::SetLabelsOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::SetLabelsOperator);
 
   return MakeUniqueCursorPtr<SetLabelsCursor>(mem, *this, mem);
 }
@@ -2843,7 +2937,7 @@ RemoveProperty::RemoveProperty(const std::shared_ptr<LogicalOperator> &input, st
 ACCEPT_WITH_INPUT(RemoveProperty)
 
 UniqueCursorPtr RemoveProperty::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::RemovePropertyOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::RemovePropertyOperator);
 
   return MakeUniqueCursorPtr<RemovePropertyCursor>(mem, *this, mem);
 }
@@ -2929,7 +3023,7 @@ RemoveLabels::RemoveLabels(const std::shared_ptr<LogicalOperator> &input, Symbol
 ACCEPT_WITH_INPUT(RemoveLabels)
 
 UniqueCursorPtr RemoveLabels::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::RemoveLabelsOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::RemoveLabelsOperator);
 
   return MakeUniqueCursorPtr<RemoveLabelsCursor>(mem, *this, mem);
 }
@@ -3002,7 +3096,7 @@ EdgeUniquenessFilter::EdgeUniquenessFilter(const std::shared_ptr<LogicalOperator
 ACCEPT_WITH_INPUT(EdgeUniquenessFilter)
 
 UniqueCursorPtr EdgeUniquenessFilter::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::EdgeUniquenessFilterOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::EdgeUniquenessFilterOperator);
 
   return MakeUniqueCursorPtr<EdgeUniquenessFilterCursor>(mem, *this, mem);
 }
@@ -3104,7 +3198,7 @@ class EmptyResultCursor : public Cursor {
 };
 
 UniqueCursorPtr EmptyResult::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::EmptyResultOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::EmptyResultOperator);
 
   return MakeUniqueCursorPtr<EmptyResultCursor>(mem, *this, mem);
 }
@@ -3143,7 +3237,12 @@ class AccumulateCursor : public Cursor {
     if (MustAbort(context)) throw HintedAbortError();
     if (cache_it_ == cache_.end()) return false;
     auto row_it = (cache_it_++)->begin();
-    for (const Symbol &symbol : self_.symbols_) frame[symbol] = *row_it++;
+    for (const Symbol &symbol : self_.symbols_) {
+      if (context.frame_change_collector && context.frame_change_collector->IsKeyTracked(symbol.name())) {
+        context.frame_change_collector->ResetTrackingValue(symbol.name());
+      }
+      frame[symbol] = *row_it++;
+    }
     return true;
   }
 
@@ -3159,13 +3258,13 @@ class AccumulateCursor : public Cursor {
  private:
   const Accumulate &self_;
   const UniqueCursorPtr input_cursor_;
-  utils::pmr::vector<utils::pmr::vector<TypedValue>> cache_;
+  utils::pmr::deque<utils::pmr::vector<TypedValue>> cache_;
   decltype(cache_.begin()) cache_it_ = cache_.begin();
   bool pulled_all_input_{false};
 };
 
 UniqueCursorPtr Accumulate::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::AccumulateOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::AccumulateOperator);
 
   return MakeUniqueCursorPtr<AccumulateCursor>(mem, *this, mem);
 }
@@ -3225,10 +3324,20 @@ class AggregateCursor : public Cursor {
       if (aggregation_.empty()) {
         auto *pull_memory = context.evaluation_context.memory;
         // place default aggregation values on the frame
-        for (const auto &elem : self_.aggregations_)
+        for (const auto &elem : self_.aggregations_) {
           frame[elem.output_sym] = DefaultAggregationOpValue(elem, pull_memory);
+          if (context.frame_change_collector && context.frame_change_collector->IsKeyTracked(elem.output_sym.name())) {
+            context.frame_change_collector->ResetTrackingValue(elem.output_sym.name());
+          }
+        }
+
         // place null as remember values on the frame
-        for (const Symbol &remember_sym : self_.remember_) frame[remember_sym] = TypedValue(pull_memory);
+        for (const Symbol &remember_sym : self_.remember_) {
+          frame[remember_sym] = TypedValue(pull_memory);
+          if (context.frame_change_collector && context.frame_change_collector->IsKeyTracked(remember_sym.name())) {
+            context.frame_change_collector->ResetTrackingValue(remember_sym.name());
+          }
+        }
         return true;
       }
     }
@@ -3527,7 +3636,7 @@ class AggregateCursor : public Cursor {
 };
 
 UniqueCursorPtr Aggregate::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::AggregateOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::AggregateOperator);
 
   return MakeUniqueCursorPtr<AggregateCursor>(mem, *this, mem);
 }
@@ -3538,7 +3647,7 @@ Skip::Skip(const std::shared_ptr<LogicalOperator> &input, Expression *expression
 ACCEPT_WITH_INPUT(Skip)
 
 UniqueCursorPtr Skip::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::SkipOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::SkipOperator);
 
   return MakeUniqueCursorPtr<SkipCursor>(mem, *this, mem);
 }
@@ -3591,7 +3700,7 @@ Limit::Limit(const std::shared_ptr<LogicalOperator> &input, Expression *expressi
 ACCEPT_WITH_INPUT(Limit)
 
 UniqueCursorPtr Limit::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::LimitOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::LimitOperator);
 
   return MakeUniqueCursorPtr<LimitCursor>(mem, *this, mem);
 }
@@ -3708,8 +3817,12 @@ class OrderByCursor : public Cursor {
                "Number of values does not match the number of output symbols "
                "in OrderBy");
     auto output_sym_it = self_.output_symbols_.begin();
-    for (const TypedValue &output : cache_it_->remember) frame[*output_sym_it++] = output;
-
+    for (const TypedValue &output : cache_it_->remember) {
+      if (context.frame_change_collector && context.frame_change_collector->IsKeyTracked(output_sym_it->name())) {
+        context.frame_change_collector->ResetTrackingValue(output_sym_it->name());
+      }
+      frame[*output_sym_it++] = output;
+    }
     cache_it_++;
     return true;
   }
@@ -3739,7 +3852,7 @@ class OrderByCursor : public Cursor {
 };
 
 UniqueCursorPtr OrderBy::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::OrderByOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::OrderByOperator);
 
   return MakeUniqueCursorPtr<OrderByCursor>(mem, *this, mem);
 }
@@ -3756,7 +3869,7 @@ bool Merge::Accept(HierarchicalLogicalOperatorVisitor &visitor) {
 }
 
 UniqueCursorPtr Merge::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::MergeOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::MergeOperator);
 
   return MakeUniqueCursorPtr<MergeCursor>(mem, *this, mem);
 }
@@ -3836,7 +3949,7 @@ bool Optional::Accept(HierarchicalLogicalOperatorVisitor &visitor) {
 }
 
 UniqueCursorPtr Optional::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::OptionalOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::OptionalOperator);
 
   return MakeUniqueCursorPtr<OptionalCursor>(mem, *this, mem);
 }
@@ -3942,6 +4055,9 @@ class UnwindCursor : public Cursor {
       if (input_value_it_ == input_value_.end()) continue;
 
       frame[self_.output_symbol_] = *input_value_it_++;
+      if (context.frame_change_collector && context.frame_change_collector->IsKeyTracked(self_.output_symbol_.name_)) {
+        context.frame_change_collector->ResetTrackingValue(self_.output_symbol_.name_);
+      }
       return true;
     }
   }
@@ -3964,7 +4080,7 @@ class UnwindCursor : public Cursor {
 };
 
 UniqueCursorPtr Unwind::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::UnwindOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::UnwindOperator);
 
   return MakeUniqueCursorPtr<UnwindCursor>(mem, *this, mem);
 }
@@ -3982,8 +4098,14 @@ class DistinctCursor : public Cursor {
 
       utils::pmr::vector<TypedValue> row(seen_rows_.get_allocator().GetMemoryResource());
       row.reserve(self_.value_symbols_.size());
-      for (const auto &symbol : self_.value_symbols_) row.emplace_back(frame[symbol]);
-      if (seen_rows_.insert(std::move(row)).second) return true;
+
+      for (const auto &symbol : self_.value_symbols_) {
+        row.emplace_back(frame.at(symbol));
+      }
+
+      if (seen_rows_.insert(std::move(row)).second) {
+        return true;
+      }
     }
   }
 
@@ -4012,7 +4134,7 @@ Distinct::Distinct(const std::shared_ptr<LogicalOperator> &input, const std::vec
 ACCEPT_WITH_INPUT(Distinct)
 
 UniqueCursorPtr Distinct::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::DistinctOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::DistinctOperator);
 
   return MakeUniqueCursorPtr<DistinctCursor>(mem, *this, mem);
 }
@@ -4034,7 +4156,7 @@ Union::Union(const std::shared_ptr<LogicalOperator> &left_op, const std::shared_
       right_symbols_(right_symbols) {}
 
 UniqueCursorPtr Union::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::UnionOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::UnionOperator);
 
   return MakeUniqueCursorPtr<Union::UnionCursor>(mem, *this, mem);
 }
@@ -4065,11 +4187,17 @@ bool Union::UnionCursor::Pull(Frame &frame, ExecutionContext &context) {
     // collect values from the left child
     for (const auto &output_symbol : self_.left_symbols_) {
       results[output_symbol.name()] = frame[output_symbol];
+      if (context.frame_change_collector && context.frame_change_collector->IsKeyTracked(output_symbol.name())) {
+        context.frame_change_collector->ResetTrackingValue(output_symbol.name());
+      }
     }
   } else if (right_cursor_->Pull(frame, context)) {
     // collect values from the right child
     for (const auto &output_symbol : self_.right_symbols_) {
       results[output_symbol.name()] = frame[output_symbol];
+      if (context.frame_change_collector && context.frame_change_collector->IsKeyTracked(output_symbol.name())) {
+        context.frame_change_collector->ResetTrackingValue(output_symbol.name());
+      }
     }
   } else {
     return false;
@@ -4078,6 +4206,9 @@ bool Union::UnionCursor::Pull(Frame &frame, ExecutionContext &context) {
   // put collected values on frame under union symbols
   for (const auto &symbol : self_.union_symbols_) {
     frame[symbol] = results[symbol.name()];
+    if (context.frame_change_collector && context.frame_change_collector->IsKeyTracked(symbol.name())) {
+      context.frame_change_collector->ResetTrackingValue(symbol.name());
+    }
   }
   return true;
 }
@@ -4142,9 +4273,12 @@ class CartesianCursor : public Cursor {
       return false;
     }
 
-    auto restore_frame = [&frame](const auto &symbols, const auto &restore_from) {
+    auto restore_frame = [&frame, &context](const auto &symbols, const auto &restore_from) {
       for (const auto &symbol : symbols) {
         frame[symbol] = restore_from[symbol.position()];
+        if (context.frame_change_collector && context.frame_change_collector->IsKeyTracked(symbol.name())) {
+          context.frame_change_collector->ResetTrackingValue(symbol.name());
+        }
       }
     };
 
@@ -4193,7 +4327,7 @@ class CartesianCursor : public Cursor {
 }  // namespace
 
 UniqueCursorPtr Cartesian::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::CartesianOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::CartesianOperator);
 
   return MakeUniqueCursorPtr<CartesianCursor>(mem, *this, mem);
 }
@@ -4222,6 +4356,10 @@ class OutputTableCursor : public Cursor {
     if (current_row_ < rows_.size()) {
       for (size_t i = 0; i < self_.output_symbols_.size(); ++i) {
         frame[self_.output_symbols_[i]] = rows_[current_row_][i];
+        if (context.frame_change_collector &&
+            context.frame_change_collector->IsKeyTracked(self_.output_symbols_[i].name())) {
+          context.frame_change_collector->ResetTrackingValue(self_.output_symbols_[i].name());
+        }
       }
       current_row_++;
       return true;
@@ -4265,6 +4403,10 @@ class OutputTableStreamCursor : public Cursor {
       MG_ASSERT(row->size() == self_->output_symbols_.size(), "Wrong number of columns in row!");
       for (size_t i = 0; i < self_->output_symbols_.size(); ++i) {
         frame[self_->output_symbols_[i]] = row->at(i);
+        if (context.frame_change_collector &&
+            context.frame_change_collector->IsKeyTracked(self_->output_symbols_[i].name())) {
+          context.frame_change_collector->ResetTrackingValue(self_->output_symbols_[i].name());
+        }
       }
       return true;
     }
@@ -4449,7 +4591,7 @@ class CallProcedureCursor : public Cursor {
       result_row_it_ = result_.rows.begin();
     }
 
-    const auto &values = result_row_it_->values;
+    auto &values = result_row_it_->values;
     // Check that the row has all fields as required by the result signature.
     // C API guarantees that it's impossible to set fields which are not part of
     // the result record, but it does not gurantee that some may be missing. See
@@ -4467,7 +4609,11 @@ class CallProcedureCursor : public Cursor {
         throw QueryRuntimeException("Procedure '{}' did not yield a record with '{}' field.", self_->procedure_name_,
                                     field_name);
       }
-      frame[self_->result_symbols_[i]] = result_it->second;
+      frame[self_->result_symbols_[i]] = std::move(result_it->second);
+      if (context.frame_change_collector &&
+          context.frame_change_collector->IsKeyTracked(self_->result_symbols_[i].name())) {
+        context.frame_change_collector->ResetTrackingValue(self_->result_symbols_[i].name());
+      }
     }
     ++result_row_it_;
 
@@ -4484,7 +4630,7 @@ class CallProcedureCursor : public Cursor {
 };
 
 UniqueCursorPtr CallProcedure::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::CallProcedureOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::CallProcedureOperator);
   CallProcedure::IncrementCounter(procedure_name_);
 
   return MakeUniqueCursorPtr<CallProcedureCursor>(mem, this, mem);
@@ -4594,6 +4740,9 @@ class LoadCsvCursor : public Cursor {
       frame[self_->row_var_] =
           CsvRowToTypedMap(*row, csv::Reader::Header(reader_->GetHeader(), context.evaluation_context.memory));
     }
+    if (context.frame_change_collector && context.frame_change_collector->IsKeyTracked(self_->row_var_.name())) {
+      context.frame_change_collector->ResetTrackingValue(self_->row_var_.name());
+    }
     return true;
   }
 
@@ -4690,7 +4839,7 @@ Foreach::Foreach(std::shared_ptr<LogicalOperator> input, std::shared_ptr<Logical
       loop_variable_symbol_(loop_variable_symbol) {}
 
 UniqueCursorPtr Foreach::MakeCursor(utils::MemoryResource *mem) const {
-  EventCounter::IncrementCounter(EventCounter::ForeachOperator);
+  memgraph::metrics::IncrementCounter(memgraph::metrics::ForeachOperator);
   return MakeUniqueCursorPtr<ForeachCursor>(mem, *this, mem);
 }
 
@@ -4708,4 +4857,72 @@ bool Foreach::Accept(HierarchicalLogicalOperatorVisitor &visitor) {
   return visitor.PostVisit(*this);
 }
 
+Apply::Apply(const std::shared_ptr<LogicalOperator> input, const std::shared_ptr<LogicalOperator> subquery,
+             bool subquery_has_return)
+    : input_(input ? input : std::make_shared<Once>()),
+      subquery_(subquery),
+      subquery_has_return_(subquery_has_return) {}
+
+bool Apply::Accept(HierarchicalLogicalOperatorVisitor &visitor) {
+  if (visitor.PreVisit(*this)) {
+    input_->Accept(visitor) && subquery_->Accept(visitor);
+  }
+  return visitor.PostVisit(*this);
+}
+
+UniqueCursorPtr Apply::MakeCursor(utils::MemoryResource *mem) const {
+  memgraph::metrics::IncrementCounter(memgraph::metrics::ApplyOperator);
+
+  return MakeUniqueCursorPtr<ApplyCursor>(mem, *this, mem);
+}
+
+Apply::ApplyCursor::ApplyCursor(const Apply &self, utils::MemoryResource *mem)
+    : self_(self),
+      input_(self.input_->MakeCursor(mem)),
+      subquery_(self.subquery_->MakeCursor(mem)),
+      subquery_has_return_(self.subquery_has_return_) {}
+
+std::vector<Symbol> Apply::ModifiedSymbols(const SymbolTable &table) const {
+  // Since Apply is the Cartesian product, modified symbols are combined from
+  // both execution branches.
+  auto symbols = input_->ModifiedSymbols(table);
+  auto subquery_symbols = subquery_->ModifiedSymbols(table);
+  symbols.insert(symbols.end(), subquery_symbols.begin(), subquery_symbols.end());
+  return symbols;
+}
+
+bool Apply::ApplyCursor::Pull(Frame &frame, ExecutionContext &context) {
+  SCOPED_PROFILE_OP("Apply");
+
+  while (true) {
+    if (pull_input_ && !input_->Pull(frame, context)) {
+      return false;
+    };
+
+    if (subquery_->Pull(frame, context)) {
+      // if successful, next Pull from this should not pull_input_
+      pull_input_ = false;
+      return true;
+    }
+    // failed to pull from subquery cursor
+    // skip that row
+    pull_input_ = true;
+    subquery_->Reset();
+
+    // don't skip row if no rows are returned from subquery, return input_ rows
+    if (!subquery_has_return_) return true;
+  }
+}
+
+void Apply::ApplyCursor::Shutdown() {
+  input_->Shutdown();
+  subquery_->Shutdown();
+}
+
+void Apply::ApplyCursor::Reset() {
+  input_->Reset();
+  subquery_->Reset();
+  pull_input_ = true;
+}
+
 }  // namespace memgraph::query::plan

src/query/plan/operator.lcp

@@ -133,6 +133,8 @@ class CallProcedure;
 class LoadCsv;
 class Foreach;
 class EmptyResult;
+class EvaluatePatternFilter;
+class Apply;
 
 using LogicalOperatorCompositeVisitor = utils::CompositeVisitor<
     Once, CreateNode, CreateExpand, ScanAll, ScanAllByLabel,
@@ -141,7 +143,8 @@ using LogicalOperatorCompositeVisitor = utils::CompositeVisitor<
     Expand, ExpandVariable, ConstructNamedPath, Filter, Produce, Delete,
     SetProperty, SetProperties, SetLabels, RemoveProperty, RemoveLabels,
     EdgeUniquenessFilter, Accumulate, Aggregate, Skip, Limit, OrderBy, Merge,
-    Optional, Unwind, Distinct, Union, Cartesian, CallProcedure, LoadCsv, Foreach, EmptyResult>;
+    Optional, Unwind, Distinct, Union, Cartesian, CallProcedure, LoadCsv, Foreach, EmptyResult,
+    EvaluatePatternFilter, Apply>;
 
 using LogicalOperatorLeafVisitor = utils::LeafVisitor<Once>;
 
@@ -1122,6 +1125,9 @@ pulled.")
   ((input "std::shared_ptr<LogicalOperator>" :scope :public
           :slk-save #'slk-save-operator-pointer
           :slk-load #'slk-load-operator-pointer)
+   (pattern_filters "std::vector<std::shared_ptr<LogicalOperator>>" :scope :public
+          :slk-save #'slk-save-ast-vector
+          :slk-load (slk-load-ast-vector "std::shared_ptr<LogicalOperator>"))
    (expression "Expression *" :scope :public
                :slk-save #'slk-save-ast-pointer
                :slk-load (slk-load-ast-pointer "Expression")))
@@ -1136,6 +1142,7 @@ a boolean value.")
    Filter() {}
 
    Filter(const std::shared_ptr<LogicalOperator> &input_,
+          const std::vector<std::shared_ptr<LogicalOperator>> &pattern_filters_,
           Expression *expression_);
    bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
    UniqueCursorPtr MakeCursor(utils::MemoryResource *) const override;
@@ -1159,6 +1166,7 @@ a boolean value.")
     private:
      const Filter &self_;
      const UniqueCursorPtr input_cursor_;
+     const std::vector<UniqueCursorPtr> pattern_filter_cursors_;
    };
    cpp<#)
   (:serialize (:slk))
@@ -1777,6 +1785,45 @@ operator's implementation does not expect this.")
   (:serialize (:slk))
   (:clone))
 
+(lcp:define-class evaluate-pattern-filter (logical-operator)
+  ((input "std::shared_ptr<LogicalOperator>" :scope :public
+          :slk-save #'slk-save-operator-pointer
+          :slk-load #'slk-load-operator-pointer)
+   (output-symbol "Symbol" :scope :public))
+  (:documentation "Applies the pattern filter by putting the value of the input cursor to the frame.")
+
+  (:public
+   #>cpp
+   EvaluatePatternFilter() {}
+
+   EvaluatePatternFilter(const std::shared_ptr<LogicalOperator> &input, Symbol output_symbol);
+   bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
+   UniqueCursorPtr MakeCursor(utils::MemoryResource *) const override;
+   std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
+
+   bool HasSingleInput() const override { return true; }
+   std::shared_ptr<LogicalOperator> input() const override { return input_; }
+   void set_input(std::shared_ptr<LogicalOperator> input) override {
+     input_ = input;
+   }
+   cpp<#)
+  (:private
+   #>cpp
+   class EvaluatePatternFilterCursor : public Cursor {
+    public:
+     EvaluatePatternFilterCursor(const EvaluatePatternFilter &, utils::MemoryResource *);
+     bool Pull(Frame &, ExecutionContext &) override;
+     void Shutdown() override;
+     void Reset() override;
+
+    private:
+     const EvaluatePatternFilter &self_;
+     UniqueCursorPtr input_cursor_;
+   };
+   cpp<#)
+  (:serialize (:slk))
+  (:clone))
+
 (lcp:define-class limit (logical-operator)
   ((input "std::shared_ptr<LogicalOperator>" :scope :public
           :slk-save #'slk-save-operator-pointer
@@ -2336,6 +2383,52 @@ clauses.
   (:serialize (:slk))
   (:clone))
 
+(lcp:define-class apply (logical-operator)
+  ((input "std::shared_ptr<LogicalOperator>" :scope :public
+          :slk-save #'slk-save-operator-pointer
+          :slk-load #'slk-load-operator-pointer)
+   (subquery "std::shared_ptr<LogicalOperator>" :scope :public
+          :slk-save #'slk-save-operator-pointer
+          :slk-load #'slk-load-operator-pointer)
+   (subquery-has-return "bool" :scope :public))
+
+  (:documentation "Applies symbols from both output branches.")
+
+  (:public
+   #>cpp
+   Apply() {}
+
+   Apply(const std::shared_ptr<LogicalOperator> input, const std::shared_ptr<LogicalOperator> subquery, bool subquery_has_return);
+   bool Accept(HierarchicalLogicalOperatorVisitor &visitor) override;
+   UniqueCursorPtr MakeCursor(utils::MemoryResource *) const override;
+   std::vector<Symbol> ModifiedSymbols(const SymbolTable &) const override;
+
+   bool HasSingleInput() const override { return true; }
+   std::shared_ptr<LogicalOperator> input() const override { return input_; }
+   void set_input(std::shared_ptr<LogicalOperator> input) override {
+     input_ = input;
+   }
+   cpp<#)
+  (:private
+   #>cpp
+   class ApplyCursor : public Cursor {
+    public:
+     ApplyCursor(const Apply &, utils::MemoryResource *);
+     bool Pull(Frame &, ExecutionContext &) override;
+     void Shutdown() override;
+     void Reset() override;
+
+    private:
+     const Apply &self_;
+     UniqueCursorPtr input_;
+     UniqueCursorPtr subquery_;
+     bool pull_input_{true};
+     bool subquery_has_return_{true};
+   };
+   cpp<#)
+  (:serialize (:slk))
+  (:clone))
+
 (lcp:pop-namespace) ;; plan
 (lcp:pop-namespace) ;; query
 (lcp:pop-namespace) ;; memgraph

src/query/plan/operator_type_info.cpp

@@ -0,0 +1,151 @@
+// 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 "query/plan/operator.hpp"
+
+namespace memgraph {
+
+constexpr utils::TypeInfo query::plan::LogicalOperator::kType{utils::TypeId::LOGICAL_OPERATOR, "LogicalOperator",
+                                                              nullptr};
+
+constexpr utils::TypeInfo query::plan::Once::kType{utils::TypeId::ONCE, "Once", &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::NodeCreationInfo::kType{utils::TypeId::NODE_CREATION_INFO, "NodeCreationInfo",
+                                                               nullptr};
+
+constexpr utils::TypeInfo query::plan::CreateNode::kType{utils::TypeId::CREATE_NODE, "CreateNode",
+                                                         &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::EdgeCreationInfo::kType{utils::TypeId::EDGE_CREATION_INFO, "EdgeCreationInfo",
+                                                               nullptr};
+
+constexpr utils::TypeInfo query::plan::CreateExpand::kType{utils::TypeId::CREATE_EXPAND, "CreateExpand",
+                                                           &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::ScanAll::kType{utils::TypeId::SCAN_ALL, "ScanAll",
+                                                      &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::ScanAllByLabel::kType{utils::TypeId::SCAN_ALL_BY_LABEL, "ScanAllByLabel",
+                                                             &query::plan::ScanAll::kType};
+
+constexpr utils::TypeInfo query::plan::ScanAllByLabelPropertyRange::kType{
+    utils::TypeId::SCAN_ALL_BY_LABEL_PROPERTY_RANGE, "ScanAllByLabelPropertyRange", &query::plan::ScanAll::kType};
+
+constexpr utils::TypeInfo query::plan::ScanAllByLabelPropertyValue::kType{
+    utils::TypeId::SCAN_ALL_BY_LABEL_PROPERTY_VALUE, "ScanAllByLabelPropertyValue", &query::plan::ScanAll::kType};
+
+constexpr utils::TypeInfo query::plan::ScanAllByLabelProperty::kType{
+    utils::TypeId::SCAN_ALL_BY_LABEL_PROPERTY, "ScanAllByLabelProperty", &query::plan::ScanAll::kType};
+
+constexpr utils::TypeInfo query::plan::ScanAllById::kType{utils::TypeId::SCAN_ALL_BY_ID, "ScanAllById",
+                                                          &query::plan::ScanAll::kType};
+
+constexpr utils::TypeInfo query::plan::ExpandCommon::kType{utils::TypeId::EXPAND_COMMON, "ExpandCommon", nullptr};
+
+constexpr utils::TypeInfo query::plan::Expand::kType{utils::TypeId::EXPAND, "Expand",
+                                                     &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::ExpansionLambda::kType{utils::TypeId::EXPANSION_LAMBDA, "ExpansionLambda",
+                                                              nullptr};
+
+constexpr utils::TypeInfo query::plan::ExpandVariable::kType{utils::TypeId::EXPAND_VARIABLE, "ExpandVariable",
+                                                             &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::ConstructNamedPath::kType{
+    utils::TypeId::CONSTRUCT_NAMED_PATH, "ConstructNamedPath", &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Filter::kType{utils::TypeId::FILTER, "Filter",
+                                                     &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Produce::kType{utils::TypeId::PRODUCE, "Produce",
+                                                      &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Delete::kType{utils::TypeId::DELETE, "Delete",
+                                                     &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::SetProperty::kType{utils::TypeId::SET_PROPERTY, "SetProperty",
+                                                          &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::SetProperties::kType{utils::TypeId::SET_PROPERTIES, "SetProperties",
+                                                            &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::SetLabels::kType{utils::TypeId::SET_LABELS, "SetLabels",
+                                                        &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::RemoveProperty::kType{utils::TypeId::REMOVE_PROPERTY, "RemoveProperty",
+                                                             &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::RemoveLabels::kType{utils::TypeId::REMOVE_LABELS, "RemoveLabels",
+                                                           &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::EdgeUniquenessFilter::kType{
+    utils::TypeId::EDGE_UNIQUENESS_FILTER, "EdgeUniquenessFilter", &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::EmptyResult::kType{utils::TypeId::EMPTY_RESULT, "EmptyResult",
+                                                          &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Accumulate::kType{utils::TypeId::ACCUMULATE, "Accumulate",
+                                                         &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Aggregate::Element::kType{utils::TypeId::AGGREGATE_ELEMENT, "Element", nullptr};
+
+constexpr utils::TypeInfo query::plan::Aggregate::kType{utils::TypeId::AGGREGATE, "Aggregate",
+                                                        &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Skip::kType{utils::TypeId::SKIP, "Skip", &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::EvaluatePatternFilter::kType{
+    utils::TypeId::EVALUATE_PATTERN_FILTER, "EvaluatePatternFilter", &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Limit::kType{utils::TypeId::LIMIT, "Limit",
+                                                    &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::OrderBy::kType{utils::TypeId::ORDERBY, "OrderBy",
+                                                      &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Merge::kType{utils::TypeId::MERGE, "Merge",
+                                                    &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Optional::kType{utils::TypeId::OPTIONAL, "Optional",
+                                                       &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Unwind::kType{utils::TypeId::UNWIND, "Unwind",
+                                                     &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Distinct::kType{utils::TypeId::DISTINCT, "Distinct",
+                                                       &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Union::kType{utils::TypeId::UNION, "Union",
+                                                    &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Cartesian::kType{utils::TypeId::CARTESIAN, "Cartesian",
+                                                        &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::OutputTable::kType{utils::TypeId::OUTPUT_TABLE, "OutputTable",
+                                                          &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::OutputTableStream::kType{utils::TypeId::OUTPUT_TABLE_STREAM, "OutputTableStream",
+                                                                &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::CallProcedure::kType{utils::TypeId::CALL_PROCEDURE, "CallProcedure",
+                                                            &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::LoadCsv::kType{utils::TypeId::LOAD_CSV, "LoadCsv",
+                                                      &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Foreach::kType{utils::TypeId::FOREACH, "Foreach",
+                                                      &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Apply::kType{utils::TypeId::APPLY, "Apply",
+                                                    &query::plan::LogicalOperator::kType};
+}  // namespace memgraph

src/query/plan/planner.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
@@ -50,23 +50,6 @@ class PostProcessor final {
   double EstimatePlanCost(const std::unique_ptr<LogicalOperator> &plan, TVertexCounts *vertex_counts) {
     return query::plan::EstimatePlanCost(vertex_counts, parameters_, *plan);
   }
-
-  template <class TPlanningContext>
-  std::unique_ptr<LogicalOperator> MergeWithCombinator(std::unique_ptr<LogicalOperator> curr_op,
-                                                       std::unique_ptr<LogicalOperator> last_op, const Tree &combinator,
-                                                       TPlanningContext *context) {
-    if (const auto *union_ = utils::Downcast<const CypherUnion>(&combinator)) {
-      return std::unique_ptr<LogicalOperator>(
-          impl::GenUnion(*union_, std::move(last_op), std::move(curr_op), *context->symbol_table));
-    }
-    throw utils::NotYetImplemented("query combinator");
-  }
-
-  template <class TPlanningContext>
-  std::unique_ptr<LogicalOperator> MakeDistinct(std::unique_ptr<LogicalOperator> last_op, TPlanningContext *context) {
-    auto output_symbols = last_op->OutputSymbols(*context->symbol_table);
-    return std::make_unique<Distinct>(std::move(last_op), output_symbols);
-  }
 };
 
 /// @brief Generates the LogicalOperator tree for a single query and returns the
@@ -82,10 +65,9 @@ class PostProcessor final {
 /// @sa RuleBasedPlanner
 /// @sa VariableStartPlanner
 template <template <class> class TPlanner, class TDbAccessor>
-auto MakeLogicalPlanForSingleQuery(std::vector<SingleQueryPart> single_query_parts,
-                                   PlanningContext<TDbAccessor> *context) {
+auto MakeLogicalPlanForSingleQuery(QueryParts query_parts, PlanningContext<TDbAccessor> *context) {
   context->bound_symbols.clear();
-  return TPlanner<PlanningContext<TDbAccessor>>(context).Plan(single_query_parts);
+  return TPlanner<PlanningContext<TDbAccessor>>(context).Plan(query_parts);
 }
 
 /// Generates the LogicalOperator tree and returns the resulting plan.
@@ -103,48 +85,34 @@ template <class TPlanningContext, class TPlanPostProcess>
 auto MakeLogicalPlan(TPlanningContext *context, TPlanPostProcess *post_process, bool use_variable_planner) {
   auto query_parts = CollectQueryParts(*context->symbol_table, *context->ast_storage, context->query);
   auto &vertex_counts = *context->db;
-  double total_cost = 0;
+  double total_cost = std::numeric_limits<double>::max();
 
   using ProcessedPlan = typename TPlanPostProcess::ProcessedPlan;
-  ProcessedPlan last_plan;
+  ProcessedPlan plan_with_least_cost;
 
-  for (const auto &query_part : query_parts.query_parts) {
-    std::optional<ProcessedPlan> curr_plan;
-    double min_cost = std::numeric_limits<double>::max();
-
-    if (use_variable_planner) {
-      auto plans = MakeLogicalPlanForSingleQuery<VariableStartPlanner>(query_part.single_query_parts, context);
-      for (auto plan : plans) {
-        // Plans are generated lazily and the current plan will disappear, so
-        // it's ok to move it.
-        auto rewritten_plan = post_process->Rewrite(std::move(plan), context);
-        double cost = post_process->EstimatePlanCost(rewritten_plan, &vertex_counts);
-        if (!curr_plan || cost < min_cost) {
-          curr_plan.emplace(std::move(rewritten_plan));
-          min_cost = cost;
-        }
-      }
-    } else {
-      auto plan = MakeLogicalPlanForSingleQuery<RuleBasedPlanner>(query_part.single_query_parts, context);
+  std::optional<ProcessedPlan> curr_plan;
+  if (use_variable_planner) {
+    auto plans = MakeLogicalPlanForSingleQuery<VariableStartPlanner>(query_parts, context);
+    for (auto plan : plans) {
+      // Plans are generated lazily and the current plan will disappear, so
+      // it's ok to move it.
       auto rewritten_plan = post_process->Rewrite(std::move(plan), context);
-      min_cost = post_process->EstimatePlanCost(rewritten_plan, &vertex_counts);
-      curr_plan.emplace(std::move(rewritten_plan));
-    }
-
-    total_cost += min_cost;
-    if (query_part.query_combinator) {
-      last_plan = post_process->MergeWithCombinator(std::move(*curr_plan), std::move(last_plan),
-                                                    *query_part.query_combinator, context);
-    } else {
-      last_plan = std::move(*curr_plan);
+      double cost = post_process->EstimatePlanCost(rewritten_plan, &vertex_counts);
+      if (!curr_plan || cost < total_cost) {
+        curr_plan.emplace(std::move(rewritten_plan));
+        total_cost = cost;
+      }
     }
+  } else {
+    auto plan = MakeLogicalPlanForSingleQuery<RuleBasedPlanner>(query_parts, context);
+    auto rewritten_plan = post_process->Rewrite(std::move(plan), context);
+    total_cost = post_process->EstimatePlanCost(rewritten_plan, &vertex_counts);
+    curr_plan.emplace(std::move(rewritten_plan));
   }
 
-  if (query_parts.distinct) {
-    last_plan = post_process->MakeDistinct(std::move(last_plan), context);
-  }
+  plan_with_least_cost = std::move(*curr_plan);
 
-  return std::make_pair(std::move(last_plan), total_cost);
+  return std::make_pair(std::move(plan_with_least_cost), total_cost);
 }
 
 template <class TPlanningContext>

src/query/plan/preprocess.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
@@ -84,56 +84,6 @@ std::vector<Expansion> NormalizePatterns(const SymbolTable &symbol_table, const
   return expansions;
 }
 
-// Fills the given Matching, by converting the Match patterns to normalized
-// representation as Expansions. Filters used in the Match are also collected,
-// as well as edge symbols which determine Cyphermorphism. Collecting filters
-// will lift them out of a pattern and generate new expressions (just like they
-// were in a Where clause).
-void AddMatching(const std::vector<Pattern *> &patterns, Where *where, SymbolTable &symbol_table, AstStorage &storage,
-                 Matching &matching) {
-  auto expansions = NormalizePatterns(symbol_table, patterns);
-  std::unordered_set<Symbol> edge_symbols;
-  for (const auto &expansion : expansions) {
-    // Matching may already have some expansions, so offset our index.
-    const size_t expansion_ix = matching.expansions.size();
-    // Map node1 symbol to expansion
-    const auto &node1_sym = symbol_table.at(*expansion.node1->identifier_);
-    matching.node_symbol_to_expansions[node1_sym].insert(expansion_ix);
-    // Add node1 to all symbols.
-    matching.expansion_symbols.insert(node1_sym);
-    if (expansion.edge) {
-      const auto &edge_sym = symbol_table.at(*expansion.edge->identifier_);
-      // Fill edge symbols for Cyphermorphism.
-      edge_symbols.insert(edge_sym);
-      // Map node2 symbol to expansion
-      const auto &node2_sym = symbol_table.at(*expansion.node2->identifier_);
-      matching.node_symbol_to_expansions[node2_sym].insert(expansion_ix);
-      // Add edge and node2 to all symbols
-      matching.expansion_symbols.insert(edge_sym);
-      matching.expansion_symbols.insert(node2_sym);
-    }
-    matching.expansions.push_back(expansion);
-  }
-  if (!edge_symbols.empty()) {
-    matching.edge_symbols.emplace_back(edge_symbols);
-  }
-  for (auto *pattern : patterns) {
-    matching.filters.CollectPatternFilters(*pattern, symbol_table, storage);
-    if (pattern->identifier_->user_declared_) {
-      std::vector<Symbol> path_elements;
-      for (auto *pattern_atom : pattern->atoms_)
-        path_elements.emplace_back(symbol_table.at(*pattern_atom->identifier_));
-      matching.named_paths.emplace(symbol_table.at(*pattern->identifier_), std::move(path_elements));
-    }
-  }
-  if (where) {
-    matching.filters.CollectWhereFilter(*where, symbol_table);
-  }
-}
-void AddMatching(const Match &match, SymbolTable &symbol_table, AstStorage &storage, Matching &matching) {
-  return AddMatching(match.patterns_, match.where_, symbol_table, storage, matching);
-}
-
 auto SplitExpressionOnAnd(Expression *expression) {
   // TODO: Think about converting all filtering expression into CNF to improve
   // the granularity of filters which can be stand alone.
@@ -519,6 +469,8 @@ void Filters::AnalyzeAndStoreFilter(Expression *expr, const SymbolTable &symbol_
     if (!add_prop_is_not_null_check(is_not_null)) {
       all_filters_.emplace_back(make_filter(FilterInfo::Type::Generic));
     }
+  } else if (auto *exists = utils::Downcast<Exists>(expr)) {
+    all_filters_.emplace_back(make_filter(FilterInfo::Type::Pattern));
   } else {
     all_filters_.emplace_back(make_filter(FilterInfo::Type::Generic));
   }
@@ -528,6 +480,78 @@ void Filters::AnalyzeAndStoreFilter(Expression *expr, const SymbolTable &symbol_
   // as `expr1 < n.prop AND n.prop < expr2`.
 }
 
+// Fills the given Matching, by converting the Match patterns to normalized
+// representation as Expansions. Filters used in the Match are also collected,
+// as well as edge symbols which determine Cyphermorphism. Collecting filters
+// will lift them out of a pattern and generate new expressions (just like they
+// were in a Where clause).
+void AddMatching(const std::vector<Pattern *> &patterns, Where *where, SymbolTable &symbol_table, AstStorage &storage,
+                 Matching &matching) {
+  auto expansions = NormalizePatterns(symbol_table, patterns);
+  std::unordered_set<Symbol> edge_symbols;
+  for (const auto &expansion : expansions) {
+    // Matching may already have some expansions, so offset our index.
+    const size_t expansion_ix = matching.expansions.size();
+    // Map node1 symbol to expansion
+    const auto &node1_sym = symbol_table.at(*expansion.node1->identifier_);
+    matching.node_symbol_to_expansions[node1_sym].insert(expansion_ix);
+    // Add node1 to all symbols.
+    matching.expansion_symbols.insert(node1_sym);
+    if (expansion.edge) {
+      const auto &edge_sym = symbol_table.at(*expansion.edge->identifier_);
+      // Fill edge symbols for Cyphermorphism.
+      edge_symbols.insert(edge_sym);
+      // Map node2 symbol to expansion
+      const auto &node2_sym = symbol_table.at(*expansion.node2->identifier_);
+      matching.node_symbol_to_expansions[node2_sym].insert(expansion_ix);
+      // Add edge and node2 to all symbols
+      matching.expansion_symbols.insert(edge_sym);
+      matching.expansion_symbols.insert(node2_sym);
+    }
+    matching.expansions.push_back(expansion);
+  }
+  if (!edge_symbols.empty()) {
+    matching.edge_symbols.emplace_back(edge_symbols);
+  }
+  for (auto *const pattern : patterns) {
+    matching.filters.CollectPatternFilters(*pattern, symbol_table, storage);
+    if (pattern->identifier_->user_declared_) {
+      std::vector<Symbol> path_elements;
+      for (auto *const pattern_atom : pattern->atoms_)
+        path_elements.push_back(symbol_table.at(*pattern_atom->identifier_));
+      matching.named_paths.emplace(symbol_table.at(*pattern->identifier_), std::move(path_elements));
+    }
+  }
+  if (where) {
+    matching.filters.CollectWhereFilter(*where, symbol_table);
+  }
+}
+
+void AddMatching(const Match &match, SymbolTable &symbol_table, AstStorage &storage, Matching &matching) {
+  AddMatching(match.patterns_, match.where_, symbol_table, storage, matching);
+
+  // If there are any pattern filters, we add those as well
+  for (auto &filter : matching.filters) {
+    PatternFilterVisitor visitor(symbol_table, storage);
+
+    filter.expression->Accept(visitor);
+    filter.matchings = visitor.getMatchings();
+  }
+}
+
+void PatternFilterVisitor::Visit(Exists &op) {
+  std::vector<Pattern *> patterns;
+  patterns.push_back(op.pattern_);
+
+  FilterMatching filter_matching;
+  AddMatching(patterns, nullptr, symbol_table_, storage_, filter_matching);
+
+  filter_matching.type = PatternFilterType::EXISTS;
+  filter_matching.symbol = std::make_optional<Symbol>(symbol_table_.at(op));
+
+  matchings_.push_back(std::move(filter_matching));
+}
+
 static void ParseForeach(query::Foreach &foreach, SingleQueryPart &query_part, AstStorage &storage,
                          SymbolTable &symbol_table) {
   for (auto *clause : foreach.clauses_) {
@@ -560,6 +584,9 @@ std::vector<SingleQueryPart> CollectSingleQueryParts(SymbolTable &symbol_table,
       if (auto *merge = utils::Downcast<query::Merge>(clause)) {
         query_part->merge_matching.emplace_back(Matching{});
         AddMatching({merge->pattern_}, nullptr, symbol_table, storage, query_part->merge_matching.back());
+      } else if (auto *call_subquery = utils::Downcast<query::CallSubquery>(clause)) {
+        query_part->subqueries.emplace_back(
+            std::make_shared<QueryParts>(CollectQueryParts(symbol_table, storage, call_subquery->cypher_query_)));
       } else if (auto *foreach = utils::Downcast<query::Foreach>(clause)) {
         ParseForeach(*foreach, *query_part, storage, symbol_table);
       } else if (utils::IsSubtype(*clause, With::kType) || utils::IsSubtype(*clause, query::Unwind::kType) ||

src/query/plan/preprocess.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
@@ -70,7 +70,26 @@ class UsedSymbolsCollector : public HierarchicalTreeVisitor {
   }
 
   bool Visit(Identifier &ident) override {
-    symbols_.insert(symbol_table_.at(ident));
+    if (!in_exists || ident.user_declared_) {
+      symbols_.insert(symbol_table_.at(ident));
+    }
+
+    return true;
+  }
+
+  bool PreVisit(Exists &exists) override {
+    in_exists = true;
+
+    // We do not visit pattern identifier since we're in exists filter pattern
+    for (auto &atom : exists.pattern_->atoms_) {
+      atom->Accept(*this);
+    }
+
+    return false;
+  }
+
+  bool PostVisit(Exists & /*exists*/) override {
+    in_exists = false;
     return true;
   }
 
@@ -79,6 +98,9 @@ class UsedSymbolsCollector : public HierarchicalTreeVisitor {
 
   std::unordered_set<Symbol> symbols_;
   const SymbolTable &symbol_table_;
+
+ private:
+  bool in_exists{false};
 };
 
 /// Normalized representation of a pattern that needs to be matched.
@@ -99,6 +121,95 @@ struct Expansion {
   NodeAtom *node2 = nullptr;
 };
 
+struct FilterMatching;
+
+enum class PatternFilterType { EXISTS };
+
+/// Collects matchings from filters that include patterns
+class PatternFilterVisitor : public ExpressionVisitor<void> {
+ public:
+  explicit PatternFilterVisitor(SymbolTable &symbol_table, AstStorage &storage)
+      : symbol_table_(symbol_table), storage_(storage) {}
+
+  using ExpressionVisitor<void>::Visit;
+
+  // Unary operators
+  void Visit(NotOperator &op) override { op.expression_->Accept(*this); }
+  void Visit(IsNullOperator &op) override { op.expression_->Accept(*this); };
+  void Visit(UnaryPlusOperator &op) override{};
+  void Visit(UnaryMinusOperator &op) override{};
+
+  // Binary operators
+  void Visit(OrOperator &op) override {
+    op.expression1_->Accept(*this);
+    op.expression2_->Accept(*this);
+  }
+  void Visit(XorOperator &op) override {
+    op.expression1_->Accept(*this);
+    op.expression2_->Accept(*this);
+  }
+  void Visit(AndOperator &op) override {
+    op.expression1_->Accept(*this);
+    op.expression2_->Accept(*this);
+  }
+  void Visit(NotEqualOperator &op) override {
+    op.expression1_->Accept(*this);
+    op.expression2_->Accept(*this);
+  };
+  void Visit(EqualOperator &op) override {
+    op.expression1_->Accept(*this);
+    op.expression2_->Accept(*this);
+  };
+  void Visit(InListOperator &op) override {
+    op.expression1_->Accept(*this);
+    op.expression2_->Accept(*this);
+  };
+  void Visit(AdditionOperator &op) override{};
+  void Visit(SubtractionOperator &op) override{};
+  void Visit(MultiplicationOperator &op) override{};
+  void Visit(DivisionOperator &op) override{};
+  void Visit(ModOperator &op) override{};
+  void Visit(LessOperator &op) override{};
+  void Visit(GreaterOperator &op) override{};
+  void Visit(LessEqualOperator &op) override{};
+  void Visit(GreaterEqualOperator &op) override{};
+  void Visit(SubscriptOperator &op) override{};
+
+  // Other
+  void Visit(ListSlicingOperator &op) override{};
+  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{};
+  void Visit(Reduce &op) override{};
+  void Visit(Coalesce &op) override{};
+  void Visit(Extract &op) override{};
+  void Visit(Exists &op) override;
+  void Visit(All &op) override{};
+  void Visit(Single &op) override{};
+  void Visit(Any &op) override{};
+  void Visit(None &op) override{};
+  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{};
+
+  std::vector<FilterMatching> getMatchings() { return matchings_; }
+
+  SymbolTable &symbol_table_;
+  AstStorage &storage_;
+
+ private:
+  /// Collection of matchings in the filter expression being analyzed.
+  std::vector<FilterMatching> matchings_;
+};
+
 /// Stores the symbols and expression used to filter a property.
 class PropertyFilter {
  public:
@@ -153,7 +264,7 @@ struct FilterInfo {
   /// applied for labels or a property. Non generic types contain extra
   /// information which can be used to produce indexed scans of graph
   /// elements.
-  enum class Type { Generic, Label, Property, Id };
+  enum class Type { Generic, Label, Property, Id, Pattern };
 
   Type type;
   /// The original filter expression which must be satisfied.
@@ -166,6 +277,8 @@ struct FilterInfo {
   std::optional<PropertyFilter> property_filter;
   /// Information for Type::Id filtering.
   std::optional<IdFilter> id_filter;
+  /// Matchings for filters that include patterns
+  std::vector<FilterMatching> matchings;
 };
 
 /// Stores information on filters used inside the @c Matching of a @c QueryPart.
@@ -287,6 +400,16 @@ struct Matching {
   std::unordered_set<Symbol> expansion_symbols{};
 };
 
+// TODO clumsy to need to declare it before, usually only the struct definition would be in header
+struct QueryParts;
+
+struct FilterMatching : Matching {
+  /// Type of pattern filter
+  PatternFilterType type;
+  /// Symbol for the filter expression
+  std::optional<Symbol> symbol;
+};
+
 /// @brief Represents a read (+ write) part of a query. Parts are split on
 /// `WITH` clauses.
 ///
@@ -331,6 +454,9 @@ struct SingleQueryPart {
   std::vector<Matching> merge_matching{};
   /// @brief All the remaining clauses (without @c Match).
   std::vector<Clause *> remaining_clauses{};
+  /// The subqueries vector are all the subqueries in this query part ordered in a list by
+  /// the order of calling.
+  std::vector<std::shared_ptr<QueryParts>> subqueries{};
 };
 
 /// Holds query parts of a single query together with the optional information

src/query/plan/pretty_print.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
@@ -14,6 +14,7 @@
 
 #include "query/db_accessor.hpp"
 #include "query/frontend/ast/pretty_print.hpp"
+#include "query/plan/operator.hpp"
 #include "utils/string.hpp"
 
 namespace memgraph::query::plan {
@@ -148,7 +149,6 @@ bool PlanPrinter::PreVisit(query::plan::Produce &op) {
 }
 
 PRE_VISIT(ConstructNamedPath);
-PRE_VISIT(Filter);
 PRE_VISIT(SetProperty);
 PRE_VISIT(SetProperties);
 PRE_VISIT(SetLabels);
@@ -157,6 +157,7 @@ PRE_VISIT(RemoveLabels);
 PRE_VISIT(EdgeUniquenessFilter);
 PRE_VISIT(Accumulate);
 PRE_VISIT(EmptyResult);
+PRE_VISIT(EvaluatePatternFilter);
 
 bool PlanPrinter::PreVisit(query::plan::Aggregate &op) {
   WithPrintLn([&](auto &out) {
@@ -251,6 +252,22 @@ bool PlanPrinter::PreVisit(query::plan::Foreach &op) {
   op.input_->Accept(*this);
   return false;
 }
+
+bool PlanPrinter::PreVisit(query::plan::Filter &op) {
+  WithPrintLn([](auto &out) { out << "* Filter"; });
+  for (const auto &pattern_filter : op.pattern_filters_) {
+    Branch(*pattern_filter);
+  }
+  op.input_->Accept(*this);
+  return false;
+}
+
+bool PlanPrinter::PreVisit(query::plan::Apply &op) {
+  WithPrintLn([](auto &out) { out << "* Apply"; });
+  Branch(*op.subquery_);
+  op.input_->Accept(*this);
+  return false;
+}
 #undef PRE_VISIT
 
 bool PlanPrinter::DefaultPreVisit() {
@@ -589,6 +606,13 @@ bool PlanToJsonVisitor::PreVisit(Filter &op) {
   op.input_->Accept(*this);
   self["input"] = PopOutput();
 
+  for (auto pattern_idx = 0; pattern_idx < op.pattern_filters_.size(); pattern_idx++) {
+    auto pattern_filter_key = "pattern_filter" + std::to_string(pattern_idx + 1);
+
+    op.pattern_filters_[pattern_idx]->Accept(*this);
+    self[pattern_filter_key] = PopOutput();
+  }
+
   output_ = std::move(self);
   return false;
 }
@@ -908,6 +932,7 @@ bool PlanToJsonVisitor::PreVisit(Cartesian &op) {
   output_ = std::move(self);
   return false;
 }
+
 bool PlanToJsonVisitor::PreVisit(Foreach &op) {
   json self;
   self["name"] = "Foreach";
@@ -924,6 +949,32 @@ bool PlanToJsonVisitor::PreVisit(Foreach &op) {
   return false;
 }
 
+bool PlanToJsonVisitor::PreVisit(EvaluatePatternFilter &op) {
+  json self;
+  self["name"] = "EvaluatePatternFilter";
+  self["output_symbol"] = ToJson(op.output_symbol_);
+
+  op.input_->Accept(*this);
+  self["input"] = PopOutput();
+
+  output_ = std::move(self);
+  return false;
+}
+
+bool PlanToJsonVisitor::PreVisit(Apply &op) {
+  json self;
+  self["name"] = "Apply";
+
+  op.input_->Accept(*this);
+  self["input"] = PopOutput();
+
+  op.subquery_->Accept(*this);
+  self["subquery"] = PopOutput();
+
+  output_ = std::move(self);
+  return false;
+}
+
 }  // namespace impl
 
 }  // namespace memgraph::query::plan

src/query/plan/pretty_print.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
@@ -74,6 +74,7 @@ class PlanPrinter : public virtual HierarchicalLogicalOperatorVisitor {
   bool PreVisit(ConstructNamedPath &) override;
 
   bool PreVisit(Filter &) override;
+  bool PreVisit(EvaluatePatternFilter & /*unused*/) override;
   bool PreVisit(EdgeUniquenessFilter &) override;
 
   bool PreVisit(Merge &) override;
@@ -94,6 +95,7 @@ class PlanPrinter : public virtual HierarchicalLogicalOperatorVisitor {
   bool PreVisit(CallProcedure &) override;
   bool PreVisit(LoadCsv &) override;
   bool PreVisit(Foreach &) override;
+  bool PreVisit(Apply & /*unused*/) override;
 
   bool Visit(Once &) override;
 
@@ -186,8 +188,10 @@ class PlanToJsonVisitor : public virtual HierarchicalLogicalOperatorVisitor {
   bool PreVisit(Optional &) override;
 
   bool PreVisit(Filter &) override;
+  bool PreVisit(EvaluatePatternFilter & /*op*/) override;
   bool PreVisit(EdgeUniquenessFilter &) override;
   bool PreVisit(Cartesian &) override;
+  bool PreVisit(Apply & /*unused*/) override;
 
   bool PreVisit(ScanAll &) override;
   bool PreVisit(ScanAllByLabel &) override;

src/query/plan/rewrite/index_lookup.hpp

@@ -27,6 +27,7 @@
 
 #include "query/plan/operator.hpp"
 #include "query/plan/preprocess.hpp"
+#include "storage/v2/indices.hpp"
 
 DECLARE_int64(query_vertex_count_to_expand_existing);
 
@@ -454,6 +455,28 @@ class IndexLookupRewriter final : public HierarchicalLogicalOperatorVisitor {
     return true;
   }
 
+  bool PreVisit(EvaluatePatternFilter &op) override {
+    prev_ops_.push_back(&op);
+    return true;
+  }
+
+  bool PostVisit(EvaluatePatternFilter & /*op*/) override {
+    prev_ops_.pop_back();
+    return true;
+  }
+
+  bool PreVisit(Apply &op) override {
+    prev_ops_.push_back(&op);
+    op.input()->Accept(*this);
+    RewriteBranch(&op.subquery_);
+    return false;
+  }
+
+  bool PostVisit(Apply & /*op*/) override {
+    prev_ops_.pop_back();
+    return true;
+  }
+
   std::shared_ptr<LogicalOperator> new_root_;
 
  private:
@@ -472,6 +495,7 @@ class IndexLookupRewriter final : public HierarchicalLogicalOperatorVisitor {
     // FilterInfo with PropertyFilter.
     FilterInfo filter;
     int64_t vertex_count;
+    std::optional<storage::IndexStats> index_stats;
   };
 
   bool DefaultPreVisit() override { throw utils::NotYetImplemented("optimizing index lookup"); }
@@ -512,8 +536,11 @@ class IndexLookupRewriter final : public HierarchicalLogicalOperatorVisitor {
     return best_label;
   }
 
-  // Finds the label-property combination which has indexed the lowest amount of
-  // vertices. If the index cannot be found, nullopt is returned.
+  // Finds the label-property combination. The first criteria based on number of vertices indexed -> if one index has
+  // 10x less than the other one, always choose the smaller one. Otherwise, choose the index with smallest average group
+  // size based on key distribution. If average group size is equal, choose the index that has distribution closer to
+  // uniform distribution. Conditions based on average group size and key distribution can be only taken into account if
+  // the user has run `ANALYZE GRAPH` query before If the index cannot be found, nullopt is returned.
   std::optional<LabelPropertyIndex> FindBestLabelPropertyIndex(const Symbol &symbol,
                                                                const std::unordered_set<Symbol> &bound_symbols) {
     auto are_bound = [&bound_symbols](const auto &used_symbols) {
@@ -524,6 +551,31 @@ class IndexLookupRewriter final : public HierarchicalLogicalOperatorVisitor {
       }
       return true;
     };
+
+    /*
+     * Comparator function between two indices. If new index has >= 10x vertices than the existing, it cannot be better.
+     * If it is <= 10x in number of vertices, check average group size of property values. The index with smaller
+     * average group size is better. If the average group size is the same, choose the one closer to the uniform
+     * distribution
+     * @param found: Current best label-property index.
+     * @param new_stats: Label-property index candidate.
+     * @param vertex_count: New index's number of vertices.
+     * @return -1 if the new index is better, 0 if they are equal and 1 if the existing one is better.
+     */
+    auto compare_indices = [](std::optional<LabelPropertyIndex> &found, std::optional<storage::IndexStats> &new_stats,
+                              int vertex_count) {
+      if (!new_stats.has_value()) {
+        return 0;
+      }
+
+      if (vertex_count / 10.0 > found->vertex_count) {
+        return 1;
+      }
+      int cmp_avg_group = utils::CompareDecimal(new_stats->avg_group_size, found->index_stats->avg_group_size);
+      if (cmp_avg_group != 0) return cmp_avg_group;
+      return utils::CompareDecimal(new_stats->statistic, found->index_stats->statistic);
+    };
+
     std::optional<LabelPropertyIndex> found;
     for (const auto &label : filters_.FilteredLabels(symbol)) {
       for (const auto &filter : filters_.PropertyFilters(symbol)) {
@@ -538,7 +590,6 @@ class IndexLookupRewriter final : public HierarchicalLogicalOperatorVisitor {
         if (!db_->LabelPropertyIndexExists(GetLabel(label), GetProperty(property))) {
           continue;
         }
-        int64_t vertex_count = db_->VerticesCount(GetLabel(label), GetProperty(property));
         auto is_better_type = [&found](PropertyFilter::Type type) {
           // Order the types by the most preferred index lookup type.
           static const PropertyFilter::Type kFilterTypeOrder[] = {
@@ -547,17 +598,32 @@ class IndexLookupRewriter final : public HierarchicalLogicalOperatorVisitor {
           auto *type_sort_ix = std::find(kFilterTypeOrder, kFilterTypeOrder + 3, type);
           return type_sort_ix < found_sort_ix;
         };
-        if (!found || vertex_count < found->vertex_count ||
-            (vertex_count == found->vertex_count && is_better_type(filter.property_filter->type_))) {
-          found = LabelPropertyIndex{label, filter, vertex_count};
+
+        int64_t vertex_count = db_->VerticesCount(GetLabel(label), GetProperty(property));
+        std::optional<storage::IndexStats> new_stats = db_->GetIndexStats(GetLabel(label), GetProperty(property));
+
+        // Conditions, from more to less important:
+        // the index with 10x less vertices is better.
+        // the index with smaller average group size is better.
+        // the index with equal avg group size and distribution closer to the uniform is better.
+        // the index with less vertices is better.
+        // the index with same number of vertices but more optimized filter is better.
+        if (!found || vertex_count * 10 < found->vertex_count) {
+          found = LabelPropertyIndex{label, filter, vertex_count, new_stats};
+          continue;
+        }
+
+        if (int cmp_res = compare_indices(found, new_stats, vertex_count);
+            cmp_res == -1 ||
+            cmp_res == 0 && (found->vertex_count > vertex_count ||
+                             found->vertex_count == vertex_count && is_better_type(filter.property_filter->type_))) {
+          found = LabelPropertyIndex{label, filter, vertex_count, new_stats};
         }
       }
     }
     return found;
   }
-
-  // Creates a ScanAll by the best possible index for the `node_symbol`. Best
-  // index is defined as the index with least number of vertices. If the node
+  // Creates a ScanAll by the best possible index for the `node_symbol`. If the node
   // does not have at least a label, no indexed lookup can be created and
   // `nullptr` is returned. The operator is chained after `input`. Optional
   // `max_vertex_count` controls, whether no operator should be created if the

src/query/plan/rule_based_planner.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
@@ -25,15 +25,6 @@ namespace memgraph::query::plan {
 
 namespace {
 
-bool HasBoundFilterSymbols(const std::unordered_set<Symbol> &bound_symbols, const FilterInfo &filter) {
-  for (const auto &symbol : filter.used_symbols) {
-    if (bound_symbols.find(symbol) == bound_symbols.end()) {
-      return false;
-    }
-  }
-  return true;
-}
-
 // Ast tree visitor which collects the context for a return body.
 // The return body of WITH and RETURN clauses consists of:
 //
@@ -133,11 +124,18 @@ class ReturnBodyContext : public HierarchicalTreeVisitor {
 
   bool PostVisit(MapLiteral &map_literal) override {
     MG_ASSERT(map_literal.elements_.size() <= has_aggregation_.size(),
-              "Expected has_aggregation_ flags as much as there are map elements.");
+              "Expected as many has_aggregation_ flags as there are map elements.");
     PostVisitCollectionLiteral(map_literal, [](auto it) { return it->second; });
     return true;
   }
 
+  bool PostVisit(MapProjectionLiteral &map_projection_literal) override {
+    MG_ASSERT(map_projection_literal.elements_.size() <= has_aggregation_.size(),
+              "Expected as many has_aggregation_ flags as there are map elements.");
+    PostVisitCollectionLiteral(map_projection_literal, [](auto it) { return it->second; });
+    return true;
+  }
+
   bool PostVisit(All &all) override {
     // Remove the symbol which is bound by all, because we are only interested
     // in free (unbound) symbols.
@@ -495,7 +493,8 @@ std::unique_ptr<LogicalOperator> GenReturnBody(std::unique_ptr<LogicalOperator>
   // Where may see new symbols so it comes after we generate Produce and in
   // general, comes after any OrderBy, Skip or Limit.
   if (body.where()) {
-    last_op = std::make_unique<Filter>(std::move(last_op), body.where()->expression_);
+    last_op = std::make_unique<Filter>(std::move(last_op), std::vector<std::shared_ptr<LogicalOperator>>{},
+                                       body.where()->expression_);
   }
   return last_op;
 }
@@ -504,6 +503,12 @@ std::unique_ptr<LogicalOperator> GenReturnBody(std::unique_ptr<LogicalOperator>
 
 namespace impl {
 
+bool HasBoundFilterSymbols(const std::unordered_set<Symbol> &bound_symbols, const FilterInfo &filter) {
+  return std::ranges::all_of(
+      filter.used_symbols.begin(), filter.used_symbols.end(),
+      [&bound_symbols](const auto &symbol) { return bound_symbols.find(symbol) != bound_symbols.end(); });
+}
+
 Expression *ExtractFilters(const std::unordered_set<Symbol> &bound_symbols, Filters &filters, AstStorage &storage) {
   Expression *filter_expr = nullptr;
   for (auto filters_it = filters.begin(); filters_it != filters.end();) {
@@ -517,14 +522,20 @@ Expression *ExtractFilters(const std::unordered_set<Symbol> &bound_symbols, Filt
   return filter_expr;
 }
 
-std::unique_ptr<LogicalOperator> GenFilters(std::unique_ptr<LogicalOperator> last_op,
-                                            const std::unordered_set<Symbol> &bound_symbols, Filters &filters,
-                                            AstStorage &storage) {
-  auto *filter_expr = ExtractFilters(bound_symbols, filters, storage);
-  if (filter_expr) {
-    last_op = std::make_unique<Filter>(std::move(last_op), filter_expr);
+std::unordered_set<Symbol> GetSubqueryBoundSymbols(const std::vector<SingleQueryPart> &single_query_parts,
+                                                   SymbolTable &symbol_table, AstStorage &storage) {
+  const auto &query = single_query_parts[0];
+
+  if (!query.matching.expansions.empty() || query.remaining_clauses.empty()) {
+    return {};
   }
-  return last_op;
+
+  if (std::unordered_set<Symbol> bound_symbols; auto *with = utils::Downcast<query::With>(query.remaining_clauses[0])) {
+    auto input_op = impl::GenWith(*with, nullptr, symbol_table, false, bound_symbols, storage);
+    return bound_symbols;
+  }
+
+  return {};
 }
 
 std::unique_ptr<LogicalOperator> GenNamedPaths(std::unique_ptr<LogicalOperator> last_op,

src/query/plan/rule_based_planner.hpp

@@ -49,6 +49,7 @@ struct PlanningContext {
   /// write) the first `n`, but the latter `n` would only read the already
   /// written information.
   std::unordered_set<Symbol> bound_symbols{};
+  bool is_write_query{false};
 };
 
 template <class TDbAccessor>
@@ -81,8 +82,13 @@ namespace impl {
 // removed from `Filters`.
 Expression *ExtractFilters(const std::unordered_set<Symbol> &, Filters &, AstStorage &);
 
-std::unique_ptr<LogicalOperator> GenFilters(std::unique_ptr<LogicalOperator>, const std::unordered_set<Symbol> &,
-                                            Filters &, AstStorage &);
+/// Checks if the filters has all the bound symbols to be included in the current part of the query
+bool HasBoundFilterSymbols(const std::unordered_set<Symbol> &bound_symbols, const FilterInfo &filter);
+
+// Returns the set of symbols for the subquery that are actually referenced from the outer scope and
+// used in the subquery.
+std::unordered_set<Symbol> GetSubqueryBoundSymbols(const std::vector<SingleQueryPart> &single_query_parts,
+                                                   SymbolTable &symbol_table, AstStorage &storage);
 
 /// Utility function for iterating pattern atoms and accumulating a result.
 ///
@@ -164,86 +170,96 @@ class RuleBasedPlanner {
   /// tree.
   using PlanResult = std::unique_ptr<LogicalOperator>;
   /// @brief Generates the operator tree based on explicitly set rules.
-  PlanResult Plan(const std::vector<SingleQueryPart> &query_parts) {
+  PlanResult Plan(const QueryParts &query_parts) {
     auto &context = *context_;
-    std::unique_ptr<LogicalOperator> input_op;
-    // Set to true if a query command writes to the database.
-    bool is_write = false;
-    for (const auto &query_part : query_parts) {
-      MatchContext match_ctx{query_part.matching, *context.symbol_table, context.bound_symbols};
-      input_op = PlanMatching(match_ctx, std::move(input_op));
-      for (const auto &matching : query_part.optional_matching) {
-        MatchContext opt_ctx{matching, *context.symbol_table, context.bound_symbols};
+    std::unique_ptr<LogicalOperator> final_plan;
 
-        std::vector<Symbol> bound_symbols(context_->bound_symbols.begin(), context_->bound_symbols.end());
-        auto once_with_symbols = std::make_unique<Once>(bound_symbols);
+    for (const auto &query_part : query_parts.query_parts) {
+      std::unique_ptr<LogicalOperator> input_op;
 
-        auto match_op = PlanMatching(opt_ctx, std::move(once_with_symbols));
-        if (match_op) {
-          input_op = std::make_unique<Optional>(std::move(input_op), std::move(match_op), opt_ctx.new_symbols);
-        }
-      }
-      uint64_t merge_id = 0;
-      for (const auto &clause : query_part.remaining_clauses) {
-        MG_ASSERT(!utils::IsSubtype(*clause, Match::kType), "Unexpected Match in remaining clauses");
-        if (auto *ret = utils::Downcast<Return>(clause)) {
-          input_op = impl::GenReturn(*ret, std::move(input_op), *context.symbol_table, is_write, context.bound_symbols,
-                                     *context.ast_storage);
-        } else if (auto *merge = utils::Downcast<query::Merge>(clause)) {
-          input_op = GenMerge(*merge, std::move(input_op), query_part.merge_matching[merge_id++]);
-          // Treat MERGE clause as write, because we do not know if it will
-          // create anything.
-          is_write = true;
-        } else if (auto *with = utils::Downcast<query::With>(clause)) {
-          input_op = impl::GenWith(*with, std::move(input_op), *context.symbol_table, is_write, context.bound_symbols,
-                                   *context.ast_storage);
-          // WITH clause advances the command, so reset the flag.
-          is_write = false;
-        } else if (auto op = HandleWriteClause(clause, input_op, *context.symbol_table, context.bound_symbols)) {
-          is_write = true;
-          input_op = std::move(op);
-        } else if (auto *unwind = utils::Downcast<query::Unwind>(clause)) {
-          const auto &symbol = context.symbol_table->at(*unwind->named_expression_);
-          context.bound_symbols.insert(symbol);
-          input_op =
-              std::make_unique<plan::Unwind>(std::move(input_op), unwind->named_expression_->expression_, symbol);
+      context.is_write_query = false;
+      for (const auto &single_query_part : query_part.single_query_parts) {
+        input_op = HandleMatching(std::move(input_op), single_query_part, *context.symbol_table, context.bound_symbols);
 
-        } else if (auto *call_proc = utils::Downcast<query::CallProcedure>(clause)) {
-          std::vector<Symbol> result_symbols;
-          result_symbols.reserve(call_proc->result_identifiers_.size());
-          for (const auto *ident : call_proc->result_identifiers_) {
-            const auto &sym = context.symbol_table->at(*ident);
-            context.bound_symbols.insert(sym);
-            result_symbols.push_back(sym);
+        uint64_t merge_id = 0;
+        uint64_t subquery_id = 0;
+
+        for (const auto &clause : single_query_part.remaining_clauses) {
+          MG_ASSERT(!utils::IsSubtype(*clause, Match::kType), "Unexpected Match in remaining clauses");
+          if (auto *ret = utils::Downcast<Return>(clause)) {
+            input_op = impl::GenReturn(*ret, std::move(input_op), *context.symbol_table, context.is_write_query,
+                                       context.bound_symbols, *context.ast_storage);
+          } else if (auto *merge = utils::Downcast<query::Merge>(clause)) {
+            input_op = GenMerge(*merge, std::move(input_op), single_query_part.merge_matching[merge_id++]);
+            // Treat MERGE clause as write, because we do not know if it will
+            // create anything.
+            context.is_write_query = true;
+          } else if (auto *with = utils::Downcast<query::With>(clause)) {
+            input_op = impl::GenWith(*with, std::move(input_op), *context.symbol_table, context.is_write_query,
+                                     context.bound_symbols, *context.ast_storage);
+            // WITH clause advances the command, so reset the flag.
+            context.is_write_query = false;
+          } else if (auto op = HandleWriteClause(clause, input_op, *context.symbol_table, context.bound_symbols)) {
+            context.is_write_query = true;
+            input_op = std::move(op);
+          } else if (auto *unwind = utils::Downcast<query::Unwind>(clause)) {
+            const auto &symbol = context.symbol_table->at(*unwind->named_expression_);
+            context.bound_symbols.insert(symbol);
+            input_op =
+                std::make_unique<plan::Unwind>(std::move(input_op), unwind->named_expression_->expression_, symbol);
+
+          } else if (auto *call_proc = utils::Downcast<query::CallProcedure>(clause)) {
+            std::vector<Symbol> result_symbols;
+            result_symbols.reserve(call_proc->result_identifiers_.size());
+            for (const auto *ident : call_proc->result_identifiers_) {
+              const auto &sym = context.symbol_table->at(*ident);
+              context.bound_symbols.insert(sym);
+              result_symbols.push_back(sym);
+            }
+            // TODO: When we add support for write and eager procedures, we will
+            // need to plan this operator with Accumulate and pass in
+            // storage::View::NEW.
+            input_op = std::make_unique<plan::CallProcedure>(
+                std::move(input_op), call_proc->procedure_name_, call_proc->arguments_, call_proc->result_fields_,
+                result_symbols, call_proc->memory_limit_, call_proc->memory_scale_, call_proc->is_write_);
+          } else if (auto *load_csv = utils::Downcast<query::LoadCsv>(clause)) {
+            const auto &row_sym = context.symbol_table->at(*load_csv->row_var_);
+            context.bound_symbols.insert(row_sym);
+
+            input_op =
+                std::make_unique<plan::LoadCsv>(std::move(input_op), load_csv->file_, load_csv->with_header_,
+                                                load_csv->ignore_bad_, load_csv->delimiter_, load_csv->quote_, row_sym);
+
+          } else if (auto *foreach = utils::Downcast<query::Foreach>(clause)) {
+            context.is_write_query = true;
+            input_op = HandleForeachClause(foreach, std::move(input_op), *context.symbol_table, context.bound_symbols,
+                                           single_query_part, merge_id);
+          } else if (auto *call_sub = utils::Downcast<query::CallSubquery>(clause)) {
+            input_op = HandleSubquery(std::move(input_op), single_query_part.subqueries[subquery_id++],
+                                      *context.symbol_table, *context_->ast_storage);
+          } else {
+            throw utils::NotYetImplemented("clause '{}' conversion to operator(s)", clause->GetTypeInfo().name);
           }
-          // TODO: When we add support for write and eager procedures, we will
-          // need to plan this operator with Accumulate and pass in
-          // storage::View::NEW.
-          input_op = std::make_unique<plan::CallProcedure>(
-              std::move(input_op), call_proc->procedure_name_, call_proc->arguments_, call_proc->result_fields_,
-              result_symbols, call_proc->memory_limit_, call_proc->memory_scale_, call_proc->is_write_);
-        } else if (auto *load_csv = utils::Downcast<query::LoadCsv>(clause)) {
-          const auto &row_sym = context.symbol_table->at(*load_csv->row_var_);
-          context.bound_symbols.insert(row_sym);
-
-          input_op =
-              std::make_unique<plan::LoadCsv>(std::move(input_op), load_csv->file_, load_csv->with_header_,
-                                              load_csv->ignore_bad_, load_csv->delimiter_, load_csv->quote_, row_sym);
-
-        } else if (auto *foreach = utils::Downcast<query::Foreach>(clause)) {
-          is_write = true;
-          input_op = HandleForeachClause(foreach, std::move(input_op), *context.symbol_table, context.bound_symbols,
-                                         query_part, merge_id);
-        } else {
-          throw utils::NotYetImplemented("clause '{}' conversion to operator(s)", clause->GetTypeInfo().name);
         }
       }
+
+      // Is this the only situation that should be covered
+      if (input_op->OutputSymbols(*context.symbol_table).empty()) {
+        input_op = std::make_unique<EmptyResult>(std::move(input_op));
+      }
+
+      if (query_part.query_combinator) {
+        final_plan = MergeWithCombinator(std::move(input_op), std::move(final_plan), *query_part.query_combinator);
+      } else {
+        final_plan = std::move(input_op);
+      }
     }
-    // Is this the only situation that should be covered
-    if (input_op->OutputSymbols(*context.symbol_table).empty()) {
-      input_op = std::make_unique<EmptyResult>(std::move(input_op));
+
+    if (query_parts.distinct) {
+      final_plan = MakeDistinct(std::move(final_plan));
     }
-    return input_op;
+
+    return final_plan;
   }
 
  private:
@@ -255,6 +271,26 @@ class RuleBasedPlanner {
 
   storage::EdgeTypeId GetEdgeType(EdgeTypeIx edge_type) { return context_->db->NameToEdgeType(edge_type.name); }
 
+  std::unique_ptr<LogicalOperator> HandleMatching(std::unique_ptr<LogicalOperator> last_op,
+                                                  const SingleQueryPart &single_query_part, SymbolTable &symbol_table,
+                                                  std::unordered_set<Symbol> &bound_symbols) {
+    MatchContext match_ctx{single_query_part.matching, symbol_table, bound_symbols};
+    last_op = PlanMatching(match_ctx, std::move(last_op));
+    for (const auto &matching : single_query_part.optional_matching) {
+      MatchContext opt_ctx{matching, symbol_table, bound_symbols};
+
+      std::vector<Symbol> bound_symbols(context_->bound_symbols.begin(), context_->bound_symbols.end());
+      auto once_with_symbols = std::make_unique<Once>(bound_symbols);
+
+      auto match_op = PlanMatching(opt_ctx, std::move(once_with_symbols));
+      if (match_op) {
+        last_op = std::make_unique<Optional>(std::move(last_op), std::move(match_op), opt_ctx.new_symbols);
+      }
+    }
+
+    return last_op;
+  }
+
   std::unique_ptr<LogicalOperator> GenCreate(Create &create, std::unique_ptr<LogicalOperator> input_op,
                                              const SymbolTable &symbol_table,
                                              std::unordered_set<Symbol> &bound_symbols) {
@@ -398,119 +434,11 @@ class RuleBasedPlanner {
     // Try to generate any filters even before the 1st match operator. This
     // optimizes the optional match which filters only on symbols bound in
     // regular match.
-    auto last_op = impl::GenFilters(std::move(input_op), bound_symbols, filters, storage);
-    for (const auto &expansion : matching.expansions) {
-      const auto &node1_symbol = symbol_table.at(*expansion.node1->identifier_);
-      if (bound_symbols.insert(node1_symbol).second) {
-        // We have just bound this symbol, so generate ScanAll which fills it.
-        last_op = std::make_unique<ScanAll>(std::move(last_op), node1_symbol, match_context.view);
-        match_context.new_symbols.emplace_back(node1_symbol);
-        last_op = impl::GenFilters(std::move(last_op), bound_symbols, filters, storage);
-        last_op = impl::GenNamedPaths(std::move(last_op), bound_symbols, named_paths);
-        last_op = impl::GenFilters(std::move(last_op), bound_symbols, filters, storage);
-      }
-      // We have an edge, so generate Expand.
-      if (expansion.edge) {
-        auto *edge = expansion.edge;
-        // If the expand symbols were already bound, then we need to indicate
-        // that they exist. The Expand will then check whether the pattern holds
-        // instead of writing the expansion to symbols.
-        const auto &node_symbol = symbol_table.at(*expansion.node2->identifier_);
-        auto existing_node = utils::Contains(bound_symbols, node_symbol);
-        const auto &edge_symbol = symbol_table.at(*edge->identifier_);
-        MG_ASSERT(!utils::Contains(bound_symbols, edge_symbol), "Existing edges are not supported");
-        std::vector<storage::EdgeTypeId> edge_types;
-        edge_types.reserve(edge->edge_types_.size());
-        for (const auto &type : edge->edge_types_) {
-          edge_types.push_back(GetEdgeType(type));
-        }
-        if (edge->IsVariable()) {
-          std::optional<ExpansionLambda> weight_lambda;
-          std::optional<Symbol> total_weight;
+    auto last_op = GenFilters(std::move(input_op), bound_symbols, filters, storage, symbol_table);
 
-          if (edge->type_ == EdgeAtom::Type::WEIGHTED_SHORTEST_PATH ||
-              edge->type_ == EdgeAtom::Type::ALL_SHORTEST_PATHS) {
-            weight_lambda.emplace(ExpansionLambda{symbol_table.at(*edge->weight_lambda_.inner_edge),
-                                                  symbol_table.at(*edge->weight_lambda_.inner_node),
-                                                  edge->weight_lambda_.expression});
+    last_op = HandleExpansion(std::move(last_op), matching, symbol_table, storage, bound_symbols,
+                              match_context.new_symbols, named_paths, filters, match_context.view);
 
-            total_weight.emplace(symbol_table.at(*edge->total_weight_));
-          }
-
-          ExpansionLambda filter_lambda;
-          filter_lambda.inner_edge_symbol = symbol_table.at(*edge->filter_lambda_.inner_edge);
-          filter_lambda.inner_node_symbol = symbol_table.at(*edge->filter_lambda_.inner_node);
-          {
-            // Bind the inner edge and node symbols so they're available for
-            // inline filtering in ExpandVariable.
-            bool inner_edge_bound = bound_symbols.insert(filter_lambda.inner_edge_symbol).second;
-            bool inner_node_bound = bound_symbols.insert(filter_lambda.inner_node_symbol).second;
-            MG_ASSERT(inner_edge_bound && inner_node_bound, "An inner edge and node can't be bound from before");
-          }
-          // Join regular filters with lambda filter expression, so that they
-          // are done inline together. Semantic analysis should guarantee that
-          // lambda filtering uses bound symbols.
-          filter_lambda.expression = impl::BoolJoin<AndOperator>(
-              storage, impl::ExtractFilters(bound_symbols, filters, storage), edge->filter_lambda_.expression);
-          // At this point it's possible we have leftover filters for inline
-          // filtering (they use the inner symbols. If they were not collected,
-          // we have to remove them manually because no other filter-extraction
-          // will ever bind them again.
-          filters.erase(std::remove_if(
-                            filters.begin(), filters.end(),
-                            [e = filter_lambda.inner_edge_symbol, n = filter_lambda.inner_node_symbol](FilterInfo &fi) {
-                              return utils::Contains(fi.used_symbols, e) || utils::Contains(fi.used_symbols, n);
-                            }),
-                        filters.end());
-          // Unbind the temporarily bound inner symbols for filtering.
-          bound_symbols.erase(filter_lambda.inner_edge_symbol);
-          bound_symbols.erase(filter_lambda.inner_node_symbol);
-
-          if (total_weight) {
-            bound_symbols.insert(*total_weight);
-          }
-
-          // TODO: Pass weight lambda.
-          MG_ASSERT(match_context.view == storage::View::OLD,
-                    "ExpandVariable should only be planned with storage::View::OLD");
-          last_op = std::make_unique<ExpandVariable>(std::move(last_op), node1_symbol, node_symbol, edge_symbol,
-                                                     edge->type_, expansion.direction, edge_types, expansion.is_flipped,
-                                                     edge->lower_bound_, edge->upper_bound_, existing_node,
-                                                     filter_lambda, weight_lambda, total_weight);
-        } else {
-          last_op = std::make_unique<Expand>(std::move(last_op), node1_symbol, node_symbol, edge_symbol,
-                                             expansion.direction, edge_types, existing_node, match_context.view);
-        }
-
-        // Bind the expanded edge and node.
-        bound_symbols.insert(edge_symbol);
-        match_context.new_symbols.emplace_back(edge_symbol);
-        if (bound_symbols.insert(node_symbol).second) {
-          match_context.new_symbols.emplace_back(node_symbol);
-        }
-
-        // Ensure Cyphermorphism (different edge symbols always map to
-        // different edges).
-        for (const auto &edge_symbols : matching.edge_symbols) {
-          if (edge_symbols.find(edge_symbol) == edge_symbols.end()) {
-            continue;
-          }
-          std::vector<Symbol> other_symbols;
-          for (const auto &symbol : edge_symbols) {
-            if (symbol == edge_symbol || bound_symbols.find(symbol) == bound_symbols.end()) {
-              continue;
-            }
-            other_symbols.push_back(symbol);
-          }
-          if (!other_symbols.empty()) {
-            last_op = std::make_unique<EdgeUniquenessFilter>(std::move(last_op), edge_symbol, other_symbols);
-          }
-        }
-        last_op = impl::GenFilters(std::move(last_op), bound_symbols, filters, storage);
-        last_op = impl::GenNamedPaths(std::move(last_op), bound_symbols, named_paths);
-        last_op = impl::GenFilters(std::move(last_op), bound_symbols, filters, storage);
-      }
-    }
     MG_ASSERT(named_paths.empty(), "Expected to generate all named paths");
     // We bound all named path symbols, so just add them to new_symbols.
     for (const auto &named_path : matching.named_paths) {
@@ -547,6 +475,143 @@ class RuleBasedPlanner {
     return std::make_unique<plan::Merge>(std::move(input_op), std::move(on_match), std::move(on_create));
   }
 
+  std::unique_ptr<LogicalOperator> HandleExpansion(std::unique_ptr<LogicalOperator> last_op, const Matching &matching,
+                                                   const SymbolTable &symbol_table, AstStorage &storage,
+                                                   std::unordered_set<Symbol> &bound_symbols,
+                                                   std::vector<Symbol> &new_symbols,
+                                                   std::unordered_map<Symbol, std::vector<Symbol>> &named_paths,
+                                                   Filters &filters, storage::View view) {
+    for (const auto &expansion : matching.expansions) {
+      const auto &node1_symbol = symbol_table.at(*expansion.node1->identifier_);
+      if (bound_symbols.insert(node1_symbol).second) {
+        // We have just bound this symbol, so generate ScanAll which fills it.
+        last_op = std::make_unique<ScanAll>(std::move(last_op), node1_symbol, view);
+        new_symbols.emplace_back(node1_symbol);
+
+        last_op = GenFilters(std::move(last_op), bound_symbols, filters, storage, symbol_table);
+        last_op = impl::GenNamedPaths(std::move(last_op), bound_symbols, named_paths);
+        last_op = GenFilters(std::move(last_op), bound_symbols, filters, storage, symbol_table);
+      }
+
+      if (expansion.edge) {
+        last_op = GenExpand(std::move(last_op), expansion, symbol_table, bound_symbols, matching, storage, filters,
+                            named_paths, new_symbols, view);
+      }
+    }
+
+    return last_op;
+  }
+
+  std::unique_ptr<LogicalOperator> GenExpand(std::unique_ptr<LogicalOperator> last_op, const Expansion &expansion,
+                                             const SymbolTable &symbol_table, std::unordered_set<Symbol> &bound_symbols,
+                                             const Matching &matching, AstStorage &storage, Filters &filters,
+                                             std::unordered_map<Symbol, std::vector<Symbol>> &named_paths,
+                                             std::vector<Symbol> &new_symbols, storage::View view) {
+    // If the expand symbols were already bound, then we need to indicate
+    // that they exist. The Expand will then check whether the pattern holds
+    // instead of writing the expansion to symbols.
+    const auto &node1_symbol = symbol_table.at(*expansion.node1->identifier_);
+    bound_symbols.insert(node1_symbol);
+
+    const auto &node_symbol = symbol_table.at(*expansion.node2->identifier_);
+    auto *edge = expansion.edge;
+
+    auto existing_node = utils::Contains(bound_symbols, node_symbol);
+    const auto &edge_symbol = symbol_table.at(*edge->identifier_);
+    MG_ASSERT(!utils::Contains(bound_symbols, edge_symbol), "Existing edges are not supported");
+    std::vector<storage::EdgeTypeId> edge_types;
+    edge_types.reserve(edge->edge_types_.size());
+    for (const auto &type : edge->edge_types_) {
+      edge_types.push_back(GetEdgeType(type));
+    }
+    if (edge->IsVariable()) {
+      std::optional<ExpansionLambda> weight_lambda;
+      std::optional<Symbol> total_weight;
+
+      if (edge->type_ == EdgeAtom::Type::WEIGHTED_SHORTEST_PATH || edge->type_ == EdgeAtom::Type::ALL_SHORTEST_PATHS) {
+        weight_lambda.emplace(ExpansionLambda{symbol_table.at(*edge->weight_lambda_.inner_edge),
+                                              symbol_table.at(*edge->weight_lambda_.inner_node),
+                                              edge->weight_lambda_.expression});
+
+        total_weight.emplace(symbol_table.at(*edge->total_weight_));
+      }
+
+      ExpansionLambda filter_lambda;
+      filter_lambda.inner_edge_symbol = symbol_table.at(*edge->filter_lambda_.inner_edge);
+      filter_lambda.inner_node_symbol = symbol_table.at(*edge->filter_lambda_.inner_node);
+      {
+        // Bind the inner edge and node symbols so they're available for
+        // inline filtering in ExpandVariable.
+        bool inner_edge_bound = bound_symbols.insert(filter_lambda.inner_edge_symbol).second;
+        bool inner_node_bound = bound_symbols.insert(filter_lambda.inner_node_symbol).second;
+        MG_ASSERT(inner_edge_bound && inner_node_bound, "An inner edge and node can't be bound from before");
+      }
+      // Join regular filters with lambda filter expression, so that they
+      // are done inline together. Semantic analysis should guarantee that
+      // lambda filtering uses bound symbols.
+      filter_lambda.expression = impl::BoolJoin<AndOperator>(
+          storage, impl::ExtractFilters(bound_symbols, filters, storage), edge->filter_lambda_.expression);
+      // At this point it's possible we have leftover filters for inline
+      // filtering (they use the inner symbols. If they were not collected,
+      // we have to remove them manually because no other filter-extraction
+      // will ever bind them again.
+      filters.erase(
+          std::remove_if(filters.begin(), filters.end(),
+                         [e = filter_lambda.inner_edge_symbol, n = filter_lambda.inner_node_symbol](FilterInfo &fi) {
+                           return utils::Contains(fi.used_symbols, e) || utils::Contains(fi.used_symbols, n);
+                         }),
+          filters.end());
+      // Unbind the temporarily bound inner symbols for filtering.
+      bound_symbols.erase(filter_lambda.inner_edge_symbol);
+      bound_symbols.erase(filter_lambda.inner_node_symbol);
+
+      if (total_weight) {
+        bound_symbols.insert(*total_weight);
+      }
+
+      // TODO: Pass weight lambda.
+      MG_ASSERT(view == storage::View::OLD, "ExpandVariable should only be planned with storage::View::OLD");
+      last_op = std::make_unique<ExpandVariable>(std::move(last_op), node1_symbol, node_symbol, edge_symbol,
+                                                 edge->type_, expansion.direction, edge_types, expansion.is_flipped,
+                                                 edge->lower_bound_, edge->upper_bound_, existing_node, filter_lambda,
+                                                 weight_lambda, total_weight);
+    } else {
+      last_op = std::make_unique<Expand>(std::move(last_op), node1_symbol, node_symbol, edge_symbol,
+                                         expansion.direction, edge_types, existing_node, view);
+    }
+
+    // Bind the expanded edge and node.
+    bound_symbols.insert(edge_symbol);
+    new_symbols.emplace_back(edge_symbol);
+    if (bound_symbols.insert(node_symbol).second) {
+      new_symbols.emplace_back(node_symbol);
+    }
+
+    // Ensure Cyphermorphism (different edge symbols always map to
+    // different edges).
+    for (const auto &edge_symbols : matching.edge_symbols) {
+      if (edge_symbols.find(edge_symbol) == edge_symbols.end()) {
+        continue;
+      }
+      std::vector<Symbol> other_symbols;
+      for (const auto &symbol : edge_symbols) {
+        if (symbol == edge_symbol || bound_symbols.find(symbol) == bound_symbols.end()) {
+          continue;
+        }
+        other_symbols.push_back(symbol);
+      }
+      if (!other_symbols.empty()) {
+        last_op = std::make_unique<EdgeUniquenessFilter>(std::move(last_op), edge_symbol, other_symbols);
+      }
+    }
+
+    last_op = GenFilters(std::move(last_op), bound_symbols, filters, storage, symbol_table);
+    last_op = impl::GenNamedPaths(std::move(last_op), bound_symbols, named_paths);
+    last_op = GenFilters(std::move(last_op), bound_symbols, filters, storage, symbol_table);
+
+    return last_op;
+  }
+
   std::unique_ptr<LogicalOperator> HandleForeachClause(query::Foreach *foreach,
                                                        std::unique_ptr<LogicalOperator> input_op,
                                                        const SymbolTable &symbol_table,
@@ -567,6 +632,108 @@ class RuleBasedPlanner {
     return std::make_unique<plan::Foreach>(std::move(input_op), std::move(op), foreach->named_expression_->expression_,
                                            symbol);
   }
+
+  std::unique_ptr<LogicalOperator> HandleSubquery(std::unique_ptr<LogicalOperator> last_op,
+                                                  std::shared_ptr<QueryParts> subquery, SymbolTable &symbol_table,
+                                                  AstStorage &storage) {
+    std::unordered_set<Symbol> outer_scope_bound_symbols;
+    outer_scope_bound_symbols.insert(std::make_move_iterator(context_->bound_symbols.begin()),
+                                     std::make_move_iterator(context_->bound_symbols.end()));
+
+    context_->bound_symbols =
+        impl::GetSubqueryBoundSymbols(subquery->query_parts[0].single_query_parts, symbol_table, storage);
+
+    auto subquery_op = Plan(*subquery);
+
+    context_->bound_symbols.clear();
+    context_->bound_symbols.insert(std::make_move_iterator(outer_scope_bound_symbols.begin()),
+                                   std::make_move_iterator(outer_scope_bound_symbols.end()));
+
+    auto subquery_has_return = true;
+    if (subquery_op->GetTypeInfo() == EmptyResult::kType) {
+      subquery_has_return = false;
+    }
+
+    last_op = std::make_unique<Apply>(std::move(last_op), std::move(subquery_op), subquery_has_return);
+
+    if (context_->is_write_query) {
+      last_op = std::make_unique<Accumulate>(std::move(last_op), last_op->ModifiedSymbols(symbol_table), true);
+    }
+
+    return last_op;
+  }
+
+  std::unique_ptr<LogicalOperator> GenFilters(std::unique_ptr<LogicalOperator> last_op,
+                                              const std::unordered_set<Symbol> &bound_symbols, Filters &filters,
+                                              AstStorage &storage, const SymbolTable &symbol_table) {
+    auto pattern_filters = ExtractPatternFilters(filters, symbol_table, storage, bound_symbols);
+    auto *filter_expr = impl::ExtractFilters(bound_symbols, filters, storage);
+
+    if (filter_expr) {
+      last_op = std::make_unique<Filter>(std::move(last_op), std::move(pattern_filters), filter_expr);
+    }
+    return last_op;
+  }
+
+  std::unique_ptr<LogicalOperator> MakeExistsFilter(const FilterMatching &matching, const SymbolTable &symbol_table,
+                                                    AstStorage &storage,
+                                                    const std::unordered_set<Symbol> &bound_symbols) {
+    std::vector<Symbol> once_symbols(bound_symbols.begin(), bound_symbols.end());
+    std::unique_ptr<LogicalOperator> last_op = std::make_unique<Once>(once_symbols);
+
+    std::vector<Symbol> new_symbols;
+    std::unordered_set<Symbol> expand_symbols(bound_symbols.begin(), bound_symbols.end());
+
+    auto filters = matching.filters;
+
+    std::unordered_map<Symbol, std::vector<Symbol>> named_paths;
+
+    last_op = HandleExpansion(std::move(last_op), matching, symbol_table, storage, expand_symbols, new_symbols,
+                              named_paths, filters, storage::View::OLD);
+
+    last_op = std::make_unique<Limit>(std::move(last_op), storage.Create<PrimitiveLiteral>(1));
+
+    last_op = std::make_unique<EvaluatePatternFilter>(std::move(last_op), matching.symbol.value());
+
+    return last_op;
+  }
+
+  std::vector<std::shared_ptr<LogicalOperator>> ExtractPatternFilters(Filters &filters, const SymbolTable &symbol_table,
+                                                                      AstStorage &storage,
+                                                                      const std::unordered_set<Symbol> &bound_symbols) {
+    std::vector<std::shared_ptr<LogicalOperator>> operators;
+
+    for (const auto &filter : filters) {
+      for (const auto &matching : filter.matchings) {
+        if (!impl::HasBoundFilterSymbols(bound_symbols, filter)) {
+          continue;
+        }
+
+        switch (matching.type) {
+          case PatternFilterType::EXISTS: {
+            operators.push_back(MakeExistsFilter(matching, symbol_table, storage, bound_symbols));
+            break;
+          }
+        }
+      }
+    }
+
+    return operators;
+  }
+
+  std::unique_ptr<LogicalOperator> MergeWithCombinator(std::unique_ptr<LogicalOperator> curr_op,
+                                                       std::unique_ptr<LogicalOperator> last_op,
+                                                       const Tree &combinator) {
+    if (const auto *union_ = utils::Downcast<const CypherUnion>(&combinator)) {
+      return impl::GenUnion(*union_, std::move(last_op), std::move(curr_op), *context_->symbol_table);
+    }
+
+    throw utils::NotYetImplemented("This type of merging queries is not yet implemented!");
+  }
+
+  std::unique_ptr<LogicalOperator> MakeDistinct(std::unique_ptr<LogicalOperator> last_op) {
+    return std::make_unique<Distinct>(std::move(last_op), last_op->OutputSymbols(*context_->symbol_table));
+  }
 };
 
 }  // namespace memgraph::query::plan

src/query/plan/variable_start_planner.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
@@ -155,6 +155,18 @@ auto ExpansionNodes(const std::vector<Expansion> &expansions, const SymbolTable
   return nodes;
 }
 
+FilterMatching ToFilterMatching(Matching &matching) {
+  FilterMatching filter_matching;
+  filter_matching.expansions = matching.expansions;
+  filter_matching.edge_symbols = matching.edge_symbols;
+  filter_matching.filters = matching.filters;
+  filter_matching.node_symbol_to_expansions = matching.node_symbol_to_expansions;
+  filter_matching.named_paths = matching.named_paths;
+  filter_matching.expansion_symbols = matching.expansion_symbols;
+
+  return filter_matching;
+}
+
 }  // namespace
 
 VaryMatchingStart::VaryMatchingStart(Matching matching, const SymbolTable &symbol_table)
@@ -209,11 +221,31 @@ CartesianProduct<VaryMatchingStart> VaryMultiMatchingStarts(const std::vector<Ma
   return MakeCartesianProduct(std::move(variants));
 }
 
+CartesianProduct<VaryMatchingStart> VaryFilterMatchingStarts(const Matching &matching,
+                                                             const SymbolTable &symbol_table) {
+  auto filter_matchings_cnt = 0;
+  for (const auto &filter : matching.filters) {
+    filter_matchings_cnt += static_cast<int>(filter.matchings.size());
+  }
+
+  std::vector<VaryMatchingStart> variants;
+  variants.reserve(filter_matchings_cnt);
+
+  for (const auto &filter : matching.filters) {
+    for (const auto &filter_matching : filter.matchings) {
+      variants.emplace_back(filter_matching, symbol_table);
+    }
+  }
+
+  return MakeCartesianProduct(std::move(variants));
+}
+
 VaryQueryPartMatching::VaryQueryPartMatching(SingleQueryPart query_part, const SymbolTable &symbol_table)
     : query_part_(std::move(query_part)),
       matchings_(VaryMatchingStart(query_part_.matching, symbol_table)),
       optional_matchings_(VaryMultiMatchingStarts(query_part_.optional_matching, symbol_table)),
-      merge_matchings_(VaryMultiMatchingStarts(query_part_.merge_matching, symbol_table)) {}
+      merge_matchings_(VaryMultiMatchingStarts(query_part_.merge_matching, symbol_table)),
+      filter_matchings_(VaryFilterMatchingStarts(query_part_.matching, symbol_table)) {}
 
 VaryQueryPartMatching::iterator::iterator(const SingleQueryPart &query_part,
                                           VaryMatchingStart::iterator matchings_begin,
@@ -221,7 +253,9 @@ VaryQueryPartMatching::iterator::iterator(const SingleQueryPart &query_part,
                                           CartesianProduct<VaryMatchingStart>::iterator optional_begin,
                                           CartesianProduct<VaryMatchingStart>::iterator optional_end,
                                           CartesianProduct<VaryMatchingStart>::iterator merge_begin,
-                                          CartesianProduct<VaryMatchingStart>::iterator merge_end)
+                                          CartesianProduct<VaryMatchingStart>::iterator merge_end,
+                                          CartesianProduct<VaryMatchingStart>::iterator filter_begin,
+                                          CartesianProduct<VaryMatchingStart>::iterator filter_end)
     : current_query_part_(query_part),
       matchings_it_(matchings_begin),
       matchings_end_(matchings_end),
@@ -230,7 +264,10 @@ VaryQueryPartMatching::iterator::iterator(const SingleQueryPart &query_part,
       optional_end_(optional_end),
       merge_it_(merge_begin),
       merge_begin_(merge_begin),
-      merge_end_(merge_end) {
+      merge_end_(merge_end),
+      filter_it_(filter_begin),
+      filter_begin_(filter_begin),
+      filter_end_(filter_end) {
   if (matchings_it_ != matchings_end_) {
     // Fill the query part with the first variation of matchings
     SetCurrentQueryPart();
@@ -242,26 +279,37 @@ VaryQueryPartMatching::iterator &VaryQueryPartMatching::iterator::operator++() {
   //    * matchings (m1) and (m2)
   //    * optional matchings (o1) and (o2)
   //    * merge matching (g1)
+  //    * filter matching (f1) and (f2)
   // We want to produce parts for:
-  //    * (m1), (o1), (g1)
-  //    * (m1), (o2), (g1)
-  //    * (m2), (o1), (g1)
-  //    * (m2), (o2), (g1)
-  // Create variations by changing the merge part first.
-  if (merge_it_ != merge_end_) ++merge_it_;
-  // If all merge variations are done, start them from beginning and move to the
-  // next optional matching variation.
-  if (merge_it_ == merge_end_) {
+  //    * (m1), (o1), (g1), (f1)
+  //    * (m1), (o1), (g1), (f2)
+  //    * (m1), (o2), (g1), (f1)
+  //    * (m1), (o2), (g1), (f2)
+  //    * (m2), (o1), (g1), (f1)
+  //    * (m2), (o1), (g1), (f2)
+  //    * (m2), (o2), (g1), (f1)
+  //    * (m2), (o2), (g1), (f2)
+
+  // Create variations by changing the filter part first.
+  if (filter_it_ != filter_end_) ++filter_it_;
+
+  // Create variations by changing the merge part.
+  if (filter_it_ == filter_end_) {
+    filter_it_ = filter_begin_;
+    if (merge_it_ != merge_end_) ++merge_it_;
+  }
+
+  // Create variations by changing the optional part.
+  if (merge_it_ == merge_end_ && filter_it_ == filter_begin_) {
     merge_it_ = merge_begin_;
     if (optional_it_ != optional_end_) ++optional_it_;
   }
-  // If all optional matching variations are done (after exhausting merge
-  // variations), start them from beginning and move to the next regular
-  // matching variation.
-  if (optional_it_ == optional_end_ && merge_it_ == merge_begin_) {
+
+  if (optional_it_ == optional_end_ && merge_it_ == merge_begin_ && filter_it_ == filter_begin_) {
     optional_it_ = optional_begin_;
     if (matchings_it_ != matchings_end_) ++matchings_it_;
   }
+
   // We have reached the end, so return;
   if (matchings_it_ == matchings_end_) return *this;
   // Fill the query part with the new variation of matchings.
@@ -283,6 +331,28 @@ void VaryQueryPartMatching::iterator::SetCurrentQueryPart() {
   if (merge_it_ != merge_end_) {
     current_query_part_.merge_matching = *merge_it_;
   }
+  DMG_ASSERT(filter_it_ != filter_end_ || filter_begin_ == filter_end_,
+             "Either there are no filter matchings or we can always generate"
+             "a variation");
+
+  auto all_filter_matchings = *filter_it_;
+  auto all_filter_matchings_idx = 0;
+  for (auto &filter : current_query_part_.matching.filters) {
+    auto matchings_size = filter.matchings.size();
+
+    std::vector<FilterMatching> new_matchings;
+    new_matchings.reserve(matchings_size);
+
+    for (auto i = 0; i < matchings_size; i++) {
+      new_matchings.push_back(ToFilterMatching(all_filter_matchings[all_filter_matchings_idx]));
+      new_matchings[i].symbol = filter.matchings[i].symbol;
+      new_matchings[i].type = filter.matchings[i].type;
+
+      all_filter_matchings_idx++;
+    }
+
+    filter.matchings = std::move(new_matchings);
+  }
 }
 
 bool VaryQueryPartMatching::iterator::operator==(const iterator &other) const {
@@ -291,7 +361,8 @@ bool VaryQueryPartMatching::iterator::operator==(const iterator &other) const {
     // iterators can be at any position.
     return true;
   }
-  return matchings_it_ == other.matchings_it_ && optional_it_ == other.optional_it_ && merge_it_ == other.merge_it_;
+  return matchings_it_ == other.matchings_it_ && optional_it_ == other.optional_it_ && merge_it_ == other.merge_it_ &&
+         filter_it_ == other.filter_it_;
 }
 
 }  // namespace memgraph::query::plan::impl

src/query/plan/variable_start_planner.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
@@ -230,6 +230,8 @@ class VaryMatchingStart {
 // Cartesian product of all of them is returned.
 CartesianProduct<VaryMatchingStart> VaryMultiMatchingStarts(const std::vector<Matching> &, const SymbolTable &);
 
+CartesianProduct<VaryMatchingStart> VaryFilterMatchingStarts(const Matching &matching, const SymbolTable &symbol_table);
+
 // Produces alternative query parts out of a single part by varying how each
 // graph matching is done.
 class VaryQueryPartMatching {
@@ -245,6 +247,7 @@ class VaryQueryPartMatching {
     typedef const SingleQueryPart *pointer;
 
     iterator(const SingleQueryPart &, VaryMatchingStart::iterator, VaryMatchingStart::iterator,
+             CartesianProduct<VaryMatchingStart>::iterator, CartesianProduct<VaryMatchingStart>::iterator,
              CartesianProduct<VaryMatchingStart>::iterator, CartesianProduct<VaryMatchingStart>::iterator,
              CartesianProduct<VaryMatchingStart>::iterator, CartesianProduct<VaryMatchingStart>::iterator);
 
@@ -266,15 +269,20 @@ class VaryQueryPartMatching {
     CartesianProduct<VaryMatchingStart>::iterator merge_it_;
     CartesianProduct<VaryMatchingStart>::iterator merge_begin_;
     CartesianProduct<VaryMatchingStart>::iterator merge_end_;
+    CartesianProduct<VaryMatchingStart>::iterator filter_it_;
+    CartesianProduct<VaryMatchingStart>::iterator filter_begin_;
+    CartesianProduct<VaryMatchingStart>::iterator filter_end_;
   };
 
   auto begin() {
     return iterator(query_part_, matchings_.begin(), matchings_.end(), optional_matchings_.begin(),
-                    optional_matchings_.end(), merge_matchings_.begin(), merge_matchings_.end());
+                    optional_matchings_.end(), merge_matchings_.begin(), merge_matchings_.end(),
+                    filter_matchings_.begin(), filter_matchings_.end());
   }
   auto end() {
     return iterator(query_part_, matchings_.end(), matchings_.end(), optional_matchings_.end(),
-                    optional_matchings_.end(), merge_matchings_.end(), merge_matchings_.end());
+                    optional_matchings_.end(), merge_matchings_.end(), merge_matchings_.end(), filter_matchings_.end(),
+                    filter_matchings_.end());
   }
 
  private:
@@ -286,6 +294,7 @@ class VaryQueryPartMatching {
   CartesianProduct<VaryMatchingStart> optional_matchings_;
   // Like optional matching, but for merge matchings.
   CartesianProduct<VaryMatchingStart> merge_matchings_;
+  CartesianProduct<VaryMatchingStart> filter_matchings_;
 };
 
 }  // namespace impl
@@ -304,25 +313,70 @@ class VariableStartPlanner {
 
   // Generates different, equivalent query parts by taking different graph
   // matching routes for each query part.
-  auto VaryQueryMatching(const std::vector<SingleQueryPart> &query_parts, const SymbolTable &symbol_table) {
-    std::vector<impl::VaryQueryPartMatching> alternative_query_parts;
-    alternative_query_parts.reserve(query_parts.size());
-    for (const auto &query_part : query_parts) {
-      alternative_query_parts.emplace_back(impl::VaryQueryPartMatching(query_part, symbol_table));
+  auto VaryQueryMatching(const QueryParts &query_parts, const SymbolTable &symbol_table) {
+    std::vector<impl::VaryQueryPartMatching> varying_query_matchings;
+
+    auto single_query_parts = ExtractSingleQueryParts(std::make_unique<QueryParts>(query_parts));
+
+    for (const auto &single_query_part : single_query_parts) {
+      varying_query_matchings.emplace_back(single_query_part, symbol_table);
     }
-    return iter::slice(MakeCartesianProduct(std::move(alternative_query_parts)), 0UL, FLAGS_query_max_plans);
+
+    return iter::slice(MakeCartesianProduct(std::move(varying_query_matchings)), 0UL, FLAGS_query_max_plans);
+  }
+
+  std::vector<SingleQueryPart> ExtractSingleQueryParts(const std::shared_ptr<QueryParts> query_parts) {
+    std::vector<SingleQueryPart> results;
+
+    for (const auto &query_part : query_parts->query_parts) {
+      for (const auto &single_query_part : query_part.single_query_parts) {
+        results.push_back(single_query_part);
+
+        for (const auto &subquery : single_query_part.subqueries) {
+          const auto subquery_results = ExtractSingleQueryParts(subquery);
+          results.insert(results.end(), std::make_move_iterator(subquery_results.begin()),
+                         std::make_move_iterator(subquery_results.end()));
+        }
+      }
+    }
+
+    return results;
+  }
+
+  QueryParts ReconstructQueryParts(const QueryParts &old_query_parts,
+                                   const std::vector<SingleQueryPart> &single_query_parts_variation, uint64_t &index) {
+    auto reconstructed_query_parts = old_query_parts;
+
+    for (auto i = 0; i < old_query_parts.query_parts.size(); i++) {
+      const auto &old_query_part = old_query_parts.query_parts[i];
+      for (auto j = 0; j < old_query_part.single_query_parts.size(); j++) {
+        const auto &old_single_query_part = old_query_part.single_query_parts[j];
+        reconstructed_query_parts.query_parts[i].single_query_parts[j] = single_query_parts_variation[index++];
+
+        for (auto k = 0; k < old_single_query_part.subqueries.size(); k++) {
+          const auto &subquery = old_single_query_part.subqueries[k];
+          reconstructed_query_parts.query_parts[i].single_query_parts[j].subqueries[k] =
+              std::make_shared<QueryParts>(ReconstructQueryParts(*subquery, single_query_parts_variation, index));
+        }
+      }
+    }
+
+    return reconstructed_query_parts;
   }
 
  public:
   explicit VariableStartPlanner(TPlanningContext *context) : context_(context) {}
 
   /// @brief Generate multiple plans by varying the order of graph traversal.
-  auto Plan(const std::vector<SingleQueryPart> &query_parts) {
+  auto Plan(const QueryParts &query_parts) {
     return iter::imap(
-        [context = context_](const auto &alternative_query_parts) {
+        [context = context_, old_query_parts = query_parts, this](const auto &alternative_query_parts) {
+          uint64_t index = 0;
+          auto reconstructed_query_parts = ReconstructQueryParts(old_query_parts, alternative_query_parts, index);
+
           RuleBasedPlanner<TPlanningContext> rule_planner(context);
           context->bound_symbols.clear();
-          return rule_planner.Plan(alternative_query_parts);
+          return rule_planner.Plan(reconstructed_query_parts);
         },
         VaryQueryMatching(query_parts, *context_->symbol_table));
   }
@@ -330,7 +384,7 @@ class VariableStartPlanner {
   /// @brief The result of plan generation is an iterable of roots to multiple
   /// generated operator trees.
   using PlanResult = typename std::result_of<decltype (&VariableStartPlanner<TPlanningContext>::Plan)(
-      VariableStartPlanner<TPlanningContext>, std::vector<SingleQueryPart> &)>::type;
+      VariableStartPlanner<TPlanningContext>, QueryParts &)>::type;
 };
 
 }  // namespace memgraph::query::plan

src/query/plan/vertex_count_cache.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
@@ -78,6 +78,11 @@ class VertexCountCache {
     return db_->LabelPropertyIndexExists(label, property);
   }
 
+  std::optional<storage::IndexStats> GetIndexStats(const storage::LabelId &label,
+                                                   const storage::PropertyId &property) const {
+    return db_->GetIndexStats(label, property);
+  }
+
  private:
   typedef std::pair<storage::LabelId, storage::PropertyId> LabelPropertyKey;