Merge branch 'master' into add-gc-for-query-memory-tracker

link mg-memory
revert back on isTransactionTracked
2023-11-22 10:11:07 +01:00 · 2023-11-14 16:19:41 +01:00 · 2023-11-14 15:57:46 +01:00 · 2023-11-14 15:47:33 +01:00 · 2023-11-14 15:14:58 +01:00 · 2023-11-06 16:45:00 +01:00
401 changed files with 4812 additions and 9793 deletions
--- a/.github/workflows/diff.yaml
+++ b/.github/workflows/diff.yaml
@@ -229,6 +229,10 @@ jobs:
          # branches and tags. (default: 1)
          fetch-depth: 0

+      - name: Check e2e service dependencies
+        run: |
+          cd tests/e2e
+          ./dependency_check.sh

      - name: Build release binaries
        run: |
@@ -267,13 +271,6 @@ jobs:
          cd build
          ctest -R memgraph__unit --output-on-failure -j$THREADS

-      - name: Ensure Kafka and Pulsar are up
-        run: |
-          cd tests/e2e/streams/kafka
-          docker-compose up -d
-          cd ../pulsar
-          docker-compose up -d
-
      - name: Run e2e tests
        run: |
          cd tests
@@ -282,14 +279,6 @@ jobs:
          cd e2e
          ./run.sh

-      - name: Ensure Kafka and Pulsar are down
-        if: always()
-        run: |
-          cd tests/e2e/streams/kafka
-          docker-compose down
-          cd ../pulsar
-          docker-compose down
-
      - name: Run stress test (plain)
        run: |
          cd tests/stress
@@ -365,11 +354,6 @@ jobs:
          cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo ..
          make -j$THREADS memgraph

-      - name: Refresh Jepsen Cluster
-        run: |
-          cd tests/jepsen
-          ./run.sh cluster-refresh
-
      - name: Run Jepsen tests
        run: |
          cd tests/jepsen
--- a/.github/workflows/package_all.yaml
+++ b/.github/workflows/package_all.yaml
@@ -0,0 +1,263 @@
+name: Package All
+
+# TODO(gitbuda): Cleanup docker container if GHA job was canceled.
+
+on:
+  workflow_dispatch:
+    inputs:
+      memgraph_version:
+        description: "Memgraph version to upload as. If empty upload is skipped. Format: 'X.Y.Z'"
+        required: false
+      build_type:
+        type: choice
+        description: "Memgraph Build type. Default value is Release."
+        default: 'Release'
+        options:
+          - Release
+          - RelWithDebInfo
+
+jobs:
+  centos-7:
+    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 centos-7 ${{ github.event.inputs.build_type }}
+      - name: "Upload package"
+        uses: actions/upload-artifact@v3
+        with:
+          name: centos-7
+          path: build/output/centos-7/memgraph*.rpm
+
+  centos-9:
+    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 centos-9 ${{ github.event.inputs.build_type }}
+      - name: "Upload package"
+        uses: actions/upload-artifact@v3
+        with:
+          name: centos-9
+          path: build/output/centos-9/memgraph*.rpm
+
+  debian-10:
+    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 debian-10 ${{ github.event.inputs.build_type }}
+      - name: "Upload package"
+        uses: actions/upload-artifact@v3
+        with:
+          name: debian-10
+          path: build/output/debian-10/memgraph*.deb
+
+  debian-11:
+    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 debian-11 ${{ github.event.inputs.build_type }}
+      - name: "Upload package"
+        uses: actions/upload-artifact@v3
+        with:
+          name: debian-11
+          path: build/output/debian-11/memgraph*.deb
+
+  docker:
+    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: |
+          cd release/package
+          ./run.sh package debian-11 ${{ github.event.inputs.build_type }} --for-docker
+          ./run.sh docker
+      - name: "Upload package"
+        uses: actions/upload-artifact@v3
+        with:
+          name: docker
+          path: build/output/docker/memgraph*.tar.gz
+
+  ubuntu-1804:
+    runs-on: [self-hosted, DockerMgBuild, X64]
+    timeout-minutes: 60
+    steps:
+      - name: "Set up repository"
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # Required because of release/get_version.py
+      - name: "Build package"
+        run: |
+          ./release/package/run.sh package ubuntu-18.04 ${{ github.event.inputs.build_type }}
+      - name: "Upload package"
+        uses: actions/upload-artifact@v3
+        with:
+          name: ubuntu-18.04
+          path: build/output/ubuntu-18.04/memgraph*.deb
+
+  ubuntu-2004:
+    runs-on: [self-hosted, DockerMgBuild, X64]
+    timeout-minutes: 60
+    steps:
+      - name: "Set up repository"
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # Required because of release/get_version.py
+      - name: "Build package"
+        run: |
+          ./release/package/run.sh package ubuntu-20.04 ${{ github.event.inputs.build_type }}
+      - name: "Upload package"
+        uses: actions/upload-artifact@v3
+        with:
+          name: ubuntu-20.04
+          path: build/output/ubuntu-20.04/memgraph*.deb
+
+  ubuntu-2204:
+    runs-on: [self-hosted, DockerMgBuild, X64]
+    timeout-minutes: 60
+    steps:
+      - name: "Set up repository"
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # Required because of release/get_version.py
+      - name: "Build package"
+        run: |
+          ./release/package/run.sh package ubuntu-22.04 ${{ github.event.inputs.build_type }}
+      - name: "Upload package"
+        uses: actions/upload-artifact@v3
+        with:
+          name: ubuntu-22.04
+          path: build/output/ubuntu-22.04/memgraph*.deb
+
+  debian-11-platform:
+    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 debian-11 ${{ github.event.inputs.build_type }} --for-platform
+      - name: "Upload package"
+        uses: actions/upload-artifact@v3
+        with:
+          name: debian-11-platform
+          path: build/output/debian-11/memgraph*.deb
+
+  fedora-36:
+    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 fedora-36 ${{ github.event.inputs.build_type }}
+      - name: "Upload package"
+        uses: actions/upload-artifact@v3
+        with:
+          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 ${{ github.event.inputs.build_type }}
+      - 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: 120
+    steps:
+      - name: "Set up repository"
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # Required because of release/get_version.py
+      - name: "Build package"
+        run: |
+          ./release/package/run.sh package debian-11-arm ${{ github.event.inputs.build_type }}
+      - name: "Upload package"
+        uses: actions/upload-artifact@v3
+        with:
+          name: debian-11-aarch64
+          path: build/output/debian-11-arm/memgraph*.deb
+
+  ubuntu-2204-arm:
+    runs-on: [self-hosted, DockerMgBuild, ARM64, strange]
+    timeout-minutes: 120
+    steps:
+      - name: "Set up repository"
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # Required because of release/get_version.py
+      - name: "Build package"
+        run: |
+          ./release/package/run.sh package ubuntu-22.04-arm ${{ github.event.inputs.build_type }}
+      - name: "Upload package"
+        uses: actions/upload-artifact@v3
+        with:
+          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/v${{ github.event.inputs.memgraph_version }}/"
--- a/.github/workflows/package_specific.yaml
+++ b/.github/workflows/package_specific.yaml
@@ -1,4 +1,4 @@
-name: Package memgraph
+name: Package Specific

 # TODO(gitbuda): Cleanup docker container if GHA job was canceled.

@@ -10,17 +10,16 @@ on:
        required: false
      build_type:
        type: choice
-        description: "Memgraph Build type. Default value is Release"
+        description: "Memgraph Build type. Default value is Release."
        default: 'Release'
        options:
          - Release
          - RelWithDebInfo
      target_os:
        type: choice
-        description: "Target OS for which memgraph will be packaged. Select 'all' if you want to package for every listed OS. Default is Ubuntu 22.04"
+        description: "Target OS for which memgraph will be packaged. Default is Ubuntu 22.04"
        default: 'ubuntu-22_04'
        options:
-          - all
          - amzn-2
          - centos-7
          - centos-9
@@ -37,7 +36,7 @@ on:

 jobs:
  amzn-2:
-    if: ${{ github.event.inputs.target_os == 'amzn-2' || github.event.inputs.target_os == 'all' }}
+    if: ${{ github.event.inputs.target_os == 'amzn-2' }}
    runs-on: [self-hosted, DockerMgBuild, X64]
    timeout-minutes: 60
    steps:
@@ -55,7 +54,7 @@ jobs:
          path: build/output/amzn-2/memgraph*.rpm

  centos-7:
-    if: ${{ github.event.inputs.target_os == 'centos-7' || github.event.inputs.target_os == 'all' }}
+    if: ${{ github.event.inputs.target_os == 'centos-7' }}
    runs-on: [self-hosted, DockerMgBuild, X64]
    timeout-minutes: 60
    steps:
@@ -73,7 +72,7 @@ jobs:
          path: build/output/centos-7/memgraph*.rpm

  centos-9:
-    if: ${{ github.event.inputs.target_os == 'centos-9' || github.event.inputs.target_os == 'all' }}
+    if: ${{ github.event.inputs.target_os == 'centos-9' }}
    runs-on: [self-hosted, DockerMgBuild, X64]
    timeout-minutes: 60
    steps:
@@ -91,7 +90,7 @@ jobs:
          path: build/output/centos-9/memgraph*.rpm

  debian-10:
-    if: ${{ github.event.inputs.target_os == 'debian-10' || github.event.inputs.target_os == 'all' }}
+    if: ${{ github.event.inputs.target_os == 'debian-10' }}
    runs-on: [self-hosted, DockerMgBuild, X64]
    timeout-minutes: 60
    steps:
@@ -109,7 +108,7 @@ jobs:
          path: build/output/debian-10/memgraph*.deb

  debian-11:
-    if: ${{ github.event.inputs.target_os == 'debian-11' || github.event.inputs.target_os == 'all' }}
+    if: ${{ github.event.inputs.target_os == 'debian-11' }}
    runs-on: [self-hosted, DockerMgBuild, X64]
    timeout-minutes: 60
    steps:
@@ -127,7 +126,7 @@ jobs:
          path: build/output/debian-11/memgraph*.deb

  debian-11-arm:
-    if: ${{ github.event.inputs.target_os == 'debian-11-arm' || github.event.inputs.target_os == 'all' }}
+    if: ${{ github.event.inputs.target_os == 'debian-11-arm' }}
    runs-on: [self-hosted, DockerMgBuild, ARM64, strange]
    timeout-minutes: 120
    steps:
@@ -145,7 +144,7 @@ jobs:
          path: build/output/debian-11-arm/memgraph*.deb

  debian-11-platform:
-    if: ${{ github.event.inputs.target_os == 'debian-11-platform' || github.event.inputs.target_os == 'all' }}
+    if: ${{ github.event.inputs.target_os == 'debian-11-platform' }}
    runs-on: [self-hosted, DockerMgBuild, X64]
    timeout-minutes: 60
    steps:
@@ -163,7 +162,7 @@ jobs:
          path: build/output/debian-11/memgraph*.deb

  docker:
-    if: ${{ github.event.inputs.target_os == 'docker' || github.event.inputs.target_os == 'all' }}
+    if: ${{ github.event.inputs.target_os == 'docker' }}
    runs-on: [self-hosted, DockerMgBuild, X64]
    timeout-minutes: 60
    steps:
@@ -183,7 +182,7 @@ jobs:
          path: build/output/docker/memgraph*.tar.gz

  fedora-36:
-    if: ${{ github.event.inputs.target_os == 'fedora-36' || github.event.inputs.target_os == 'all' }}
+    if: ${{ github.event.inputs.target_os == 'fedora-36' }}
    runs-on: [self-hosted, DockerMgBuild, X64]
    timeout-minutes: 60
    steps:
@@ -201,7 +200,7 @@ jobs:
          path: build/output/fedora-36/memgraph*.rpm

  ubuntu-18_04:
-    if: ${{ github.event.inputs.target_os == 'ubuntu-18_04' || github.event.inputs.target_os == 'all' }}
+    if: ${{ github.event.inputs.target_os == 'ubuntu-18_04' }}
    runs-on: [self-hosted, DockerMgBuild, X64]
    timeout-minutes: 60
    steps:
@@ -219,7 +218,7 @@ jobs:
          path: build/output/ubuntu-18.04/memgraph*.deb

  ubuntu-20_04:
-    if: ${{ github.event.inputs.target_os == 'ubuntu-20_04' || github.event.inputs.target_os == 'all' }}
+    if: ${{ github.event.inputs.target_os == 'ubuntu-20_04' }}
    runs-on: [self-hosted, DockerMgBuild, X64]
    timeout-minutes: 60
    steps:
@@ -237,7 +236,7 @@ jobs:
          path: build/output/ubuntu-20.04/memgraph*.deb

  ubuntu-22_04:
-    if: ${{ github.event.inputs.target_os == 'ubuntu-22_04' || github.event.inputs.target_os == 'all' }}
+    if: ${{ github.event.inputs.target_os == 'ubuntu-22_04' }}
    runs-on: [self-hosted, DockerMgBuild, X64]
    timeout-minutes: 60
    steps:
@@ -255,7 +254,7 @@ jobs:
          path: build/output/ubuntu-22.04/memgraph*.deb

  ubuntu-22_04-arm:
-    if: ${{ github.event.inputs.target_os == 'ubuntu-22_04-arm' || github.event.inputs.target_os == 'all' }}
+    if: ${{ github.event.inputs.target_os == 'ubuntu-22_04-arm' }}
    runs-on: [self-hosted, DockerMgBuild, ARM64, strange]
    timeout-minutes: 120
    steps:
--- a/.github/workflows/release_centos8.yaml
+++ b/.github/workflows/release_centos8.yaml
@@ -0,0 +1,318 @@
+name: Release CentOS 8
+
+on:
+  workflow_dispatch:
+    inputs:
+      build_type:
+        type: choice
+        description: "Memgraph Build type. Default value is Release."
+        default: 'Release'
+        options:
+          - Release
+          - RelWithDebInfo
+
+  schedule:
+    - cron: "0 22 * * *"
+
+jobs:
+  community_build:
+    name: "Community build"
+    runs-on: [self-hosted, Linux, X64, CentOS8]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960
+
+    steps:
+      - name: Set up repository
+        uses: actions/checkout@v3
+        with:
+          # Number of commits to fetch. `0` indicates all history for all
+          # branches and tags. (default: 1)
+          fetch-depth: 0
+
+      - name: Build community binaries
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
+          # Build community binaries.
+          cd build
+          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DMG_ENTERPRISE=OFF ..
+          make -j$THREADS
+
+      - name: Run unit tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure
+
+  coverage_build:
+    name: "Coverage build"
+    runs-on: [self-hosted, Linux, X64, CentOS8]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    steps:
+      - name: Set up repository
+        uses: actions/checkout@v3
+        with:
+          # Number of commits to fetch. `0` indicates all history for all
+          # branches and tags. (default: 1)
+          fetch-depth: 0
+
+      - name: Build coverage binaries
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Build coverage binaries.
+          cd build
+          cmake -DTEST_COVERAGE=ON ..
+          make -j$THREADS memgraph__unit
+
+      - name: Run unit tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure
+
+      - name: Compute code coverage
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Compute code coverage.
+          cd tools/github
+          ./coverage_convert
+
+          # Package code coverage.
+          cd generated
+          tar -czf code_coverage.tar.gz coverage.json html report.json summary.rmu
+
+      - name: Save code coverage
+        uses: actions/upload-artifact@v3
+        with:
+          name: "Code coverage"
+          path: tools/github/generated/code_coverage.tar.gz
+
+  debug_build:
+    name: "Debug build"
+    runs-on: [self-hosted, Linux, X64, CentOS8]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+
+    steps:
+      - name: Set up repository
+        uses: actions/checkout@v3
+        with:
+          # Number of commits to fetch. `0` indicates all history for all
+          # branches and tags. (default: 1)
+          fetch-depth: 0
+
+      - name: Build debug binaries
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Build debug binaries.
+          cd build
+          cmake ..
+          make -j$THREADS
+
+      - name: Run leftover CTest tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Run leftover CTest tests (all except unit and benchmark tests).
+          cd build
+          ctest -E "(memgraph__unit|memgraph__benchmark)" --output-on-failure
+
+      - name: Run drivers tests
+        run: |
+          ./tests/drivers/run.sh
+
+      - name: Run integration tests
+        run: |
+          tests/integration/run.sh
+
+      - name: Run cppcheck and clang-format
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Run cppcheck and clang-format.
+          cd tools/github
+          ./cppcheck_and_clang_format diff
+
+      - name: Save cppcheck and clang-format errors
+        uses: actions/upload-artifact@v3
+        with:
+          name: "Code coverage"
+          path: tools/github/cppcheck_and_clang_format.txt
+
+  release_build:
+    name: "Release build"
+    runs-on: [self-hosted, Linux, X64, CentOS8]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960
+
+    steps:
+      - name: Set up repository
+        uses: actions/checkout@v3
+        with:
+          # Number of commits to fetch. `0` indicates all history for all
+          # branches and tags. (default: 1)
+          fetch-depth: 0
+
+      - name: Build release binaries
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Initialize dependencies.
+          ./init
+
+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
+          # Build release binaries.
+          cd build
+          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
+          make -j$THREADS
+
+      - name: Create enterprise RPM package
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          cd build
+
+          # create mgconsole
+          # we use the -B to force the build
+          make -j$THREADS -B mgconsole
+
+          # Create enterprise RPM package.
+          mkdir output && cd output
+          cpack -G RPM --config ../CPackConfig.cmake
+          rpmlint memgraph*.rpm
+
+      - name: Save enterprise RPM package
+        uses: actions/upload-artifact@v3
+        with:
+          name: "Enterprise RPM package"
+          path: build/output/memgraph*.rpm
+
+      - name: Run micro benchmark tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Run micro benchmark tests.
+          cd build
+          # The `eval` benchmark needs a large stack limit.
+          ulimit -s 262144
+          ctest -R memgraph__benchmark -V
+
+      - name: Run macro benchmark tests
+        run: |
+          cd tests/macro_benchmark
+          ./harness QuerySuite MemgraphRunner \
+            --groups aggregation 1000_create unwind_create dense_expand match \
+            --no-strict
+
+      - name: Run parallel macro benchmark tests
+        run: |
+          cd tests/macro_benchmark
+          ./harness QueryParallelSuite MemgraphRunner \
+            --groups aggregation_parallel create_parallel bfs_parallel \
+            --num-database-workers 9 --num-clients-workers 30 \
+            --no-strict
+
+      - name: Run GQL Behave tests
+        run: |
+          cd tests
+          ./setup.sh /opt/toolchain-v4/activate
+          cd gql_behave
+          ./continuous_integration
+
+      - name: Save quality assurance status
+        uses: actions/upload-artifact@v3
+        with:
+          name: "GQL Behave Status"
+          path: |
+            tests/gql_behave/gql_behave_status.csv
+            tests/gql_behave/gql_behave_status.html
+
+      - name: Run unit tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__unit --output-on-failure
+
+      - name: Run e2e tests
+        run: |
+          cd tests
+          ./setup.sh /opt/toolchain-v4/activate
+          source ve3/bin/activate_e2e
+          cd e2e
+          ./run.sh
+
+      - name: Run stress test (plain)
+        run: |
+          cd tests/stress
+          ./continuous_integration
+
+      - name: Run stress test (SSL)
+        run: |
+          cd tests/stress
+          ./continuous_integration --use-ssl
+
+      - name: Run stress test (large)
+        run: |
+          cd tests/stress
+          ./continuous_integration --large-dataset
+
+      - name: Run durability test (plain)
+        run: |
+          cd tests/stress
+          source ve3/bin/activate
+          python3 durability --num-steps 5
+
+      - name: Run durability test (large)
+        run: |
+          cd tests/stress
+          source ve3/bin/activate
+          python3 durability --num-steps 20
--- a/.github/workflows/release_debian10.yaml
+++ b/.github/workflows/release_debian10.yaml
@@ -1,7 +1,4 @@
 name: Release Debian 10
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}
-  cancel-in-progress: true

 on:
  workflow_dispatch:
@@ -13,30 +10,23 @@ on:
        options:
          - Release
          - RelWithDebInfo
-  push:
-    branches:
-      - "release/**"
-    tags:
-      - "v*.*.*-rc*"
-      - "v*.*-rc*"
+
  schedule:
    - cron: "0 22 * * *"

-env:
-  THREADS: 24
-  MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
-  MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
-  BUILD_TYPE: ${{ github.event.inputs.build_type || 'Release' }}
-
 jobs:
  community_build:
    name: "Community build"
    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -50,6 +40,10 @@ jobs:
          # Initialize dependencies.
          ./init

+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
          # Build community binaries.
          cd build
          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DMG_ENTERPRISE=OFF ..
@@ -71,11 +65,10 @@ jobs:
      THREADS: 24
      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
-    timeout-minutes: 60

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -117,19 +110,22 @@ jobs:
          tar -czf code_coverage.tar.gz coverage.json html report.json summary.rmu

      - name: Save code coverage
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
-          name: "Code coverage(Coverage build)"
+          name: "Code coverage"
          path: tools/github/generated/code_coverage.tar.gz

  debug_build:
    name: "Debug build"
    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -161,6 +157,10 @@ jobs:
        run: |
          ./tests/drivers/run.sh

+      - name: Run integration tests
+        run: |
+          tests/integration/run.sh
+
      - name: Run cppcheck and clang-format
        run: |
          # Activate toolchain.
@@ -171,49 +171,23 @@ jobs:
          ./cppcheck_and_clang_format diff

      - name: Save cppcheck and clang-format errors
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
-          name: "Code coverage(Debug build)"
+          name: "Code coverage"
          path: tools/github/cppcheck_and_clang_format.txt

-  debug_integration_test:
-    name: "Debug integration tests"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build debug binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build debug binaries.
-          cd build
-          cmake ..
-          make -j$THREADS
-
-      - name: Run integration tests
-        run: |
-          tests/integration/run.sh
-
  release_build:
    name: "Release build"
    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -227,6 +201,10 @@ jobs:
          # Initialize dependencies.
          ./init

+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
          # Build release binaries.
          cd build
          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
@@ -248,60 +226,11 @@ jobs:
          cpack -G DEB --config ../CPackConfig.cmake

      - name: Save enterprise DEB package
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: "Enterprise DEB package"
          path: build/output/memgraph*.deb

-      - name: Run GQL Behave tests
-        run: |
-          cd tests
-          ./setup.sh /opt/toolchain-v4/activate
-          cd gql_behave
-          ./continuous_integration
-
-      - name: Save quality assurance status
-        uses: actions/upload-artifact@v4
-        with:
-          name: "GQL Behave Status"
-          path: |
-            tests/gql_behave/gql_behave_status.csv
-            tests/gql_behave/gql_behave_status.html
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__unit --output-on-failure
-
-  release_benchmark_tests:
-    name: "Release Benchmark Tests"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
      - name: Run micro benchmark tests
        run: |
          # Activate toolchain.
@@ -328,37 +257,29 @@ jobs:
            --num-database-workers 9 --num-clients-workers 30 \
            --no-strict

-  release_e2e_test:
-    name: "Release End-to-end Test"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
+      - name: Run GQL Behave tests
+        run: |
+          cd tests
+          ./setup.sh /opt/toolchain-v4/activate
+          cd gql_behave
+          ./continuous_integration

-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
+      - name: Save quality assurance status
+        uses: actions/upload-artifact@v3
        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
+          name: "GQL Behave Status"
+          path: |
+            tests/gql_behave/gql_behave_status.csv
+            tests/gql_behave/gql_behave_status.html

-      - name: Build release binaries
+      - name: Run unit tests
        run: |
          # Activate toolchain.
          source /opt/toolchain-v4/activate
-          # Initialize dependencies.
-          ./init

-          # Build release binaries
+          # Run unit tests.
          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
-      - name: Ensure Kafka and Pulsar are up
-        run: |
-          cd tests/e2e/streams/kafka
-          docker-compose up -d
-          cd ../pulsar
-          docker-compose up -d
+          ctest -R memgraph__unit --output-on-failure

      - name: Run e2e tests
        run: |
@@ -368,40 +289,6 @@ jobs:
          cd e2e
          ./run.sh

-      - name: Ensure Kafka and Pulsar are down
-        if: always()
-        run: |
-          cd tests/e2e/streams/kafka
-          docker-compose down
-          cd ../pulsar
-          docker-compose down
-
-  release_durability_stress_tests:
-    name: "Release durability and stress tests"
-    runs-on: [self-hosted, Linux, X64, Debian10]
-    timeout-minutes: 60
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
      - name: Run stress test (plain)
        run: |
          cd tests/stress
@@ -412,6 +299,11 @@ jobs:
          cd tests/stress
          ./continuous_integration --use-ssl

+      - name: Run stress test (large)
+        run: |
+          cd tests/stress
+          ./continuous_integration --large-dataset
+
      - name: Run durability test (plain)
        run: |
          cd tests/stress
@@ -427,11 +319,15 @@ jobs:
  release_jepsen_test:
    name: "Release Jepsen Test"
    runs-on: [self-hosted, Linux, X64, Debian10, JepsenControl]
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
    timeout-minutes: 60

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -444,23 +340,22 @@ jobs:
          # Initialize dependencies.
          ./init

+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
          # Build only memgraph release binary.
          cd build
          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
          make -j$THREADS memgraph

-      - name: Refresh Jepsen Cluster
-        run: |
-          cd tests/jepsen
-          ./run.sh cluster-refresh
-
      - name: Run Jepsen tests
        run: |
          cd tests/jepsen
          ./run.sh test-all-individually --binary ../../build/memgraph --ignore-run-stdout-logs --ignore-run-stderr-logs

      - name: Save Jepsen report
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        if: ${{ always() }}
        with:
          name: "Jepsen Report"
--- a/.github/workflows/release_ubuntu2004.yaml
+++ b/.github/workflows/release_ubuntu2004.yaml
@@ -1,7 +1,4 @@
 name: Release Ubuntu 20.04
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}
-  cancel-in-progress: true

 on:
  workflow_dispatch:
@@ -13,30 +10,23 @@ on:
        options:
          - Release
          - RelWithDebInfo
-  push:
-    branches:
-      - "release/**"
-    tags:
-      - "v*.*.*-rc*"
-      - "v*.*-rc*"
+
  schedule:
    - cron: "0 22 * * *"

-env:
-  THREADS: 24
-  MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
-  MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
-  BUILD_TYPE: ${{ github.event.inputs.build_type || 'Release' }}
-
 jobs:
  community_build:
    name: "Community build"
    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -50,6 +40,10 @@ jobs:
          # Initialize dependencies.
          ./init

+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
          # Build community binaries.
          cd build
          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DMG_ENTERPRISE=OFF ..
@@ -67,11 +61,14 @@ jobs:
  coverage_build:
    name: "Coverage build"
    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -113,19 +110,22 @@ jobs:
          tar -czf code_coverage.tar.gz coverage.json html report.json summary.rmu

      - name: Save code coverage
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
-          name: "Code coverage(Coverage build)"
+          name: "Code coverage"
          path: tools/github/generated/code_coverage.tar.gz

  debug_build:
    name: "Debug build"
    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -157,6 +157,10 @@ jobs:
        run: |
          ./tests/drivers/run.sh

+      - name: Run integration tests
+        run: |
+          tests/integration/run.sh
+
      - name: Run cppcheck and clang-format
        run: |
          # Activate toolchain.
@@ -167,49 +171,23 @@ jobs:
          ./cppcheck_and_clang_format diff

      - name: Save cppcheck and clang-format errors
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
-          name: "Code coverage(Debug build)"
+          name: "Code coverage"
          path: tools/github/cppcheck_and_clang_format.txt

-  debug_integration_test:
-    name: "Debug integration tests"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build debug binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build debug binaries.
-          cd build
-          cmake ..
-          make -j$THREADS
-
-      - name: Run integration tests
-        run: |
-          tests/integration/run.sh
-
  release_build:
    name: "Release build"
    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+    env:
+      THREADS: 24
+      MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
+      MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
+    timeout-minutes: 960

    steps:
      - name: Set up repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
        with:
          # Number of commits to fetch. `0` indicates all history for all
          # branches and tags. (default: 1)
@@ -223,6 +201,10 @@ jobs:
          # Initialize dependencies.
          ./init

+          # Set default build_type to Release
+          INPUT_BUILD_TYPE=${{ github.event.inputs.build_type }}
+          BUILD_TYPE=${INPUT_BUILD_TYPE:-"Release"}
+
          # Build release binaries.
          cd build
          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
@@ -244,60 +226,11 @@ jobs:
          cpack -G DEB --config ../CPackConfig.cmake

      - name: Save enterprise DEB package
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
        with:
          name: "Enterprise DEB package"
          path: build/output/memgraph*.deb

-      - name: Run GQL Behave tests
-        run: |
-          cd tests
-          ./setup.sh /opt/toolchain-v4/activate
-          cd gql_behave
-          ./continuous_integration
-
-      - name: Save quality assurance status
-        uses: actions/upload-artifact@v4
-        with:
-          name: "GQL Behave Status"
-          path: |
-            tests/gql_behave/gql_behave_status.csv
-            tests/gql_behave/gql_behave_status.html
-
-      - name: Run unit tests
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Run unit tests.
-          cd build
-          ctest -R memgraph__unit --output-on-failure
-
-  release_benchmark_tests:
-    name: "Release Benchmark Tests"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
      - name: Run micro benchmark tests
        run: |
          # Activate toolchain.
@@ -324,37 +257,29 @@ jobs:
            --num-database-workers 9 --num-clients-workers 30 \
            --no-strict

-  release_e2e_test:
-    name: "Release End-to-end Test"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
+      - name: Run GQL Behave tests
+        run: |
+          cd tests
+          ./setup.sh /opt/toolchain-v4/activate
+          cd gql_behave
+          ./continuous_integration

-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
+      - name: Save quality assurance status
+        uses: actions/upload-artifact@v3
        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
+          name: "GQL Behave Status"
+          path: |
+            tests/gql_behave/gql_behave_status.csv
+            tests/gql_behave/gql_behave_status.html

-      - name: Build release binaries
+      - name: Run unit tests
        run: |
          # Activate toolchain.
          source /opt/toolchain-v4/activate
-          # Initialize dependencies.
-          ./init

-          # Build release binaries
+          # Run unit tests.
          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
-      - name: Ensure Kafka and Pulsar are up
-        run: |
-          cd tests/e2e/streams/kafka
-          docker-compose up -d
-          cd ../pulsar
-          docker-compose up -d
+          ctest -R memgraph__unit --output-on-failure

      - name: Run e2e tests
        run: |
@@ -364,40 +289,6 @@ jobs:
          cd e2e
          ./run.sh

-      - name: Ensure Kafka and Pulsar are down
-        if: always()
-        run: |
-          cd tests/e2e/streams/kafka
-          docker-compose down
-          cd ../pulsar
-          docker-compose down
-
-  release_durability_stress_tests:
-    name: "Release durability and stress tests"
-    runs-on: [self-hosted, Linux, X64, Ubuntu20.04]
-    timeout-minutes: 60
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
      - name: Run stress test (plain)
        run: |
          cd tests/stress
@@ -408,6 +299,11 @@ jobs:
          cd tests/stress
          ./continuous_integration --use-ssl

+      - name: Run stress test (large)
+        run: |
+          cd tests/stress
+          ./continuous_integration --large-dataset
+
      - name: Run durability test (plain)
        run: |
          cd tests/stress
--- a/.github/workflows/stress_test_large.yaml
+++ b/.github/workflows/stress_test_large.yaml
@@ -1,68 +0,0 @@
-name: Stress test large
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}
-  cancel-in-progress: true
-
-on:
-  workflow_dispatch:
-    inputs:
-      build_type:
-        type: choice
-        description: "Memgraph Build type. Default value is Release."
-        default: 'Release'
-        options:
-          - Release
-          - RelWithDebInfo
-  push:
-    tags:
-      - "v*.*.*-rc*"
-      - "v*.*-rc*"
-  schedule:
-    - cron: "0 22 * * *"
-
-env:
-  THREADS: 24
-  MEMGRAPH_ENTERPRISE_LICENSE: ${{ secrets.MEMGRAPH_ENTERPRISE_LICENSE }}
-  MEMGRAPH_ORGANIZATION_NAME: ${{ secrets.MEMGRAPH_ORGANIZATION_NAME }}
-  BUILD_TYPE: ${{ github.event.inputs.build_type || 'Release' }}
-
-jobs:
-  stress_test_large:
-    name: "Stress test large"
-    timeout-minutes: 720
-    strategy:
-      matrix:
-        os: [Debian10, Ubuntu20.04]
-        extra: [BigMemory, Gen8]
-        exclude:
-          - os: Debian10
-            extra: Gen8
-          - os: Ubuntu20.04
-            extra: BigMemory
-    runs-on: [self-hosted, Linux, X64, "${{ matrix.os }}", "${{ matrix.extra }}"]
-
-    steps:
-      - name: Set up repository
-        uses: actions/checkout@v4
-        with:
-          # Number of commits to fetch. `0` indicates all history for all
-          # branches and tags. (default: 1)
-          fetch-depth: 0
-
-      - name: Build release binaries
-        run: |
-          # Activate toolchain.
-          source /opt/toolchain-v4/activate
-
-          # Initialize dependencies.
-          ./init
-
-          # Build release binaries.
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=$BUILD_TYPE ..
-          make -j$THREADS
-
-      - name: Run stress test (large)
-        run: |
-          cd tests/stress
-          ./continuous_integration --large-dataset
--- a/.sonarcloud.properties
+++ b/.sonarcloud.properties
@@ -1,22 +0,0 @@
-# Path to sources
-sonar.sources = .
-# sonar.exclusions=
-sonar.inclusions=src,include,query_modules
-
-# Path to tests
-sonar.tests = tests/
-# sonar.test.exclusions=
-# sonar.test.inclusions=
-
-# Source encoding
-# sonar.sourceEncoding=
-
-# Exclusions for copy-paste detection
-# sonar.cpd.exclusions=
-
-# Python version (for python projects only)
-# sonar.python.version=
-
-# C++ standard version (for C++ projects only)
-# If not specified, it defaults to the latest supported standard
-# sonar.cfamily.reportingCppStandardOverride=c++98|c++11|c++14|c++17|c++20
--- a/ADRs/001_tantivy.md
+++ b/ADRs/001_tantivy.md
@@ -1,32 +0,0 @@
-# Tantivy ADR
-
-**Author**
-Marko Budiselic (github.com/gitbuda)
-
-**Status**
-APPROVED
-
-**Date**
-January 5, 2024
-
-**Problem**
-
-For some of Memgraph workloads, text search is a required feature. We don't
-want to build a new text search engine because that's not Memgraph's core
-value.
-
-**Criteria**
-
- easy integration with our C++ codebase
- ability to operate in-memory and on-disk
- sufficient features (regex, full-text search, fuzzy search, aggregations over
-  text data)
- production-ready
-
-**Decision**
-
-All known C++ libraries are not production-ready. Recent Rust libraries, in
-particular [Tantivy](https://github.com/quickwit-oss/tantivy), seem to provide
-much more features, it is production ready. The way how we'll integrate Tantivy
-into the current Memgraph codebase is via
-[cxx](https://github.com/dtolnay/cxx). **We select Tantivy.**
--- a/ADRs/002_nuraft.md
+++ b/ADRs/002_nuraft.md
@@ -1,34 +0,0 @@
-# NuRaft ADR
-
-**Author**
-Marko Budiselic (github.com/gitbuda)
-
-**Status**
-PROPOSED
-
-**Date**
-January 10, 2024
-
-**Problem**
-
-In order to enhance Memgraph to have High Availability features as requested by
-customers, we want to have reliable coordinators backed by RAFT consensus algorithm. Implementing
-RAFT to be correct and performant is a very challenging task. Skillful Memgraph
-engineers already tried 3 times and failed to deliver in a reasonable timeframe
-all three times (approximately 4 person-weeks of engineering work each time).
-
-**Criteria**
-
- easy integration with our C++ codebase
- heavily tested in production environments
- implementation of performance optimizations on top of the canonical Raft
-  implementation
-
-**Decision**
-
-There are a few, robust C++ implementations of Raft but as a part of other
-projects or bigger libraries. **We select
-[NuRaft](https://github.com/eBay/NuRaft)** because it focuses on delivering
-Raft without bloatware, and it's used by
-[Clickhouse](https://github.com/ClickHouse/ClickHouse) (an comparable peer to
-Memgraph, a very well-established product).
--- a/ADRs/README.md
+++ b/ADRs/README.md
@@ -1,67 +0,0 @@
-# Architecture Decision Records
-
-Also known as ADRs. This practice has become widespread in many
-high performing engineering teams. It is a technique for communicating
-between software engineers. ADRs provide a clear and documented
-history of architectural choices, ensuring that everyone on the
-team is on the same page. This improves communication and reduces
-misunderstandings. The act of recording decisions encourages
-thoughtful consideration before making choices. This can lead to
-more robust and better-informed architectural decisions.
-
-Links must be created, pointing both to and from the Github Issues
-and/or the Notion Program Management "Initiative" database.
-
-ADRs are complimentary to any tech specs that get written while
-designing a solution. ADRs are very short and to the point, while
-tech specs will include diagrams and can be quite verbose.
-
-## HOWTO
-
-Each ADR will be assigned a monotonically increasing unique numeric
-identifier, which will be zero-padded to 3 digits. Each ADR will
-be in a single markdown file containing no more than one page of
-text, and the filename will start with that unique identifier,
-followed by a camel case phrase summarizing the problem.  For
-example: `001_architecture_decision_records.md` or
-`002_big_integration_cap_theorem.md`.
-
-We want to use an ADR when:
-1. Significant Impact: This includes choices that affect scalability, performance, or fundamental design principles.
-1. Long-Term Ramifications: When a decision is expected to have long-term ramifications or is difficult to reverse.
-1. Architectural Principles: ADRs are suitable for documenting decisions related to architectural principles, frameworks, or patterns that shape the system's structure.
-1. Controversial Choices: When a decision is likely to be controversial or may require justification in the future.
-
-The most senior engineer on a project will evaluate and decide
-whether or not an ADR is needed.
-
-## Do
-
-1. Keep them brief and concise.
-1. Explain the trade-offs.
-1. Each ADR should be about one AD, not multiple ADs
-1. Don't alter existing information in an ADR. Instead, amend the ADR by adding new information, or supersede the ADR by creating a new ADR.
-1. Explain your organization's situation and business priorities.
-1. Include rationale and considerations based on social and skills makeups of your teams.
-1. Include pros and cons that are relevant, and describe them in terms that align with your needs and goals.
-1. Explain what follows from making the decision. This can include the effects, outcomes, outputs, follow ups, and more.
-
-## Don't
-
-1. Try to guess what the executive leader wants, and then attempt to please them. Be objective.
-1. Try to solve everything all at once. A pretty good solution now is MUCH BETTER than a perfect solution later. Carpe diem!
-1. Hide any doubts or unanswered questions.
-1. Make it a sales pitch. Everything has upsides and downsides - be authentic and honest about them.
-1. Perform merely a superficial investigation. If an ADR doesn't call for some deep thinking, then it probably shouldn't exist.
-1. Ignore the long-term costs such as performance, tech debt or hardware and maintenance.
-1. Get tunnel vision where creative or surprising approaches are not explored.
-
-# Template - use the format below for each new ADR
-
-1. **Author** - who has written the ADR
-1. **Status** - one of: PROPOSED, ACCEPTED, REJECTED, SUPERSEDED-BY or DEPRECATED
-1. **Date** - when the status was most recently updated
-1. **Problem** - a concise paragraph explaining the context
-1. **Criteria** - a list of the two or three metrics by which the solution was evaluated, and their relative weights (importance)
-1. **Decision** - what was chosen as the way forward, and what the consequences are of the decision
-
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -64,7 +64,7 @@ option(MG_ENTERPRISE "Build Memgraph Enterprise Edition" ON)
 # Set the current version here to override the automatic version detection. The
 # version must be specified as `X.Y.Z`. Primarily used when building new patch
 # versions.
-set(MEMGRAPH_OVERRIDE_VERSION "2.14.0")
+set(MEMGRAPH_OVERRIDE_VERSION "")

 # Custom suffix that this version should have. The suffix can be any arbitrary
 # string. Primarily used when building a version for a specific customer.
--- a/config/flags.yaml
+++ b/config/flags.yaml
@@ -111,14 +111,6 @@ modifications:
    value: "false"
    override: true

-  - name: "storage_parallel_schema_recovery"
-    value: "false"
-    override: true
-
-  - name: "storage_enable_schema_metadata"
-    value: "false"
-    override: true
-
  - name: "query_callable_mappings_path"
    value: "/etc/memgraph/apoc_compatibility_mappings.json"
    override: true
--- a/include/_mgp.hpp
+++ b/include/_mgp.hpp
@@ -234,6 +234,8 @@ inline mgp_type *type_duration() { return MgInvoke<mgp_type *>(mgp_type_duration

 inline mgp_type *type_nullable(mgp_type *type) { return MgInvoke<mgp_type *>(mgp_type_nullable, type); }

+// mgp_graph
+
 inline bool create_label_index(mgp_graph *graph, const char *label) {
  return MgInvoke<int>(mgp_create_label_index, graph, label);
 }
@@ -282,10 +284,6 @@ inline mgp_list *list_all_unique_constraints(mgp_graph *graph, mgp_memory *memor
  return MgInvoke<mgp_list *>(mgp_list_all_unique_constraints, graph, memory);
 }

-// mgp_graph
-  
-inline bool graph_is_transactional(mgp_graph *graph) { return MgInvoke<int>(mgp_graph_is_transactional, graph); }
-
 inline bool graph_is_mutable(mgp_graph *graph) { return MgInvoke<int>(mgp_graph_is_mutable, graph); }

 inline mgp_vertex *graph_create_vertex(mgp_graph *graph, mgp_memory *memory) {
@@ -378,8 +376,6 @@ inline mgp_list *list_copy(mgp_list *list, mgp_memory *memory) {

 inline void list_destroy(mgp_list *list) { mgp_list_destroy(list); }

-inline bool list_contains_deleted(mgp_list *list) { return MgInvoke<int>(mgp_list_contains_deleted, list); }
-
 inline void list_append(mgp_list *list, mgp_value *val) { MgInvokeVoid(mgp_list_append, list, val); }

 inline void list_append_extend(mgp_list *list, mgp_value *val) { MgInvokeVoid(mgp_list_append_extend, list, val); }
@@ -398,8 +394,6 @@ inline mgp_map *map_copy(mgp_map *map, mgp_memory *memory) { return MgInvoke<mgp

 inline void map_destroy(mgp_map *map) { mgp_map_destroy(map); }

-inline bool map_contains_deleted(mgp_map *map) { return MgInvoke<int>(mgp_map_contains_deleted, map); }
-
 inline void map_insert(mgp_map *map, const char *key, mgp_value *value) {
  MgInvokeVoid(mgp_map_insert, map, key, value);
 }
@@ -448,8 +442,6 @@ inline mgp_vertex *vertex_copy(mgp_vertex *v, mgp_memory *memory) {

 inline void vertex_destroy(mgp_vertex *v) { mgp_vertex_destroy(v); }

-inline bool vertex_is_deleted(mgp_vertex *v) { return MgInvoke<int>(mgp_vertex_is_deleted, v); }
-
 inline bool vertex_equal(mgp_vertex *v1, mgp_vertex *v2) { return MgInvoke<int>(mgp_vertex_equal, v1, v2); }

 inline size_t vertex_labels_count(mgp_vertex *v) { return MgInvoke<size_t>(mgp_vertex_labels_count, v); }
@@ -502,8 +494,6 @@ inline mgp_edge *edge_copy(mgp_edge *e, mgp_memory *memory) { return MgInvoke<mg

 inline void edge_destroy(mgp_edge *e) { mgp_edge_destroy(e); }

-inline bool edge_is_deleted(mgp_edge *e) { return MgInvoke<int>(mgp_edge_is_deleted, e); }
-
 inline bool edge_equal(mgp_edge *e1, mgp_edge *e2) { return MgInvoke<int>(mgp_edge_equal, e1, e2); }

 inline mgp_edge_type edge_get_type(mgp_edge *e) { return MgInvoke<mgp_edge_type>(mgp_edge_get_type, e); }
@@ -540,8 +530,6 @@ inline mgp_path *path_copy(mgp_path *path, mgp_memory *memory) {

 inline void path_destroy(mgp_path *path) { mgp_path_destroy(path); }

-inline bool path_contains_deleted(mgp_path *path) { return MgInvoke<int>(mgp_path_contains_deleted, path); }
-
 inline void path_expand(mgp_path *path, mgp_edge *edge) { MgInvokeVoid(mgp_path_expand, path, edge); }

 inline void path_pop(mgp_path *path) { MgInvokeVoid(mgp_path_pop, path); }
--- a/include/mg_exceptions.hpp
+++ b/include/mg_exceptions.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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,7 +25,7 @@ namespace mg_exception {
 template <typename FirstArg, typename... Args>
 std::string StringSerialize(FirstArg &&firstArg, Args &&...args) {
  std::stringstream stream;
-  stream << std::forward<FirstArg>(firstArg);
+  stream << firstArg;
  ((stream << " " << args), ...);
  return stream.str();
 }
--- a/include/mg_procedure.h
+++ b/include/mg_procedure.h
@@ -429,9 +429,6 @@ enum mgp_error mgp_list_copy(struct mgp_list *list, struct mgp_memory *memory, s
 /// Free the memory used by the given mgp_list and contained elements.
 void mgp_list_destroy(struct mgp_list *list);

-/// Return whether the given mgp_list contains any deleted values.
-enum mgp_error mgp_list_contains_deleted(struct mgp_list *list, int *result);
-
 /// Append a copy of mgp_value to mgp_list if capacity allows.
 /// The list copies the given value and therefore does not take ownership of the
 /// original value. You still need to call mgp_value_destroy to free the
@@ -472,9 +469,6 @@ enum mgp_error mgp_map_copy(struct mgp_map *map, struct mgp_memory *memory, stru
 /// Free the memory used by the given mgp_map and contained items.
 void mgp_map_destroy(struct mgp_map *map);

-/// Return whether the given mgp_map contains any deleted values.
-enum mgp_error mgp_map_contains_deleted(struct mgp_map *map, int *result);
-
 /// Insert a new mapping from a NULL terminated character string to a value.
 /// If a mapping with the same key already exists, it is *not* replaced.
 /// In case of insertion, both the string and the value are copied into the map.
@@ -558,9 +552,6 @@ enum mgp_error mgp_path_copy(struct mgp_path *path, struct mgp_memory *memory, s
 /// Free the memory used by the given mgp_path and contained vertices and edges.
 void mgp_path_destroy(struct mgp_path *path);

-/// Return whether the given mgp_path contains any deleted values.
-enum mgp_error mgp_path_contains_deleted(struct mgp_path *path, int *result);
-
 /// Append an edge continuing from the last vertex on the path.
 /// The edge is copied into the path. Therefore, the path does not take
 /// ownership of the original edge, so you still need to free the edge memory
@@ -734,9 +725,6 @@ enum mgp_error mgp_vertex_copy(struct mgp_vertex *v, struct mgp_memory *memory,
 /// Free the memory used by a mgp_vertex.
 void mgp_vertex_destroy(struct mgp_vertex *v);

-/// Return whether the given mgp_vertex is deleted.
-enum mgp_error mgp_vertex_is_deleted(struct mgp_vertex *v, int *result);
-
 /// Result is non-zero if given vertices are equal, otherwise 0.
 enum mgp_error mgp_vertex_equal(struct mgp_vertex *v1, struct mgp_vertex *v2, int *result);

@@ -831,9 +819,6 @@ enum mgp_error mgp_edge_copy(struct mgp_edge *e, struct mgp_memory *memory, stru
 /// Free the memory used by a mgp_edge.
 void mgp_edge_destroy(struct mgp_edge *e);

-/// Return whether the given mgp_edge is deleted.
-enum mgp_error mgp_edge_is_deleted(struct mgp_edge *e, int *result);
-
 /// Result is non-zero if given edges are equal, otherwise 0.
 enum mgp_error mgp_edge_equal(struct mgp_edge *e1, struct mgp_edge *e2, int *result);

@@ -956,12 +941,6 @@ enum mgp_error mgp_list_all_unique_constraints(struct mgp_graph *graph, struct m
 /// Current implementation always returns without errors.
 enum mgp_error mgp_graph_is_mutable(struct mgp_graph *graph, int *result);

-/// Result is non-zero if the graph is in transactional storage mode.
-/// If a graph is not in transactional mode (i.e. analytical mode), then vertices and edges can be missing
-/// because changes from other transactions are visible.
-/// Current implementation always returns without errors.
-enum mgp_error mgp_graph_is_transactional(struct mgp_graph *graph, int *result);
-
 /// Add a new vertex to the graph.
 /// Resulting vertex must be freed using mgp_vertex_destroy.
 /// Return mgp_error::MGP_ERROR_IMMUTABLE_OBJECT if `graph` is immutable.
--- a/include/mgp.hpp
+++ b/include/mgp.hpp
--- a/libs/setup.sh
+++ b/libs/setup.sh
@@ -259,7 +259,7 @@ repo_clone_try_double "${primary_urls[absl]}" "${secondary_urls[absl]}" "absl" "

 # jemalloc ea6b3e973b477b8061e0076bb257dbd7f3faa756
 JEMALLOC_COMMIT_VERSION="5.2.1"
-repo_clone_try_double "${primary_urls[jemalloc]}" "${secondary_urls[jemalloc]}" "jemalloc" "$JEMALLOC_COMMIT_VERSION"
+repo_clone_try_double "${secondary_urls[jemalloc]}" "${secondary_urls[jemalloc]}" "jemalloc" "$JEMALLOC_COMMIT_VERSION"

 # this is hack for cmake in libs to set path, and for FindJemalloc to use Jemalloc_INCLUDE_DIR
 pushd jemalloc
--- a/licenses/BSL.txt
+++ b/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:            2028-21-01
+CHANGE DATE:            2027-30-10
 CHANGE LICENSE:         Apache License, Version 2.0

 For information about alternative licensing arrangements, please visit: https://memgraph.com/legal.
--- a/query_modules/schema.cpp
+++ b/query_modules/schema.cpp
@@ -108,83 +108,32 @@ void Schema::ProcessPropertiesRel(mgp::Record &record, const std::string_view &t
  record.Insert(std::string(kReturnMandatory).c_str(), mandatory);
 }

-struct Property {
-  std::string name;
-  mgp::Value value;
-
-  Property(const std::string &name, mgp::Value &&value) : name(name), value(std::move(value)) {}
-};
-
-struct LabelsHash {
-  std::size_t operator()(const std::set<std::string> &set) const {
-    std::size_t seed = set.size();
-    for (const auto &i : set) {
-      seed ^= std::hash<std::string>{}(i) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-    }
-    return seed;
-  }
-};
-
-struct LabelsComparator {
-  bool operator()(const std::set<std::string> &lhs, const std::set<std::string> &rhs) const { return lhs == rhs; }
-};
-
-struct PropertyComparator {
-  bool operator()(const Property &lhs, const Property &rhs) const { return lhs.name < rhs.name; }
-};
-
-struct PropertyInfo {
-  std::set<Property, PropertyComparator> properties;
-  bool mandatory;
-};
-
 void Schema::NodeTypeProperties(mgp_list * /*args*/, mgp_graph *memgraph_graph, mgp_result *result,
                                mgp_memory *memory) {
  mgp::MemoryDispatcherGuard guard{memory};
+  ;
  const auto record_factory = mgp::RecordFactory(result);
  try {
-    std::unordered_map<std::set<std::string>, PropertyInfo, LabelsHash, LabelsComparator> node_types_properties;
-
-    for (auto node : mgp::Graph(memgraph_graph).Nodes()) {
-      std::set<std::string> labels_set = {};
+    const mgp::Graph graph = mgp::Graph(memgraph_graph);
+    for (auto node : graph.Nodes()) {
+      std::string type;
+      mgp::List labels = mgp::List();
      for (auto label : node.Labels()) {
-        labels_set.emplace(label);
-      }
-
-      if (node_types_properties.find(labels_set) == node_types_properties.end()) {
-        node_types_properties[labels_set] = PropertyInfo{std::set<Property, PropertyComparator>(), true};
+        labels.AppendExtend(mgp::Value(label));
+        type += ":`" + std::string(label) + "`";
      }

      if (node.Properties().empty()) {
-        node_types_properties[labels_set].mandatory = false;  // if there is node with no property, it is not mandatory
+        auto record = record_factory.NewRecord();
+        ProcessPropertiesNode<std::string>(record, type, labels, "", "", false);
        continue;
      }

-      auto &property_info = node_types_properties.at(labels_set);
      for (auto &[key, prop] : node.Properties()) {
-        property_info.properties.emplace(key, std::move(prop));
-        if (property_info.mandatory) {
-          property_info.mandatory =
-              property_info.properties.size() == 1;  // if there is only one property, it is mandatory
-        }
-      }
-    }
-
-    for (auto &[labels, property_info] : node_types_properties) {
-      std::string label_type;
-      mgp::List labels_list = mgp::List();
-      for (auto const &label : labels) {
-        label_type += ":`" + std::string(label) + "`";
-        labels_list.AppendExtend(mgp::Value(label));
-      }
-      for (auto const &prop : property_info.properties) {
+        auto property_type = mgp::List();
        auto record = record_factory.NewRecord();
-        ProcessPropertiesNode(record, label_type, labels_list, prop.name, TypeOf(prop.value.Type()),
-                              property_info.mandatory);
-      }
-      if (property_info.properties.empty()) {
-        auto record = record_factory.NewRecord();
-        ProcessPropertiesNode<std::string>(record, label_type, labels_list, "", "", false);
+        property_type.AppendExtend(mgp::Value(TypeOf(prop.Type())));
+        ProcessPropertiesNode<mgp::List>(record, type, labels, key, property_type, true);
      }
    }

@@ -196,41 +145,23 @@ void Schema::NodeTypeProperties(mgp_list * /*args*/, mgp_graph *memgraph_graph,

 void Schema::RelTypeProperties(mgp_list * /*args*/, mgp_graph *memgraph_graph, mgp_result *result, mgp_memory *memory) {
  mgp::MemoryDispatcherGuard guard{memory};
-
-  std::unordered_map<std::string, PropertyInfo> rel_types_properties;
  const auto record_factory = mgp::RecordFactory(result);
  try {
    const mgp::Graph graph = mgp::Graph(memgraph_graph);
-    for (auto rel : graph.Relationships()) {
-      std::string rel_type = std::string(rel.Type());
-      if (rel_types_properties.find(rel_type) == rel_types_properties.end()) {
-        rel_types_properties[rel_type] = PropertyInfo{std::set<Property, PropertyComparator>(), true};
-      }

+    for (auto rel : graph.Relationships()) {
+      std::string type = ":`" + std::string(rel.Type()) + "`";
      if (rel.Properties().empty()) {
-        rel_types_properties[rel_type].mandatory = false;  // if there is rel with no property, it is not mandatory
+        auto record = record_factory.NewRecord();
+        ProcessPropertiesRel<std::string>(record, type, "", "", false);
        continue;
      }

-      auto &property_info = rel_types_properties.at(rel_type);
      for (auto &[key, prop] : rel.Properties()) {
-        property_info.properties.emplace(key, std::move(prop));
-        if (property_info.mandatory) {
-          property_info.mandatory =
-              property_info.properties.size() == 1;  // if there is only one property, it is mandatory
-        }
-      }
-    }
-
-    for (auto &[type, property_info] : rel_types_properties) {
-      std::string type_str = ":`" + std::string(type) + "`";
-      for (auto const &prop : property_info.properties) {
+        auto property_type = mgp::List();
        auto record = record_factory.NewRecord();
-        ProcessPropertiesRel(record, type_str, prop.name, TypeOf(prop.value.Type()), property_info.mandatory);
-      }
-      if (property_info.properties.empty()) {
-        auto record = record_factory.NewRecord();
-        ProcessPropertiesRel<std::string>(record, type_str, "", "", false);
+        property_type.AppendExtend(mgp::Value(TypeOf(prop.Type())));
+        ProcessPropertiesRel<mgp::List>(record, type, key, property_type, true);
      }
    }

@@ -639,6 +570,7 @@ void Schema::Assert(mgp_list *args, mgp_graph *memgraph_graph, mgp_result *resul
 extern "C" int mgp_init_module(struct mgp_module *module, struct mgp_memory *memory) {
  try {
    mgp::MemoryDispatcherGuard guard{memory};
+    ;

    AddProcedure(Schema::NodeTypeProperties, Schema::kProcedureNodeType, mgp::ProcedureType::Read, {},
                 {mgp::Return(Schema::kReturnNodeType, mgp::Type::String),
--- a/release/get_version.py
+++ b/release/get_version.py
@@ -104,9 +104,7 @@ def retry(retry_limit, timeout=100):
                except Exception:
                    time.sleep(timeout)
            return func(*args, **kwargs)
-
        return wrapper
-
    return inner_func


@@ -202,19 +200,19 @@ if args.version:
 try:
    current_branch = get_output("git", "rev-parse", "--abbrev-ref", "HEAD")
    if current_branch != "master":
-        branches = get_output("git", "branch", "-r", "--list", "origin/master")
-        if "origin/master" in branches:
+        branches = get_output("git", "branch")
+        if "master" in branches:
            # If master is present locally, the fetch is allowed to fail
            # because this script will still be able to compare against the
            # master branch.
            try:
-                get_output("git", "fetch", "origin", "master")
+                get_output("git", "fetch", "origin", "master:master")
            except Exception:
                pass
        else:
            # If master is not present locally, the fetch command has to
            # succeed because something else will fail otherwise.
-            get_output("git", "fetch", "origin", "master")
+            get_output("git", "fetch", "origin", "master:master")
 except Exception:
    print("Fatal error while ensuring local master branch.")
    sys.exit(1)
@@ -234,7 +232,7 @@ for branch in branches:
    match = branch_regex.match(branch)
    if match is not None:
        version = tuple(map(int, match.group(1).split(".")))
-        master_branch_merge = get_output("git", "merge-base", "origin/master", branch)
+        master_branch_merge = get_output("git", "merge-base", "master", branch)
        versions.append((version, branch, master_branch_merge))
 versions.sort(reverse=True)

@@ -245,7 +243,7 @@ current_version = None
 for version in versions:
    version_tuple, branch, master_branch_merge = version
    current_branch_merge = get_output("git", "merge-base", current_hash, branch)
-    master_current_merge = get_output("git", "merge-base", current_hash, "origin/master")
+    master_current_merge = get_output("git", "merge-base", current_hash, "master")
    # The first check checks whether this commit is a child of `master` and
    # the version branch was created before us.
    # The second check checks whether this commit is a child of the version
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -53,10 +53,7 @@ set_target_properties(memgraph PROPERTIES
        OUTPUT_NAME "memgraph-${MEMGRAPH_VERSION}_${CMAKE_BUILD_TYPE}"

        # Output the executable in main binary dir.
-        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}
-
-        POSITION_INDEPENDENT_CODE ON
-        )
+        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})

 # Create symlink to the built executable.
 add_custom_command(TARGET memgraph POST_BUILD
--- a/src/audit/log.cpp
+++ b/src/audit/log.cpp
@@ -13,7 +13,6 @@

 #include <fmt/format.h>
 #include <json/json.hpp>
-#include <utility>

 #include "storage/v2/temporal.hpp"
 #include "utils/logging.hpp"
@@ -88,8 +87,8 @@ inline nlohmann::json PropertyValueToJson(const storage::PropertyValue &pv) {
  return ret;
 }

-Log::Log(std::filesystem::path storage_directory, int32_t buffer_size, int32_t buffer_flush_interval_millis)
-    : storage_directory_(std::move(storage_directory)),
+Log::Log(const std::filesystem::path &storage_directory, int32_t buffer_size, int32_t buffer_flush_interval_millis)
+    : storage_directory_(storage_directory),
      buffer_size_(buffer_size),
      buffer_flush_interval_millis_(buffer_flush_interval_millis),
      started_(false) {}
--- a/src/audit/log.hpp
+++ b/src/audit/log.hpp
@@ -36,7 +36,7 @@ class Log {
  };

 public:
-  Log(std::filesystem::path storage_directory, int32_t buffer_size, int32_t buffer_flush_interval_millis);
+  Log(const std::filesystem::path &storage_directory, int32_t buffer_size, int32_t buffer_flush_interval_millis);

  ~Log();

--- a/src/auth/models.cpp
+++ b/src/auth/models.cpp
@@ -10,7 +10,6 @@

 #include <cstdint>
 #include <regex>
-#include <utility>

 #include <gflags/gflags.h>

@@ -561,20 +560,20 @@ Databases Databases::Deserialize(const nlohmann::json &data) {
 }
 #endif

-User::User() = default;
+User::User() {}

 User::User(const std::string &username) : username_(utils::ToLowerCase(username)) {}
-User::User(const std::string &username, std::string password_hash, const Permissions &permissions)
-    : username_(utils::ToLowerCase(username)), password_hash_(std::move(password_hash)), permissions_(permissions) {}
+User::User(const std::string &username, const std::string &password_hash, const Permissions &permissions)
+    : username_(utils::ToLowerCase(username)), password_hash_(password_hash), permissions_(permissions) {}

 #ifdef MG_ENTERPRISE
-User::User(const std::string &username, std::string password_hash, const Permissions &permissions,
+User::User(const std::string &username, const std::string &password_hash, const Permissions &permissions,
           FineGrainedAccessHandler fine_grained_access_handler, Databases db_access)
    : username_(utils::ToLowerCase(username)),
-      password_hash_(std::move(password_hash)),
+      password_hash_(password_hash),
      permissions_(permissions),
      fine_grained_access_handler_(std::move(fine_grained_access_handler)),
-      database_access_(std::move(db_access)) {}
+      database_access_(db_access) {}
 #endif

 bool User::CheckPassword(const std::string &password) {
--- a/src/auth/models.hpp
+++ b/src/auth/models.hpp
@@ -14,7 +14,6 @@
 #include <unordered_map>

 #include <json/json.hpp>
-#include <utility>
 #include "dbms/constants.hpp"
 #include "utils/logging.hpp"

@@ -302,8 +301,8 @@ class Databases final {
  bool Contains(const std::string &db) const;

  bool GetAllowAll() const { return allow_all_; }
-  const std::set<std::string, std::less<>> &GetGrants() const { return grants_dbs_; }
-  const std::set<std::string, std::less<>> &GetDenies() const { return denies_dbs_; }
+  const std::set<std::string> &GetGrants() const { return grants_dbs_; }
+  const std::set<std::string> &GetDenies() const { return denies_dbs_; }
  const std::string &GetDefault() const;

  nlohmann::json Serialize() const;
@@ -311,17 +310,14 @@ class Databases final {
  static Databases Deserialize(const nlohmann::json &data);

 private:
-  Databases(bool allow_all, std::set<std::string, std::less<>> grant, std::set<std::string, std::less<>> deny,
-            std::string default_db = dbms::kDefaultDB)
-      : grants_dbs_(std::move(grant)),
-        denies_dbs_(std::move(deny)),
-        allow_all_(allow_all),
-        default_db_(std::move(default_db)) {}
+  Databases(bool allow_all, std::set<std::string> grant, std::set<std::string> deny,
+            const std::string &default_db = dbms::kDefaultDB)
+      : grants_dbs_(grant), denies_dbs_(deny), allow_all_(allow_all), default_db_(default_db) {}

-  std::set<std::string, std::less<>> grants_dbs_;  //!< set of databases with granted access
-  std::set<std::string, std::less<>> denies_dbs_;  //!< set of databases with denied access
-  bool allow_all_;                                 //!< flag to allow access to everything (denied overrides this)
-  std::string default_db_;                         //!< user's default database
+  std::set<std::string> grants_dbs_;  //!< set of databases with granted access
+  std::set<std::string> denies_dbs_;  //!< set of databases with denied access
+  bool allow_all_;                    //!< flag to allow access to everything (denied overrides this)
+  std::string default_db_;            //!< user's default database
 };
 #endif

@@ -331,9 +327,9 @@ class User final {
  User();

  explicit User(const std::string &username);
-  User(const std::string &username, std::string password_hash, const Permissions &permissions);
+  User(const std::string &username, const std::string &password_hash, const Permissions &permissions);
 #ifdef MG_ENTERPRISE
-  User(const std::string &username, std::string password_hash, const Permissions &permissions,
+  User(const std::string &username, const std::string &password_hash, const Permissions &permissions,
       FineGrainedAccessHandler fine_grained_access_handler, Databases db_access = {});
 #endif
  User(const User &) = default;
--- a/src/communication/bolt/client.hpp
+++ b/src/communication/bolt/client.hpp
@@ -14,7 +14,6 @@
 #include <map>
 #include <optional>
 #include <string>
-#include <utility>
 #include <vector>

 #include "communication/bolt/v1/codes.hpp"
@@ -35,8 +34,8 @@ class FailureResponseException : public utils::BasicException {

  explicit FailureResponseException(const std::string &message) : utils::BasicException{message} {}

-  FailureResponseException(std::string code, const std::string &message)
-      : utils::BasicException{message}, code_{std::move(code)} {}
+  FailureResponseException(const std::string &code, const std::string &message)
+      : utils::BasicException{message}, code_{code} {}

  const std::string &code() const { return code_; }
  SPECIALIZE_GET_EXCEPTION_NAME(FailureResponseException)
--- a/src/communication/bolt/v1/decoder/chunked_decoder_buffer.hpp
+++ b/src/communication/bolt/v1/decoder/chunked_decoder_buffer.hpp
@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -51,7 +51,7 @@ enum class ChunkState : uint8_t {
 template <typename TBuffer>
 class ChunkedDecoderBuffer {
 public:
-  explicit ChunkedDecoderBuffer(TBuffer &buffer) : buffer_(buffer) { data_.reserve(kChunkMaxDataSize); }
+  ChunkedDecoderBuffer(TBuffer &buffer) : buffer_(buffer) { data_.reserve(kChunkMaxDataSize); }

  /**
   * Reads data from the internal buffer.
--- a/src/communication/bolt/v1/decoder/decoder.hpp
+++ b/src/communication/bolt/v1/decoder/decoder.hpp
@@ -401,11 +401,11 @@ class Decoder {
    }
    auto &labels = dv.ValueList();
    vertex.labels.reserve(labels.size());
-    for (auto &label : labels) {
-      if (label.type() != Value::Type::String) {
+    for (size_t i = 0; i < labels.size(); ++i) {
+      if (labels[i].type() != Value::Type::String) {
        return false;
      }
-      vertex.labels.emplace_back(std::move(label.ValueString()));
+      vertex.labels.emplace_back(std::move(labels[i].ValueString()));
    }

    // read properties
--- a/src/communication/bolt/v1/encoder/base_encoder.hpp
+++ b/src/communication/bolt/v1/encoder/base_encoder.hpp
@@ -111,12 +111,12 @@ class BaseEncoder {

  void WriteList(const std::vector<Value> &value) {
    WriteTypeSize(value.size(), MarkerList);
-    for (const auto &x : value) WriteValue(x);
+    for (auto &x : value) WriteValue(x);
  }

  void WriteMap(const std::map<std::string, Value> &value) {
    WriteTypeSize(value.size(), MarkerMap);
-    for (const auto &x : value) {
+    for (auto &x : value) {
      WriteString(x.first);
      WriteValue(x.second);
    }
@@ -205,11 +205,11 @@ class BaseEncoder {
    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct) + 3);
    WriteRAW(utils::UnderlyingCast(Signature::Path));
    WriteTypeSize(path.vertices.size(), MarkerList);
-    for (const auto &v : path.vertices) WriteVertex(v);
+    for (auto &v : path.vertices) WriteVertex(v);
    WriteTypeSize(path.edges.size(), MarkerList);
-    for (const auto &e : path.edges) WriteEdge(e);
+    for (auto &e : path.edges) WriteEdge(e);
    WriteTypeSize(path.indices.size(), MarkerList);
-    for (const auto &i : path.indices) WriteInt(i);
+    for (auto &i : path.indices) WriteInt(i);
  }

  void WriteDate(const utils::Date &date) {
--- a/src/communication/bolt/v1/encoder/chunked_encoder_buffer.hpp
+++ b/src/communication/bolt/v1/encoder/chunked_encoder_buffer.hpp
@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -48,7 +48,7 @@ namespace memgraph::communication::bolt {
 template <class TOutputStream>
 class ChunkedEncoderBuffer {
 public:
-  explicit ChunkedEncoderBuffer(TOutputStream &output_stream) : output_stream_(output_stream) {}
+  ChunkedEncoderBuffer(TOutputStream &output_stream) : output_stream_(output_stream) {}

  /**
   * Writes n values into the buffer. If n is bigger than whole chunk size
--- a/src/communication/bolt/v1/encoder/client_encoder.hpp
+++ b/src/communication/bolt/v1/encoder/client_encoder.hpp
@@ -39,7 +39,7 @@ class ClientEncoder : private BaseEncoder<Buffer> {
  using BaseEncoder<Buffer>::buffer_;

 public:
-  explicit ClientEncoder(Buffer &buffer) : BaseEncoder<Buffer>(buffer) {}
+  ClientEncoder(Buffer &buffer) : BaseEncoder<Buffer>(buffer) {}

  using BaseEncoder<Buffer>::UpdateVersion;

--- a/src/communication/bolt/v1/encoder/encoder.hpp
+++ b/src/communication/bolt/v1/encoder/encoder.hpp
@@ -32,7 +32,7 @@ class Encoder : private BaseEncoder<Buffer> {
  using BaseEncoder<Buffer>::buffer_;

 public:
-  explicit Encoder(Buffer &buffer) : BaseEncoder<Buffer>(buffer) {}
+  Encoder(Buffer &buffer) : BaseEncoder<Buffer>(buffer) {}

  using BaseEncoder<Buffer>::UpdateVersion;

--- a/src/communication/bolt/v1/states/handlers.hpp
+++ b/src/communication/bolt/v1/states/handlers.hpp
@@ -93,7 +93,7 @@ State HandlePullDiscard(TSession &session, std::optional<int> n, std::optional<i
      return State::Close;
    }

-    if (summary.contains("has_more") && summary.at("has_more").ValueBool()) {
+    if (summary.count("has_more") && summary.at("has_more").ValueBool()) {
      return State::Result;
    }

@@ -148,13 +148,13 @@ State HandlePullDiscardV4(TSession &session, const State state, const Marker mar
    spdlog::trace("Couldn't read extra field!");
  }
  const auto &extra_map = extra.ValueMap();
-  if (extra_map.contains("n")) {
+  if (extra_map.count("n")) {
    if (const auto n_value = extra_map.at("n").ValueInt(); n_value != kPullAll) {
      n = n_value;
    }
  }

-  if (extra_map.contains("qid")) {
+  if (extra_map.count("qid")) {
    if (const auto qid_value = extra_map.at("qid").ValueInt(); qid_value != kPullLast) {
      qid = qid_value;
    }
@@ -367,16 +367,14 @@ State HandleReset(TSession &session, const Marker marker) {
    return State::Close;
  }

-  try {
-    session.Abort();
-    if (!session.encoder_.MessageSuccess({})) {
-      spdlog::trace("Couldn't send success message!");
-      return State::Close;
-    }
-    return State::Idle;
-  } catch (const std::exception &e) {
-    return HandleFailure(session, e);
+  if (!session.encoder_.MessageSuccess()) {
+    spdlog::trace("Couldn't send success message!");
+    return State::Close;
  }
+
+  session.Abort();
+
+  return State::Idle;
 }

 template <typename TSession>
@@ -399,17 +397,19 @@ State HandleBegin(TSession &session, const State state, const Marker marker) {

  DMG_ASSERT(!session.encoder_buffer_.HasData(), "There should be no data to write in this state");

+  if (!session.encoder_.MessageSuccess({})) {
+    spdlog::trace("Couldn't send success message!");
+    return State::Close;
+  }
+
  try {
    session.Configure(extra.ValueMap());
    session.BeginTransaction(extra.ValueMap());
-    if (!session.encoder_.MessageSuccess({})) {
-      spdlog::trace("Couldn't send success message!");
-      return State::Close;
-    }
-    return State::Idle;
  } catch (const std::exception &e) {
    return HandleFailure(session, e);
  }
+
+  return State::Idle;
 }

 template <typename TSession>
@@ -427,11 +427,11 @@ State HandleCommit(TSession &session, const State state, const Marker marker) {
  DMG_ASSERT(!session.encoder_buffer_.HasData(), "There should be no data to write in this state");

  try {
-    session.CommitTransaction();
    if (!session.encoder_.MessageSuccess({})) {
      spdlog::trace("Couldn't send success message!");
      return State::Close;
    }
+    session.CommitTransaction();
    return State::Idle;
  } catch (const std::exception &e) {
    return HandleFailure(session, e);
@@ -453,11 +453,11 @@ State HandleRollback(TSession &session, const State state, const Marker marker)
  DMG_ASSERT(!session.encoder_buffer_.HasData(), "There should be no data to write in this state");

  try {
-    session.RollbackTransaction();
    if (!session.encoder_.MessageSuccess({})) {
      spdlog::trace("Couldn't send success message!");
      return State::Close;
    }
+    session.RollbackTransaction();
    return State::Idle;
  } catch (const std::exception &e) {
    return HandleFailure(session, e);
--- a/src/communication/bolt/v1/states/init.hpp
+++ b/src/communication/bolt/v1/states/init.hpp
@@ -42,11 +42,11 @@ std::optional<State> AuthenticateUser(TSession &session, Value &metadata) {
  std::string username;
  std::string password;
  if (data["scheme"].ValueString() == "basic") {
-    if (!data.contains("principal")) {  // Special case principal = ""
+    if (!data.count("principal")) {  // Special case principal = ""
      spdlog::warn("The client didn't supply the principal field! Trying with \"\"...");
      data["principal"] = "";
    }
-    if (!data.contains("credentials")) {  // Special case credentials = ""
+    if (!data.count("credentials")) {  // Special case credentials = ""
      spdlog::warn("The client didn't supply the credentials field! Trying with \"\"...");
      data["credentials"] = "";
    }
@@ -118,7 +118,7 @@ std::optional<Value> GetMetadataV4(TSession &session, const Marker marker) {
  }

  auto &data = metadata.ValueMap();
-  if (!data.contains("user_agent")) {
+  if (!data.count("user_agent")) {
    spdlog::warn("The client didn't supply the user agent!");
    return std::nullopt;
  }
@@ -142,7 +142,7 @@ std::optional<Value> GetInitDataV5(TSession &session, const Marker marker) {
  }

  const auto &data = metadata.ValueMap();
-  if (!data.contains("user_agent")) {
+  if (!data.count("user_agent")) {
    spdlog::warn("The client didn't supply the user agent!");
    return std::nullopt;
  }
--- a/src/communication/bolt/v1/value.hpp
+++ b/src/communication/bolt/v1/value.hpp
@@ -91,7 +91,7 @@ struct UnboundedEdge {
 * The decoder writes data into this structure.
 */
 struct Path {
-  Path() = default;
+  Path() {}

  Path(const std::vector<Vertex> &vertices, const std::vector<Edge> &edges) {
    // Helper function. Looks for the given element in the collection. If found,
--- a/src/communication/client.cpp
+++ b/src/communication/client.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -12,7 +12,6 @@
 #include "communication/client.hpp"

 #include "communication/helpers.hpp"
-#include "io/network/network_error.hpp"
 #include "utils/logging.hpp"

 namespace memgraph::communication {
@@ -26,9 +25,7 @@ Client::~Client() {

 bool Client::Connect(const io::network::Endpoint &endpoint) {
  // Try to establish a socket connection.
-  if (!socket_.Connect(endpoint)) {
-    return false;
-  }
+  if (!socket_.Connect(endpoint)) return false;

  // Enable TCP keep alive for all connections.
  // Because we manually always set the `have_more` flag to the socket
--- a/src/communication/client.hpp
+++ b/src/communication/client.hpp
@@ -132,7 +132,7 @@ class Client final {
 */
 class ClientInputStream final {
 public:
-  explicit ClientInputStream(Client &client);
+  ClientInputStream(Client &client);

  ClientInputStream(const ClientInputStream &) = delete;
  ClientInputStream(ClientInputStream &&) = delete;
@@ -156,7 +156,7 @@ class ClientInputStream final {
 */
 class ClientOutputStream final {
 public:
-  explicit ClientOutputStream(Client &client);
+  ClientOutputStream(Client &client);

  ClientOutputStream(const ClientOutputStream &) = delete;
  ClientOutputStream(ClientOutputStream &&) = delete;
--- a/src/communication/context.cpp
+++ b/src/communication/context.cpp
@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -34,7 +34,7 @@ ClientContext::ClientContext(bool use_ssl) : use_ssl_(use_ssl), ctx_(nullptr) {
 }

 ClientContext::ClientContext(const std::string &key_file, const std::string &cert_file) : ClientContext(true) {
-  if (!key_file.empty() && !cert_file.empty()) {
+  if (key_file != "" && cert_file != "") {
    MG_ASSERT(SSL_CTX_use_certificate_file(ctx_, cert_file.c_str(), SSL_FILETYPE_PEM) == 1,
              "Couldn't load client certificate from file: {}", cert_file);
    MG_ASSERT(SSL_CTX_use_PrivateKey_file(ctx_, key_file.c_str(), SSL_FILETYPE_PEM) == 1,
@@ -124,7 +124,7 @@ ServerContext &ServerContext::operator=(ServerContext &&other) noexcept {
  return *this;
 }

-ServerContext::~ServerContext() = default;
+ServerContext::~ServerContext() {}

 SSL_CTX *ServerContext::context() {
  MG_ASSERT(ctx_);
--- a/src/communication/helpers.cpp
+++ b/src/communication/helpers.cpp
@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -15,7 +15,7 @@

 namespace memgraph::communication {

-std::string SslGetLastError() {
+const std::string SslGetLastError() {
  char buff[2048];
  auto err = ERR_get_error();
  ERR_error_string_n(err, buff, sizeof(buff));
--- a/src/communication/helpers.hpp
+++ b/src/communication/helpers.hpp
@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -18,6 +18,6 @@ namespace memgraph::communication {
 /**
 * This function reads and returns a string describing the last OpenSSL error.
 */
-std::string SslGetLastError();
+const std::string SslGetLastError();

 }  // namespace memgraph::communication
--- a/src/communication/http/listener.hpp
+++ b/src/communication/http/listener.hpp
@@ -38,7 +38,7 @@ class Listener final : public std::enable_shared_from_this<Listener<TRequestHand
  Listener(Listener &&) = delete;
  Listener &operator=(const Listener &) = delete;
  Listener &operator=(Listener &&) = delete;
-  ~Listener() = default;
+  ~Listener() {}

  template <typename... Args>
  static std::shared_ptr<Listener> Create(Args &&...args) {
--- a/src/communication/http/session.hpp
+++ b/src/communication/http/session.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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
@@ -107,7 +107,7 @@ class Session : public std::enable_shared_from_this<Session<TRequestHandler, TSe
  void DoRead() {
    req_ = {};

-    ExecuteForStream([this](auto &stream) {
+    ExecuteForStream([this](auto &&stream) {
      boost::beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(kSSLExpirySeconds));

      boost::beast::http::async_read(
@@ -129,7 +129,7 @@ class Session : public std::enable_shared_from_this<Session<TRequestHandler, TSe
    }

    auto async_write = [this](boost::beast::http::response<boost::beast::http::string_body> msg) {
-      ExecuteForStream([this, &msg](auto &stream) {
+      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.
@@ -171,7 +171,7 @@ class Session : public std::enable_shared_from_this<Session<TRequestHandler, TSe
  }

  auto GetExecutor() {
-    return std::visit(utils::Overloaded{[](auto &stream) { return stream.get_executor(); }}, stream_);
+    return std::visit(utils::Overloaded{[](auto &&stream) { return stream.get_executor(); }}, stream_);
  }

  template <typename F>
--- a/src/communication/listener.hpp
+++ b/src/communication/listener.hpp
@@ -17,7 +17,6 @@
 #include <memory>
 #include <mutex>
 #include <thread>
-#include <utility>

 #include <gflags/gflags.h>

@@ -52,13 +51,13 @@ class Listener final {
  using SessionHandler = Session<TSession, TSessionContext>;

 public:
-  Listener(TSessionContext *data, ServerContext *context, int inactivity_timeout_sec, std::string service_name,
+  Listener(TSessionContext *data, ServerContext *context, int inactivity_timeout_sec, const std::string &service_name,
           size_t workers_count)
      : data_(data),
        alive_(false),
        context_(context),
        inactivity_timeout_sec_(inactivity_timeout_sec),
-        service_name_(std::move(service_name)),
+        service_name_(service_name),
        workers_count_(workers_count) {}

  ~Listener() {
--- a/src/communication/result_stream_faker.hpp
+++ b/src/communication/result_stream_faker.hpp
@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -80,7 +80,7 @@ class ResultStreamFaker {
    std::transform(header.begin(), header.end(), column_widths.begin(), [](const auto &s) { return s.size(); });

    // convert all the results into strings, and track max column width
-    const auto &results_data = results.GetResults();
+    auto &results_data = results.GetResults();
    std::vector<std::vector<std::string>> result_strings(results_data.size(),
                                                         std::vector<std::string>(column_widths.size()));
    for (int row_ind = 0; row_ind < static_cast<int>(results_data.size()); ++row_ind) {
--- a/src/communication/session.hpp
+++ b/src/communication/session.hpp
@@ -17,7 +17,6 @@
 #include <memory>
 #include <mutex>
 #include <thread>
-#include <utility>

 #include <openssl/bio.h>
 #include <openssl/err.h>
@@ -52,8 +51,7 @@ using InputStream = Buffer::ReadEnd;
 */
 class OutputStream final {
 public:
-  explicit OutputStream(std::function<bool(const uint8_t *, size_t, bool)> write_function)
-      : write_function_(std::move(write_function)) {}
+  OutputStream(std::function<bool(const uint8_t *, size_t, bool)> write_function) : write_function_(write_function) {}

  OutputStream(const OutputStream &) = delete;
  OutputStream(OutputStream &&) = delete;
--- a/src/communication/v2/listener.hpp
+++ b/src/communication/v2/listener.hpp
@@ -47,7 +47,7 @@ class Listener final : public std::enable_shared_from_this<Listener<TSession, TS
  Listener(Listener &&) = delete;
  Listener &operator=(const Listener &) = delete;
  Listener &operator=(Listener &&) = delete;
-  ~Listener() = default;
+  ~Listener() {}

  template <typename... Args>
  static std::shared_ptr<Listener> Create(Args &&...args) {
--- a/src/communication/v2/session.hpp
+++ b/src/communication/v2/session.hpp
@@ -76,7 +76,7 @@ using tcp = boost::asio::ip::tcp;
 class OutputStream final {
 public:
  explicit OutputStream(std::function<bool(const uint8_t *, size_t, bool)> write_function)
-      : write_function_(std::move(write_function)) {}
+      : write_function_(write_function) {}

  OutputStream(const OutputStream &) = delete;
  OutputStream(OutputStream &&) = delete;
--- a/src/communication/websocket/server.hpp
+++ b/src/communication/websocket/server.hpp
@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -16,7 +16,6 @@
 #include <spdlog/sinks/base_sink.h>
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/ip/tcp.hpp>
-#include <utility>

 #include "communication/websocket/listener.hpp"
 #include "io/network/endpoint.hpp"
@@ -46,7 +45,7 @@ class Server final {

  class LoggingSink : public spdlog::sinks::base_sink<std::mutex> {
   public:
-    explicit LoggingSink(std::weak_ptr<Listener> listener) : listener_(std::move(listener)) {}
+    explicit LoggingSink(std::weak_ptr<Listener> listener) : listener_(listener) {}

   private:
    void sink_it_(const spdlog::details::log_msg &msg) override;
--- a/src/dbms/CMakeLists.txt
+++ b/src/dbms/CMakeLists.txt
@@ -1,3 +1,3 @@

-add_library(mg-dbms STATIC dbms_handler.cpp database.cpp replication_handler.cpp replication_client.cpp inmemory/replication_handlers.cpp)
+add_library(mg-dbms STATIC database.cpp replication_handler.cpp inmemory/replication_handlers.cpp)
 target_link_libraries(mg-dbms mg-utils mg-storage-v2 mg-query)
--- a/src/dbms/constants.hpp
+++ b/src/dbms/constants.hpp
@@ -15,10 +15,4 @@ namespace memgraph::dbms {

 constexpr static const char *kDefaultDB = "memgraph";  //!< Name of the default database

-#ifdef MG_EXPERIMENTAL_REPLICATION_MULTITENANCY
-constexpr bool allow_mt_repl = true;
-#else
-constexpr bool allow_mt_repl = false;
-#endif
-
 }  // namespace memgraph::dbms
--- a/src/dbms/database.cpp
+++ b/src/dbms/database.cpp
@@ -21,7 +21,7 @@ template struct memgraph::utils::Gatekeeper<memgraph::dbms::Database>;

 namespace memgraph::dbms {

-Database::Database(storage::Config config, replication::ReplicationState &repl_state)
+Database::Database(storage::Config config, const replication::ReplicationState &repl_state)
    : trigger_store_(config.durability.storage_directory / "triggers"),
      streams_{config.durability.storage_directory / "streams"},
      plan_cache_{FLAGS_query_plan_cache_max_size},
--- a/src/dbms/database.hpp
+++ b/src/dbms/database.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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
@@ -48,7 +48,7 @@ class Database {
   *
   * @param config storage configuration
   */
-  explicit Database(storage::Config config, replication::ReplicationState &repl_state);
+  explicit Database(storage::Config config, const replication::ReplicationState &repl_state);

  /**
   * @brief Returns the raw storage pointer.
@@ -68,12 +68,12 @@ class Database {
   */
  std::unique_ptr<storage::Storage::Accessor> Access(
      std::optional<storage::IsolationLevel> override_isolation_level = {}) {
-    return storage_->Access(repl_state_->GetRole(), override_isolation_level);
+    return storage_->Access(override_isolation_level, repl_state_->IsMain());
  }

  std::unique_ptr<storage::Storage::Accessor> UniqueAccess(
      std::optional<storage::IsolationLevel> override_isolation_level = {}) {
-    return storage_->UniqueAccess(repl_state_->GetRole(), override_isolation_level);
+    return storage_->UniqueAccess(override_isolation_level, repl_state_->IsMain());
  }

  /**
@@ -95,7 +95,7 @@ class Database {
   *
   * @return storage::StorageMode
   */
-  storage::StorageMode GetStorageMode() const noexcept { return storage_->GetStorageMode(); }
+  storage::StorageMode GetStorageMode() const { return storage_->GetStorageMode(); }

  /**
   * @brief Get the storage info
@@ -103,9 +103,9 @@ class Database {
   * @param force_directory Use the configured directory, do not try to decipher the multi-db version
   * @return DatabaseInfo
   */
-  DatabaseInfo GetInfo(bool force_directory, replication::ReplicationRole replication_role) const {
+  DatabaseInfo GetInfo(bool force_directory = false) const {
    DatabaseInfo info;
-    info.storage_info = storage_->GetInfo(force_directory, replication_role);
+    info.storage_info = storage_->GetInfo(force_directory);
    info.triggers = trigger_store_.GetTriggerInfo().size();
    info.streams = streams_.GetStreamInfo().size();
    return info;
--- a/src/dbms/database_handler.hpp
+++ b/src/dbms/database_handler.hpp
@@ -51,7 +51,8 @@ class DatabaseHandler : public Handler<Database> {
   * @param config Storage configuration
   * @return HandlerT::NewResult
   */
-  HandlerT::NewResult New(std::string_view name, storage::Config config, replication::ReplicationState &repl_state) {
+  HandlerT::NewResult New(std::string_view name, storage::Config config,
+                          const replication::ReplicationState &repl_state) {
    // Control that no one is using the same data directory
    if (std::any_of(begin(), end(), [&](auto &elem) {
          auto db_acc = elem.second.access();
--- a/src/dbms/dbms_handler.cpp
+++ b/src/dbms/dbms_handler.cpp
@@ -1,75 +0,0 @@
-// 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 "dbms/dbms_handler.hpp"
-
-namespace memgraph::dbms {
-#ifdef MG_ENTERPRISE
-DbmsHandler::DbmsHandler(
-    storage::Config config,
-    memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
-    bool recovery_on_startup, bool delete_on_drop)
-    : default_config_{std::move(config)},
-      delete_on_drop_(delete_on_drop),
-      repl_state_{ReplicationStateRootPath(default_config_)} {
-  // TODO: Decouple storage config from dbms config
-  // TODO: Save individual db configs inside the kvstore and restore from there
-  storage::UpdatePaths(default_config_, default_config_.durability.storage_directory / "databases");
-  const auto &db_dir = default_config_.durability.storage_directory;
-  const auto durability_dir = db_dir / ".durability";
-  utils::EnsureDirOrDie(db_dir);
-  utils::EnsureDirOrDie(durability_dir);
-  durability_ = std::make_unique<kvstore::KVStore>(durability_dir);
-
-  // Generate the default database
-  MG_ASSERT(!NewDefault_().HasError(), "Failed while creating the default DB.");
-
-  // Recover previous databases
-  if (recovery_on_startup) {
-    for (const auto &[name, _] : *durability_) {
-      if (name == kDefaultDB) continue;  // Already set
-      spdlog::info("Restoring database {}.", name);
-      MG_ASSERT(!New_(name).HasError(), "Failed while creating database {}.", name);
-      spdlog::info("Database {} restored.", name);
-    }
-  } else {  // Clear databases from the durability list and auth
-    auto locked_auth = auth->Lock();
-    for (const auto &[name, _] : *durability_) {
-      if (name == kDefaultDB) continue;
-      locked_auth->DeleteDatabase(name);
-      durability_->Delete(name);
-    }
-  }
-
-  // Startup replication state (if recovered at startup)
-  auto replica = [this](replication::RoleReplicaData const &data) {
-    // Register handlers
-    InMemoryReplicationHandlers::Register(this, *data.server);
-    if (!data.server->Start()) {
-      spdlog::error("Unable to start the replication server.");
-      return false;
-    }
-    return true;
-  };
-  // Replication frequent check start
-  auto main = [this](replication::RoleMainData &data) {
-    for (auto &client : data.registered_replicas_) {
-      StartReplicaClient(*this, client);
-    }
-    return true;
-  };
-  // Startup proccess for main/replica
-  MG_ASSERT(std::visit(memgraph::utils::Overloaded{replica, main}, repl_state_.ReplicationData()),
-            "Replica recovery failure!");
-}
-#endif
-
-}  // namespace memgraph::dbms
--- a/src/dbms/dbms_handler.hpp
+++ b/src/dbms/dbms_handler.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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,11 +26,9 @@
 #include "auth/auth.hpp"
 #include "constants.hpp"
 #include "dbms/database.hpp"
-#include "dbms/inmemory/replication_handlers.hpp"
 #ifdef MG_ENTERPRISE
 #include "dbms/database_handler.hpp"
 #endif
-#include "dbms/replication_client.hpp"
 #include "global.hpp"
 #include "query/config.hpp"
 #include "query/interpreter_context.hpp"
@@ -104,22 +102,52 @@ class DbmsHandler {
   * @param recovery_on_startup restore databases (and its content) and authentication data
   * @param delete_on_drop when dropping delete any associated directories on disk
   */
-  DbmsHandler(storage::Config config,
-              memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
-              bool recovery_on_startup, bool delete_on_drop);  // TODO If more arguments are added use a config strut
+  DbmsHandler(storage::Config config, const replication::ReplicationState &repl_state, auto *auth,
+              bool recovery_on_startup, bool delete_on_drop)
+      : lock_{utils::RWLock::Priority::READ},
+        default_config_{std::move(config)},
+        repl_state_(repl_state),
+        delete_on_drop_(delete_on_drop) {
+    // TODO: Decouple storage config from dbms config
+    // TODO: Save individual db configs inside the kvstore and restore from there
+    storage::UpdatePaths(default_config_, default_config_.durability.storage_directory / "databases");
+    const auto &db_dir = default_config_.durability.storage_directory;
+    const auto durability_dir = db_dir / ".durability";
+    utils::EnsureDirOrDie(db_dir);
+    utils::EnsureDirOrDie(durability_dir);
+    durability_ = std::make_unique<kvstore::KVStore>(durability_dir);
+
+    // Generate the default database
+    MG_ASSERT(!NewDefault_().HasError(), "Failed while creating the default DB.");
+    // Recover previous databases
+    if (recovery_on_startup) {
+      for (const auto &[name, _] : *durability_) {
+        if (name == kDefaultDB) continue;  // Already set
+        spdlog::info("Restoring database {}.", name);
+        MG_ASSERT(!New_(name).HasError(), "Failed while creating database {}.", name);
+        spdlog::info("Database {} restored.", name);
+      }
+    } else {  // Clear databases from the durability list and auth
+      auto locked_auth = auth->Lock();
+      for (const auto &[name, _] : *durability_) {
+        if (name == kDefaultDB) continue;
+        locked_auth->DeleteDatabase(name);
+        durability_->Delete(name);
+      }
+    }
+  }
 #else
  /**
   * @brief Initialize the handler. A single database is supported in community edition.
   *
   * @param configs storage configuration
   */
-  DbmsHandler(storage::Config config)
-      : repl_state_{ReplicationStateRootPath(config)},
-        db_gatekeeper_{[&] {
+  DbmsHandler(storage::Config config, const replication::ReplicationState &repl_state)
+      : db_gatekeeper_{[&] {
                         config.name = kDefaultDB;
                         return std::move(config);
                       }(),
-                       repl_state_} {}
+                       repl_state} {}
 #endif

 #ifdef MG_ENTERPRISE
@@ -220,19 +248,12 @@ class DbmsHandler {
 #endif
  }

-  replication::ReplicationState &ReplicationState() { return repl_state_; }
-  replication::ReplicationState const &ReplicationState() const { return repl_state_; }
-
-  bool IsMain() const { return repl_state_.IsMain(); }
-  bool IsReplica() const { return repl_state_.IsReplica(); }
-
  /**
   * @brief Return the statistics all databases.
   *
   * @return Statistics
   */
  Statistics Stats() {
-    auto const replication_role = repl_state_.GetRole();
    Statistics stats{};
    // TODO: Handle overflow?
 #ifdef MG_ENTERPRISE
@@ -245,7 +266,7 @@ class DbmsHandler {
      auto db_acc_opt = db_gk.access();
      if (db_acc_opt) {
        auto &db_acc = *db_acc_opt;
-        const auto &info = db_acc->GetInfo(false, replication_role);
+        const auto &info = db_acc->GetInfo();
        const auto &storage_info = info.storage_info;
        stats.num_vertex += storage_info.vertex_count;
        stats.num_edges += storage_info.edge_count;
@@ -269,7 +290,6 @@ class DbmsHandler {
   * @return std::vector<DatabaseInfo>
   */
  std::vector<DatabaseInfo> Info() {
-    auto const replication_role = repl_state_.GetRole();
    std::vector<DatabaseInfo> res;
 #ifdef MG_ENTERPRISE
    std::shared_lock<LockT> rd(lock_);
@@ -282,7 +302,7 @@ class DbmsHandler {
      auto db_acc_opt = db_gk.access();
      if (db_acc_opt) {
        auto &db_acc = *db_acc_opt;
-        res.push_back(db_acc->GetInfo(false, replication_role));
+        res.push_back(db_acc->GetInfo());
      }
    }
    return res;
@@ -516,15 +536,14 @@ class DbmsHandler {
    throw UnknownDatabaseException("Tried to retrieve an unknown database \"{}\".", name);
  }

-  mutable LockT lock_{utils::RWLock::Priority::READ};  //!< protective lock
-  storage::Config default_config_;                     //!< Storage configuration used when creating new databases
-  DatabaseHandler db_handler_;                         //!< multi-tenancy storage handler
-  std::unique_ptr<kvstore::KVStore> durability_;       //!< list of active dbs (pointer so we can postpone its creation)
-  bool delete_on_drop_;                                //!< Flag defining if dropping storage also deletes its directory
-  std::set<std::string> defunct_dbs_;  //!< Databases that are in an unknown state due to various failures
-#endif
-  replication::ReplicationState repl_state_;  //!< Global replication state
-#ifndef MG_ENTERPRISE
+  mutable LockT lock_;                               //!< protective lock
+  storage::Config default_config_;                   //!< Storage configuration used when creating new databases
+  const replication::ReplicationState &repl_state_;  //!< Global replication state
+  DatabaseHandler db_handler_;                       //!< multi-tenancy storage handler
+  std::unique_ptr<kvstore::KVStore> durability_;     //!< list of active dbs (pointer so we can postpone its creation)
+  bool delete_on_drop_;                              //!< Flag defining if dropping storage also deletes its directory
+  std::set<std::string> defunct_dbs_;                //!< Databases that are in an unknown state due to various failures
+#else
  mutable utils::Gatekeeper<Database> db_gatekeeper_;  //!< Single databases gatekeeper
 #endif
 };
--- a/src/dbms/handler.hpp
+++ b/src/dbms/handler.hpp
@@ -38,7 +38,7 @@ class Handler {
   * @brief Empty Handler constructor.
   *
   */
-  Handler() = default;
+  Handler() {}

  /**
   * @brief Generate a new context and corresponding configuration.
--- a/src/dbms/inmemory/replication_handlers.cpp
+++ b/src/dbms/inmemory/replication_handlers.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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
@@ -10,7 +10,6 @@
 // licenses/APL.txt.

 #include "dbms/inmemory/replication_handlers.hpp"
-#include <optional>
 #include "dbms/constants.hpp"
 #include "dbms/dbms_handler.hpp"
 #include "replication/replication_server.hpp"
@@ -22,7 +21,6 @@
 #include "storage/v2/inmemory/storage.hpp"
 #include "storage/v2/inmemory/unique_constraints.hpp"

-using memgraph::replication::ReplicationRole;
 using memgraph::storage::Delta;
 using memgraph::storage::EdgeAccessor;
 using memgraph::storage::EdgeRef;
@@ -189,9 +187,9 @@ void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handle
  storage::replication::Decoder decoder(req_reader);

  auto *storage = static_cast<storage::InMemoryStorage *>(db_acc->get()->storage());
-  utils::EnsureDirOrDie(storage->recovery_.snapshot_directory_);
+  utils::EnsureDirOrDie(storage->snapshot_directory_);

-  const auto maybe_snapshot_path = decoder.ReadFile(storage->recovery_.snapshot_directory_);
+  const auto maybe_snapshot_path = decoder.ReadFile(storage->snapshot_directory_);
  MG_ASSERT(maybe_snapshot_path, "Failed to load snapshot!");
  spdlog::info("Received snapshot saved to {}", *maybe_snapshot_path);

@@ -221,10 +219,7 @@ void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handle
    storage->timestamp_ = std::max(storage->timestamp_, recovery_info.next_timestamp);

    spdlog::trace("Recovering indices and constraints from snapshot.");
-    memgraph::storage::durability::RecoverIndicesAndStats(recovered_snapshot.indices_constraints.indices,
-                                                          &storage->indices_, &storage->vertices_,
-                                                          storage->name_id_mapper_.get());
-    memgraph::storage::durability::RecoverConstraints(recovered_snapshot.indices_constraints.constraints,
+    storage::durability::RecoverIndicesAndConstraints(recovered_snapshot.indices_constraints, &storage->indices_,
                                                      &storage->constraints_, &storage->vertices_,
                                                      storage->name_id_mapper_.get());
  } catch (const storage::durability::RecoveryFailure &e) {
@@ -238,7 +233,7 @@ void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handle

  spdlog::trace("Deleting old snapshot files due to snapshot recovery.");
  // Delete other durability files
-  auto snapshot_files = storage::durability::GetSnapshotFiles(storage->recovery_.snapshot_directory_, storage->uuid_);
+  auto snapshot_files = storage::durability::GetSnapshotFiles(storage->snapshot_directory_, storage->uuid_);
  for (const auto &[path, uuid, _] : snapshot_files) {
    if (path != *maybe_snapshot_path) {
      spdlog::trace("Deleting snapshot file {}", path);
@@ -247,7 +242,7 @@ void InMemoryReplicationHandlers::SnapshotHandler(dbms::DbmsHandler *dbms_handle
  }

  spdlog::trace("Deleting old WAL files due to snapshot recovery.");
-  auto wal_files = storage::durability::GetWalFiles(storage->recovery_.wal_directory_, storage->uuid_);
+  auto wal_files = storage::durability::GetWalFiles(storage->wal_directory_, storage->uuid_);
  if (wal_files) {
    for (const auto &wal_file : *wal_files) {
      spdlog::trace("Deleting WAL file {}", wal_file.path);
@@ -272,7 +267,7 @@ void InMemoryReplicationHandlers::WalFilesHandler(dbms::DbmsHandler *dbms_handle
  storage::replication::Decoder decoder(req_reader);

  auto *storage = static_cast<storage::InMemoryStorage *>(db_acc->get()->storage());
-  utils::EnsureDirOrDie(storage->recovery_.wal_directory_);
+  utils::EnsureDirOrDie(storage->wal_directory_);

  for (auto i = 0; i < wal_file_number; ++i) {
    LoadWal(storage, &decoder);
@@ -294,7 +289,7 @@ void InMemoryReplicationHandlers::CurrentWalHandler(dbms::DbmsHandler *dbms_hand
  storage::replication::Decoder decoder(req_reader);

  auto *storage = static_cast<storage::InMemoryStorage *>(db_acc->get()->storage());
-  utils::EnsureDirOrDie(storage->recovery_.wal_directory_);
+  utils::EnsureDirOrDie(storage->wal_directory_);

  LoadWal(storage, &decoder);

@@ -375,15 +370,14 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
  constexpr bool kSharedAccess = false;

  std::optional<std::pair<uint64_t, storage::InMemoryStorage::ReplicationAccessor>> commit_timestamp_and_accessor;
-  auto const get_transaction = [storage, &commit_timestamp_and_accessor](
-                                   uint64_t commit_timestamp,
-                                   bool unique = kSharedAccess) -> storage::InMemoryStorage::ReplicationAccessor * {
+  auto get_transaction = [storage, &commit_timestamp_and_accessor](uint64_t commit_timestamp,
+                                                                   bool unique = kSharedAccess) {
    if (!commit_timestamp_and_accessor) {
      std::unique_ptr<storage::Storage::Accessor> acc = nullptr;
      if (unique) {
-        acc = storage->UniqueAccess(ReplicationRole::REPLICA);
+        acc = storage->UniqueAccess(std::nullopt, false /*not main*/);
      } else {
-        acc = storage->Access(ReplicationRole::REPLICA);
+        acc = storage->Access(std::nullopt, false /*not main*/);
      }
      auto inmem_acc = std::unique_ptr<storage::InMemoryStorage::InMemoryAccessor>(
          static_cast<storage::InMemoryStorage::InMemoryAccessor *>(acc.release()));
@@ -421,11 +415,9 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
        spdlog::trace("       Delete vertex {}", delta.vertex_create_delete.gid.AsUint());
        auto *transaction = get_transaction(timestamp);
        auto vertex = transaction->FindVertex(delta.vertex_create_delete.gid, View::NEW);
-        if (!vertex)
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (!vertex) throw utils::BasicException("Invalid transaction!");
        auto ret = transaction->DeleteVertex(&*vertex);
-        if (ret.HasError() || !ret.GetValue())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (ret.HasError() || !ret.GetValue()) throw utils::BasicException("Invalid transaction!");
        break;
      }
      case WalDeltaData::Type::VERTEX_ADD_LABEL: {
@@ -433,11 +425,9 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
                      delta.vertex_add_remove_label.label);
        auto *transaction = get_transaction(timestamp);
        auto vertex = transaction->FindVertex(delta.vertex_add_remove_label.gid, View::NEW);
-        if (!vertex)
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (!vertex) throw utils::BasicException("Invalid transaction!");
        auto ret = vertex->AddLabel(transaction->NameToLabel(delta.vertex_add_remove_label.label));
-        if (ret.HasError() || !ret.GetValue())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (ret.HasError() || !ret.GetValue()) throw utils::BasicException("Invalid transaction!");
        break;
      }
      case WalDeltaData::Type::VERTEX_REMOVE_LABEL: {
@@ -445,11 +435,9 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
                      delta.vertex_add_remove_label.label);
        auto *transaction = get_transaction(timestamp);
        auto vertex = transaction->FindVertex(delta.vertex_add_remove_label.gid, View::NEW);
-        if (!vertex)
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (!vertex) throw utils::BasicException("Invalid transaction!");
        auto ret = vertex->RemoveLabel(transaction->NameToLabel(delta.vertex_add_remove_label.label));
-        if (ret.HasError() || !ret.GetValue())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (ret.HasError() || !ret.GetValue()) throw utils::BasicException("Invalid transaction!");
        break;
      }
      case WalDeltaData::Type::VERTEX_SET_PROPERTY: {
@@ -457,12 +445,10 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
                      delta.vertex_edge_set_property.property, delta.vertex_edge_set_property.value);
        auto *transaction = get_transaction(timestamp);
        auto vertex = transaction->FindVertex(delta.vertex_edge_set_property.gid, View::NEW);
-        if (!vertex)
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (!vertex) throw utils::BasicException("Invalid transaction!");
        auto ret = vertex->SetProperty(transaction->NameToProperty(delta.vertex_edge_set_property.property),
                                       delta.vertex_edge_set_property.value);
-        if (ret.HasError())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (ret.HasError()) throw utils::BasicException("Invalid transaction!");
        break;
      }
      case WalDeltaData::Type::EDGE_CREATE: {
@@ -471,16 +457,13 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
                      delta.edge_create_delete.from_vertex.AsUint(), delta.edge_create_delete.to_vertex.AsUint());
        auto *transaction = get_transaction(timestamp);
        auto from_vertex = transaction->FindVertex(delta.edge_create_delete.from_vertex, View::NEW);
-        if (!from_vertex)
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (!from_vertex) throw utils::BasicException("Invalid transaction!");
        auto to_vertex = transaction->FindVertex(delta.edge_create_delete.to_vertex, View::NEW);
-        if (!to_vertex)
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (!to_vertex) throw utils::BasicException("Invalid transaction!");
        auto edge = transaction->CreateEdgeEx(&*from_vertex, &*to_vertex,
                                              transaction->NameToEdgeType(delta.edge_create_delete.edge_type),
                                              delta.edge_create_delete.gid);
-        if (edge.HasError())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (edge.HasError()) throw utils::BasicException("Invalid transaction!");
        break;
      }
      case WalDeltaData::Type::EDGE_DELETE: {
@@ -489,17 +472,16 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
                      delta.edge_create_delete.from_vertex.AsUint(), delta.edge_create_delete.to_vertex.AsUint());
        auto *transaction = get_transaction(timestamp);
        auto from_vertex = transaction->FindVertex(delta.edge_create_delete.from_vertex, View::NEW);
-        if (!from_vertex)
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (!from_vertex) throw utils::BasicException("Invalid transaction!");
        auto to_vertex = transaction->FindVertex(delta.edge_create_delete.to_vertex, View::NEW);
-        if (!to_vertex)
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
-        auto edgeType = transaction->NameToEdgeType(delta.edge_create_delete.edge_type);
-        auto edge =
-            transaction->FindEdge(delta.edge_create_delete.gid, View::NEW, edgeType, &*from_vertex, &*to_vertex);
-        if (!edge) throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
-        if (auto ret = transaction->DeleteEdge(&*edge); ret.HasError())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (!to_vertex) throw utils::BasicException("Invalid transaction!");
+        auto edges = from_vertex->OutEdges(View::NEW, {transaction->NameToEdgeType(delta.edge_create_delete.edge_type)},
+                                           &*to_vertex);
+        if (edges.HasError()) throw utils::BasicException("Invalid transaction!");
+        if (edges->edges.size() != 1) throw utils::BasicException("Invalid transaction!");
+        auto &edge = (*edges).edges[0];
+        auto ret = transaction->DeleteEdge(&edge);
+        if (ret.HasError()) throw utils::BasicException("Invalid transaction!");
        break;
      }
      case WalDeltaData::Type::EDGE_SET_PROPERTY: {
@@ -516,8 +498,7 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
        // yields an accessor that is only valid for managing the edge's
        // properties.
        auto edge = edge_acc.find(delta.vertex_edge_set_property.gid);
-        if (edge == edge_acc.end())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (edge == edge_acc.end()) throw utils::BasicException("Invalid transaction!");
        // The edge visibility check must be done here manually because we
        // don't allow direct access to the edges through the public API.
        {
@@ -549,8 +530,7 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
              }
            }
          });
-          if (!is_visible)
-            throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+          if (!is_visible) throw utils::BasicException("Invalid transaction!");
        }
        EdgeRef edge_ref(&*edge);
        // Here we create an edge accessor that we will use to get the
@@ -563,8 +543,7 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage

        auto ret = ea.SetProperty(transaction->NameToProperty(delta.vertex_edge_set_property.property),
                                  delta.vertex_edge_set_property.value);
-        if (ret.HasError())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (ret.HasError()) throw utils::BasicException("Invalid transaction!");
        break;
      }

@@ -574,8 +553,7 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
          throw utils::BasicException("Invalid commit data!");
        auto ret =
            commit_timestamp_and_accessor->second.Commit(commit_timestamp_and_accessor->first, false /* not main */);
-        if (ret.HasError())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (ret.HasError()) throw utils::BasicException("Invalid transaction!");
        commit_timestamp_and_accessor = std::nullopt;
        break;
      }
@@ -585,14 +563,14 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
        // Need to send the timestamp
        auto *transaction = get_transaction(timestamp, kUniqueAccess);
        if (transaction->CreateIndex(storage->NameToLabel(delta.operation_label.label)).HasError())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+          throw utils::BasicException("Invalid transaction!");
        break;
      }
      case WalDeltaData::Type::LABEL_INDEX_DROP: {
        spdlog::trace("       Drop label index on :{}", delta.operation_label.label);
        auto *transaction = get_transaction(timestamp, kUniqueAccess);
        if (transaction->DropIndex(storage->NameToLabel(delta.operation_label.label)).HasError())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+          throw utils::BasicException("Invalid transaction!");
        break;
      }
      case WalDeltaData::Type::LABEL_INDEX_STATS_SET: {
@@ -623,7 +601,7 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
                ->CreateIndex(storage->NameToLabel(delta.operation_label_property.label),
                              storage->NameToProperty(delta.operation_label_property.property))
                .HasError())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+          throw utils::BasicException("Invalid transaction!");
        break;
      }
      case WalDeltaData::Type::LABEL_PROPERTY_INDEX_DROP: {
@@ -634,7 +612,7 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
                ->DropIndex(storage->NameToLabel(delta.operation_label_property.label),
                            storage->NameToProperty(delta.operation_label_property.property))
                .HasError())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+          throw utils::BasicException("Invalid transaction!");
        break;
      }
      case WalDeltaData::Type::LABEL_PROPERTY_INDEX_STATS_SET: {
@@ -666,8 +644,7 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
        auto ret =
            transaction->CreateExistenceConstraint(storage->NameToLabel(delta.operation_label_property.label),
                                                   storage->NameToProperty(delta.operation_label_property.property));
-        if (ret.HasError())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+        if (ret.HasError()) throw utils::BasicException("Invalid transaction!");
        break;
      }
      case WalDeltaData::Type::EXISTENCE_CONSTRAINT_DROP: {
@@ -678,7 +655,7 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
                ->DropExistenceConstraint(storage->NameToLabel(delta.operation_label_property.label),
                                          storage->NameToProperty(delta.operation_label_property.property))
                .HasError())
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+          throw utils::BasicException("Invalid transaction!");
        break;
      }
      case WalDeltaData::Type::UNIQUE_CONSTRAINT_CREATE: {
@@ -693,7 +670,7 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
        auto ret = transaction->CreateUniqueConstraint(storage->NameToLabel(delta.operation_label_properties.label),
                                                       properties);
        if (!ret.HasValue() || ret.GetValue() != UniqueConstraints::CreationStatus::SUCCESS)
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+          throw utils::BasicException("Invalid transaction!");
        break;
      }
      case WalDeltaData::Type::UNIQUE_CONSTRAINT_DROP: {
@@ -708,7 +685,7 @@ uint64_t InMemoryReplicationHandlers::ReadAndApplyDelta(storage::InMemoryStorage
        auto ret =
            transaction->DropUniqueConstraint(storage->NameToLabel(delta.operation_label_properties.label), properties);
        if (ret != UniqueConstraints::DeletionStatus::SUCCESS) {
-          throw utils::BasicException("Invalid transaction! Please raise an issue, {}:{}", __FILE__, __LINE__);
+          throw utils::BasicException("Invalid transaction!");
        }
        break;
      }
--- a/src/dbms/inmemory/storage_helper.hpp
+++ b/src/dbms/inmemory/storage_helper.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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,14 @@

 namespace memgraph::dbms {

-inline std::unique_ptr<storage::Storage> CreateInMemoryStorage(storage::Config config,
-                                                               ::memgraph::replication::ReplicationState &repl_state) {
+#ifdef MG_EXPERIMENTAL_REPLICATION_MULTITENANCY
+constexpr bool allow_mt_repl = true;
+#else
+constexpr bool allow_mt_repl = false;
+#endif
+
+inline std::unique_ptr<storage::Storage> CreateInMemoryStorage(
+    storage::Config config, const ::memgraph::replication::ReplicationState &repl_state) {
  const auto wal_mode = config.durability.snapshot_wal_mode;
  const auto name = config.name;
  auto storage = std::make_unique<storage::InMemoryStorage>(std::move(config));
@@ -31,7 +37,10 @@ inline std::unique_ptr<storage::Storage> CreateInMemoryStorage(storage::Config c
  // Connect replication state and storage
  storage->CreateSnapshotHandler(
      [storage = storage.get(), &repl_state]() -> utils::BasicResult<storage::InMemoryStorage::CreateSnapshotError> {
-        return storage->CreateSnapshot(repl_state.GetRole());
+        if (repl_state.IsReplica()) {
+          return storage::InMemoryStorage::CreateSnapshotError::DisabledForReplica;
+        }
+        return storage->CreateSnapshot();
      });

  if (allow_mt_repl || name == dbms::kDefaultDB) {
--- a/src/dbms/replication_client.cpp
+++ b/src/dbms/replication_client.cpp
@@ -1,34 +0,0 @@
-// 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 "dbms/replication_client.hpp"
-
-namespace memgraph::dbms {
-
-void StartReplicaClient(DbmsHandler &dbms_handler, replication::ReplicationClient &client) {
-  // No client error, start instance level client
-  auto const &endpoint = client.rpc_client_.Endpoint();
-  spdlog::trace("Replication client started at: {}:{}", endpoint.address, endpoint.port);
-  client.StartFrequentCheck([&dbms_handler](std::string_view name) {
-    // Working connection, check if any database has been left behind
-    dbms_handler.ForEach([name](dbms::Database *db) {
-      // Specific database <-> replica client
-      db->storage()->repl_storage_state_.WithClient(name, [&](storage::ReplicationStorageClient *client) {
-        if (client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
-          // Database <-> replica might be behind, check and recover
-          client->TryCheckReplicaStateAsync(db->storage());
-        }
-      });
-    });
-  });
-}
-
-}  // namespace memgraph::dbms
--- a/src/dbms/replication_client.hpp
+++ b/src/dbms/replication_client.hpp
@@ -1,21 +0,0 @@
-// 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 "dbms/dbms_handler.hpp"
-#include "replication/replication_client.hpp"
-
-namespace memgraph::dbms {
-
-void StartReplicaClient(DbmsHandler &dbms_handler, replication::ReplicationClient &client);
-
-}  // namespace memgraph::dbms
--- a/src/dbms/replication_handler.cpp
+++ b/src/dbms/replication_handler.cpp
@@ -15,7 +15,6 @@
 #include "dbms/dbms_handler.hpp"
 #include "dbms/inmemory/replication_handlers.hpp"
 #include "dbms/inmemory/storage_helper.hpp"
-#include "dbms/replication_client.hpp"
 #include "replication/state.hpp"

 using memgraph::replication::ReplicationClientConfig;
@@ -42,8 +41,6 @@ std::string RegisterReplicaErrorToString(RegisterReplicaError error) {
 }
 }  // namespace

-ReplicationHandler::ReplicationHandler(DbmsHandler &dbms_handler) : dbms_handler_(dbms_handler) {}
-
 bool ReplicationHandler::SetReplicationRoleMain() {
  auto const main_handler = [](RoleMainData const &) {
    // If we are already MAIN, we don't want to change anything
@@ -59,49 +56,42 @@ bool ReplicationHandler::SetReplicationRoleMain() {

    // STEP 2) Change to MAIN
    // TODO: restore replication servers if false?
-    if (!dbms_handler_.ReplicationState().SetReplicationRoleMain()) {
+    if (!repl_state_.SetReplicationRoleMain()) {
      // TODO: Handle recovery on failure???
      return false;
    }

    // STEP 3) We are now MAIN, update storage local epoch
-    const auto &epoch =
-        std::get<RoleMainData>(std::as_const(dbms_handler_.ReplicationState()).ReplicationData()).epoch_;
    dbms_handler_.ForEach([&](Database *db) {
      auto *storage = db->storage();
-      storage->repl_storage_state_.epoch_ = epoch;
+      storage->repl_storage_state_.epoch_ = std::get<RoleMainData>(std::as_const(repl_state_).ReplicationData()).epoch_;
    });

    return true;
  };

  // TODO: under lock
-  return std::visit(utils::Overloaded{main_handler, replica_handler},
-                    dbms_handler_.ReplicationState().ReplicationData());
+  return std::visit(utils::Overloaded{main_handler, replica_handler}, repl_state_.ReplicationData());
 }

 bool ReplicationHandler::SetReplicationRoleReplica(const memgraph::replication::ReplicationServerConfig &config) {
  // We don't want to restart the server if we're already a REPLICA
-  if (dbms_handler_.ReplicationState().IsReplica()) {
+  if (repl_state_.IsReplica()) {
    return false;
  }

-  // TODO StorageState needs to be synched. Could have a dangling reference if someone adds a database as we are
-  //      deleting the replica.
-  // Remove database specific clients
+  // Remove registered replicas
  dbms_handler_.ForEach([&](Database *db) {
    auto *storage = db->storage();
    storage->repl_storage_state_.replication_clients_.WithLock([](auto &clients) { clients.clear(); });
  });
-  // Remove instance level clients
-  std::get<RoleMainData>(dbms_handler_.ReplicationState().ReplicationData()).registered_replicas_.clear();

  // Creates the server
-  dbms_handler_.ReplicationState().SetReplicationRoleReplica(config);
+  repl_state_.SetReplicationRoleReplica(config);

  // Start
  const auto success =
-      std::visit(utils::Overloaded{[](RoleMainData const &) {
+      std::visit(utils::Overloaded{[](auto) {
                                     // ASSERT
                                     return false;
                                   },
@@ -114,37 +104,36 @@ bool ReplicationHandler::SetReplicationRoleReplica(const memgraph::replication::
                                     }
                                     return true;
                                   }},
-                 dbms_handler_.ReplicationState().ReplicationData());
+                 repl_state_.ReplicationData());
  // TODO Handle error (restore to main?)
  return success;
 }

 auto ReplicationHandler::RegisterReplica(const memgraph::replication::ReplicationClientConfig &config)
    -> memgraph::utils::BasicResult<RegisterReplicaError> {
-  MG_ASSERT(dbms_handler_.ReplicationState().IsMain(), "Only main instance can register a replica!");
+  MG_ASSERT(repl_state_.IsMain(), "Only main instance can register a replica!");

-  auto instance_client = dbms_handler_.ReplicationState().RegisterReplica(config);
-  if (instance_client.HasError()) switch (instance_client.GetError()) {
-      case memgraph::replication::RegisterReplicaError::NOT_MAIN:
-        MG_ASSERT(false, "Only main instance can register a replica!");
-        return {};
-      case memgraph::replication::RegisterReplicaError::NAME_EXISTS:
-        return memgraph::dbms::RegisterReplicaError::NAME_EXISTS;
-      case memgraph::replication::RegisterReplicaError::END_POINT_EXISTS:
-        return memgraph::dbms::RegisterReplicaError::END_POINT_EXISTS;
-      case memgraph::replication::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
-        return memgraph::dbms::RegisterReplicaError::COULD_NOT_BE_PERSISTED;
-      case memgraph::replication::RegisterReplicaError::SUCCESS:
-        break;
-    }
+  auto res = repl_state_.RegisterReplica(config);
+  switch (res) {
+    case memgraph::replication::RegisterReplicaError::NOT_MAIN:
+      MG_ASSERT(false, "Only main instance can register a replica!");
+      return {};
+    case memgraph::replication::RegisterReplicaError::NAME_EXISTS:
+      return memgraph::dbms::RegisterReplicaError::NAME_EXISTS;
+    case memgraph::replication::RegisterReplicaError::END_POINT_EXISTS:
+      return memgraph::dbms::RegisterReplicaError::END_POINT_EXISTS;
+    case memgraph::replication::RegisterReplicaError::COULD_NOT_BE_PERSISTED:
+      return memgraph::dbms::RegisterReplicaError::COULD_NOT_BE_PERSISTED;
+    case memgraph::replication::RegisterReplicaError::SUCCESS:
+      break;
+  }
+
+  bool all_clients_good = true;

  if (!allow_mt_repl && dbms_handler_.All().size() > 1) {
    spdlog::warn("Multi-tenant replication is currently not supported!");
  }

-  bool all_clients_good = true;
-
-  // Add database specific clients (NOTE Currently all databases are connected to each replica)
  dbms_handler_.ForEach([&](Database *db) {
    auto *storage = db->storage();
    if (!allow_mt_repl && storage->id() != kDefaultDB) {
@@ -154,29 +143,18 @@ auto ReplicationHandler::RegisterReplica(const memgraph::replication::Replicatio
    if (storage->storage_mode_ != storage::StorageMode::IN_MEMORY_TRANSACTIONAL) return;

    all_clients_good &=
-        storage->repl_storage_state_.replication_clients_.WithLock([storage, &instance_client](auto &storage_clients) {
-          auto client = std::make_unique<storage::ReplicationStorageClient>(*instance_client.GetValue());
-          client->Start(storage);
-          // After start the storage <-> replica state should be READY or RECOVERING (if correctly started)
-          // MAYBE_BEHIND isn't a statement of the current state, this is the default value
-          // Failed to start due to branching of MAIN and REPLICA
-          if (client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
+        storage->repl_storage_state_.replication_clients_.WithLock([storage, &config](auto &clients) -> bool {
+          auto client = storage->CreateReplicationClient(config, &storage->repl_storage_state_.epoch_);
+          client->Start();
+
+          if (client->State() == storage::replication::ReplicaState::INVALID) {
            return false;
          }
-          storage_clients.push_back(std::move(client));
+          clients.push_back(std::move(client));
          return true;
        });
  });
-
-  // NOTE Currently if any databases fails, we revert back
-  if (!all_clients_good) {
-    spdlog::error("Failed to register all databases to the REPLICA \"{}\"", config.name);
-    UnregisterReplica(config.name);
-    return RegisterReplicaError::CONNECTION_FAILED;
-  }
-
-  // No client error, start instance level client
-  StartReplicaClient(dbms_handler_, *instance_client.GetValue());
+  if (!all_clients_good) return RegisterReplicaError::CONNECTION_FAILED;  // TODO: this happen to 1 or many...what to do
  return {};
 }

@@ -185,66 +163,60 @@ auto ReplicationHandler::UnregisterReplica(std::string_view name) -> UnregisterR
    return UnregisterReplicaResult::NOT_MAIN;
  };
  auto const main_handler = [this, name](RoleMainData &mainData) -> UnregisterReplicaResult {
-    if (!dbms_handler_.ReplicationState().TryPersistUnregisterReplica(name)) {
+    if (!repl_state_.TryPersistUnregisterReplica(name)) {
      return UnregisterReplicaResult::COULD_NOT_BE_PERSISTED;
    }
-    // Remove database specific clients
-    dbms_handler_.ForEach([name](Database *db) {
-      db->storage()->repl_storage_state_.replication_clients_.WithLock([&name](auto &clients) {
-        std::erase_if(clients, [name](const auto &client) { return client->Name() == name; });
-      });
-    });
-    // Remove instance level clients
    auto const n_unregistered =
-        std::erase_if(mainData.registered_replicas_, [name](auto const &client) { return client.name_ == name; });
+        std::erase_if(mainData.registered_replicas_,
+                      [&](ReplicationClientConfig const &registered_config) { return registered_config.name == name; });
+
+    dbms_handler_.ForEach([&](Database *db) {
+      db->storage()->repl_storage_state_.replication_clients_.WithLock(
+          [&](auto &clients) { std::erase_if(clients, [&](const auto &client) { return client->Name() == name; }); });
+    });
+
    return n_unregistered != 0 ? UnregisterReplicaResult::SUCCESS : UnregisterReplicaResult::CAN_NOT_UNREGISTER;
  };

-  return std::visit(utils::Overloaded{main_handler, replica_handler},
-                    dbms_handler_.ReplicationState().ReplicationData());
+  return std::visit(utils::Overloaded{main_handler, replica_handler}, repl_state_.ReplicationData());
 }

-auto ReplicationHandler::GetRole() const -> memgraph::replication::ReplicationRole {
-  return dbms_handler_.ReplicationState().GetRole();
-}
+auto ReplicationHandler::GetRole() const -> memgraph::replication::ReplicationRole { return repl_state_.GetRole(); }

-bool ReplicationHandler::IsMain() const { return dbms_handler_.ReplicationState().IsMain(); }
+bool ReplicationHandler::IsMain() const { return repl_state_.IsMain(); }

-bool ReplicationHandler::IsReplica() const { return dbms_handler_.ReplicationState().IsReplica(); }
+bool ReplicationHandler::IsReplica() const { return repl_state_.IsReplica(); }

-// Per storage
-// NOTE Storage will connect to all replicas. Future work might change this
-void RestoreReplication(replication::ReplicationState &repl_state, storage::Storage &storage) {
+void RestoreReplication(const replication::ReplicationState &repl_state, storage::Storage &storage) {
  spdlog::info("Restoring replication role.");

  /// MAIN
-  auto const recover_main = [&storage](RoleMainData &mainData) {
-    // Each individual client has already been restored and started. Here we just go through each database and start its
-    // client
-    for (auto &instance_client : mainData.registered_replicas_) {
-      spdlog::info("Replica {} restoration started for {}.", instance_client.name_, storage.id());
+  auto const recover_main = [&storage](RoleMainData const &mainData) {
+    for (const auto &config : mainData.registered_replicas_) {
+      spdlog::info("Replica {} restoration started for {}.", config.name, storage.id());

-      const auto &ret = storage.repl_storage_state_.replication_clients_.WithLock(
-          [&](auto &storage_clients) -> utils::BasicResult<RegisterReplicaError> {
-            auto client = std::make_unique<storage::ReplicationStorageClient>(instance_client);
-            client->Start(&storage);
-            // After start the storage <-> replica state should be READY or RECOVERING (if correctly started)
-            // MAYBE_BEHIND isn't a statement of the current state, this is the default value
-            // Failed to start due to branching of MAIN and REPLICA
-            if (client->State() == storage::replication::ReplicaState::MAYBE_BEHIND) {
-              spdlog::warn("Connection failed when registering replica {}. Replica will still be registered.",
-                           instance_client.name_);
-            }
-            storage_clients.push_back(std::move(client));
-            return {};
-          });
+      auto register_replica = [&storage](const memgraph::replication::ReplicationClientConfig &config)
+          -> memgraph::utils::BasicResult<RegisterReplicaError> {
+        return storage.repl_storage_state_.replication_clients_.WithLock(
+            [&storage, &config](auto &clients) -> utils::BasicResult<RegisterReplicaError> {
+              auto client = storage.CreateReplicationClient(config, &storage.repl_storage_state_.epoch_);
+              client->Start();

+              if (client->State() == storage::replication::ReplicaState::INVALID) {
+                spdlog::warn("Connection failed when registering replica {}. Replica will still be registered.",
+                             client->Name());
+              }
+              clients.push_back(std::move(client));
+              return {};
+            });
+      };
+
+      auto ret = register_replica(config);
      if (ret.HasError()) {
        MG_ASSERT(RegisterReplicaError::CONNECTION_FAILED != ret.GetError());
-        LOG_FATAL("Failure when restoring replica {}: {}.", instance_client.name_,
-                  RegisterReplicaErrorToString(ret.GetError()));
+        LOG_FATAL("Failure when restoring replica {}: {}.", config.name, RegisterReplicaErrorToString(ret.GetError()));
      }
-      spdlog::info("Replica {} restored for {}.", instance_client.name_, storage.id());
+      spdlog::info("Replica {} restored for {}.", config.name, storage.id());
    }
    spdlog::info("Replication role restored to MAIN.");
  };
@@ -257,6 +229,6 @@ void RestoreReplication(replication::ReplicationState &repl_state, storage::Stor
          recover_main,
          recover_replica,
      },
-      repl_state.ReplicationData());
+      std::as_const(repl_state).ReplicationData());
 }
 }  // namespace memgraph::dbms
--- a/src/dbms/replication_handler.hpp
+++ b/src/dbms/replication_handler.hpp
@@ -36,7 +36,8 @@ enum class UnregisterReplicaResult : uint8_t {
 /// A handler type that keep in sync current ReplicationState and the MAIN/REPLICA-ness of Storage
 /// TODO: extend to do multiple storages
 struct ReplicationHandler {
-  explicit ReplicationHandler(DbmsHandler &dbms_handler);
+  ReplicationHandler(memgraph::replication::ReplicationState &replState, DbmsHandler &dbms_handler)
+      : repl_state_(replState), dbms_handler_(dbms_handler) {}

  // as REPLICA, become MAIN
  bool SetReplicationRoleMain();
@@ -57,11 +58,12 @@ struct ReplicationHandler {
  bool IsReplica() const;

 private:
+  memgraph::replication::ReplicationState &repl_state_;
  DbmsHandler &dbms_handler_;
 };

 /// A handler type that keep in sync current ReplicationState and the MAIN/REPLICA-ness of Storage
 /// TODO: extend to do multiple storages
-void RestoreReplication(replication::ReplicationState &repl_state, storage::Storage &storage);
+void RestoreReplication(const replication::ReplicationState &repl_state, storage::Storage &storage);

 }  // namespace memgraph::dbms
--- a/src/flags/general.cpp
+++ b/src/flags/general.cpp
@@ -66,9 +66,6 @@ DEFINE_bool(allow_load_csv, true, "Controls whether LOAD CSV clause is allowed i
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_VALIDATED_uint64(storage_gc_cycle_sec, 30, "Storage garbage collector interval (in seconds).",
                        FLAG_IN_RANGE(1, 24UL * 3600));
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_VALIDATED_uint64(storage_python_gc_cycle_sec, 180,
-                        "Storage python full garbage collection interval (in seconds).", FLAG_IN_RANGE(1, 24UL * 3600));
 // NOTE: The `storage_properties_on_edges` flag must be the same here and in
 // `mg_import_csv`. If you change it, make sure to change it there as well.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -107,19 +104,9 @@ DEFINE_bool(storage_snapshot_on_exit, false, "Controls whether the storage creat
 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,misc-unused-parameters)
-DEFINE_VALIDATED_bool(
-    storage_parallel_index_recovery, false,
-    "Controls whether the index creation can be done in a multithreaded fashion.", {
-      spdlog::warn(
-          "storage_parallel_index_recovery flag is deprecated. Check storage_mode_parallel_schema_recovery for more "
-          "details.");
-      return true;
-    });
-
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_bool(storage_parallel_schema_recovery, false,
-            "Controls whether the indices and constraints creation can be done in a multithreaded fashion.");
+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,
@@ -127,10 +114,6 @@ DEFINE_uint64(storage_recovery_thread_count,
                       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(storage_enable_schema_metadata, false,
-            "Controls whether metadata should be collected about the resident labels and edge types.");
-
 #ifdef MG_ENTERPRISE
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_bool(storage_delete_on_drop, true,
--- a/src/flags/general.hpp
+++ b/src/flags/general.hpp
@@ -52,8 +52,6 @@ DECLARE_bool(allow_load_csv);
 // Storage flags.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_uint64(storage_gc_cycle_sec);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint64(storage_python_gc_cycle_sec);
 // NOTE: The `storage_properties_on_edges` flag must be the same here and in
 // `mg_import_csv`. If you change it, make sure to change it there as well.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -75,15 +73,10 @@ DECLARE_uint64(storage_wal_file_flush_every_n_tx);
 DECLARE_bool(storage_snapshot_on_exit);
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_uint64(storage_items_per_batch);
-// storage_parallel_index_recovery deprecated; use storage_parallel_schema_recovery instead
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_bool(storage_parallel_index_recovery);
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_bool(storage_parallel_schema_recovery);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_uint64(storage_recovery_thread_count);
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_bool(storage_enable_schema_metadata);
 #ifdef MG_ENTERPRISE
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DECLARE_bool(storage_delete_on_drop);
--- a/src/glue/SessionHL.cpp
+++ b/src/glue/SessionHL.cpp
@@ -10,7 +10,6 @@
 // licenses/APL.txt.

 #include <optional>
-#include <utility>
 #include "gflags/gflags.h"

 #include "audit/log.hpp"
@@ -234,55 +233,11 @@ std::pair<std::vector<std::string>, std::optional<int>> SessionHL::Interpret(
    throw memgraph::communication::bolt::ClientError(e.what());
  }
 }
-
-void SessionHL::RollbackTransaction() {
-  try {
-    interpreter_.RollbackTransaction();
-  } catch (const memgraph::query::QueryException &e) {
-    // Count the number of specific exceptions thrown
-    metrics::IncrementCounter(GetExceptionName(e));
-    // Wrap QueryException into ClientError, because we want to allow the
-    // client to fix their query.
-    throw memgraph::communication::bolt::ClientError(e.what());
-  } catch (const memgraph::query::ReplicationException &e) {
-    // Count the number of specific exceptions thrown
-    metrics::IncrementCounter(GetExceptionName(e));
-    throw memgraph::communication::bolt::ClientError(e.what());
-  }
-}
-
-void SessionHL::CommitTransaction() {
-  try {
-    interpreter_.CommitTransaction();
-  } catch (const memgraph::query::QueryException &e) {
-    // Count the number of specific exceptions thrown
-    metrics::IncrementCounter(GetExceptionName(e));
-    // Wrap QueryException into ClientError, because we want to allow the
-    // client to fix their query.
-    throw memgraph::communication::bolt::ClientError(e.what());
-  } catch (const memgraph::query::ReplicationException &e) {
-    // Count the number of specific exceptions thrown
-    metrics::IncrementCounter(GetExceptionName(e));
-    throw memgraph::communication::bolt::ClientError(e.what());
-  }
-}
-
+void SessionHL::RollbackTransaction() { interpreter_.RollbackTransaction(); }
+void SessionHL::CommitTransaction() { interpreter_.CommitTransaction(); }
 void SessionHL::BeginTransaction(const std::map<std::string, memgraph::communication::bolt::Value> &extra) {
-  try {
-    interpreter_.BeginTransaction(ToQueryExtras(extra));
-  } catch (const memgraph::query::QueryException &e) {
-    // Count the number of specific exceptions thrown
-    metrics::IncrementCounter(GetExceptionName(e));
-    // Wrap QueryException into ClientError, because we want to allow the
-    // client to fix their query.
-    throw memgraph::communication::bolt::ClientError(e.what());
-  } catch (const memgraph::query::ReplicationException &e) {
-    // Count the number of specific exceptions thrown
-    metrics::IncrementCounter(GetExceptionName(e));
-    throw memgraph::communication::bolt::ClientError(e.what());
-  }
+  interpreter_.BeginTransaction(ToQueryExtras(extra));
 }
-
 void SessionHL::Configure(const std::map<std::string, memgraph::communication::bolt::Value> &run_time_info) {
 #ifdef MG_ENTERPRISE
  std::string db;
@@ -317,7 +272,7 @@ void SessionHL::Configure(const std::map<std::string, memgraph::communication::b
 #endif
 }
 SessionHL::SessionHL(memgraph::query::InterpreterContext *interpreter_context,
-                     memgraph::communication::v2::ServerEndpoint endpoint,
+                     const memgraph::communication::v2::ServerEndpoint &endpoint,
                     memgraph::communication::v2::InputStream *input_stream,
                     memgraph::communication::v2::OutputStream *output_stream,
                     memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth
@@ -334,7 +289,7 @@ SessionHL::SessionHL(memgraph::query::InterpreterContext *interpreter_context,
      audit_log_(audit_log),
 #endif
      auth_(auth),
-      endpoint_(std::move(endpoint)),
+      endpoint_(endpoint),
      implicit_db_(dbms::kDefaultDB) {
  // Metrics update
  memgraph::metrics::IncrementCounter(memgraph::metrics::ActiveBoltSessions);
--- a/src/glue/SessionHL.hpp
+++ b/src/glue/SessionHL.hpp
@@ -23,7 +23,7 @@ class SessionHL final : public memgraph::communication::bolt::Session<memgraph::
                                                                      memgraph::communication::v2::OutputStream> {
 public:
  SessionHL(memgraph::query::InterpreterContext *interpreter_context,
-            memgraph::communication::v2::ServerEndpoint endpoint,
+            const memgraph::communication::v2::ServerEndpoint &endpoint,
            memgraph::communication::v2::InputStream *input_stream,
            memgraph::communication::v2::OutputStream *output_stream,
            memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth
--- a/src/glue/communication.cpp
+++ b/src/glue/communication.cpp
@@ -127,8 +127,6 @@ storage::Result<Value> ToBoltValue(const query::TypedValue &value, const storage
      return Value(value.ValueLocalDateTime());
    case query::TypedValue::Type::Duration:
      return Value(value.ValueDuration());
-    case query::TypedValue::Type::Function:
-      throw communication::bolt::ValueException("Unsupported conversion from TypedValue::Function to Value");
    case query::TypedValue::Type::Graph:
      auto maybe_graph = ToBoltGraph(value.ValueGraph(), db, view);
      if (maybe_graph.HasError()) return maybe_graph.GetError();
@@ -204,7 +202,7 @@ storage::Result<std::map<std::string, Value>> ToBoltGraph(const query::Graph &gr
  for (const auto &v : graph.vertices()) {
    auto maybe_vertex = ToBoltVertex(v, db, view);
    if (maybe_vertex.HasError()) return maybe_vertex.GetError();
-    vertices.emplace_back(std::move(*maybe_vertex));
+    vertices.emplace_back(Value(std::move(*maybe_vertex)));
  }
  map.emplace("nodes", Value(vertices));

@@ -213,7 +211,7 @@ storage::Result<std::map<std::string, Value>> ToBoltGraph(const query::Graph &gr
  for (const auto &e : graph.edges()) {
    auto maybe_edge = ToBoltEdge(e, db, view);
    if (maybe_edge.HasError()) return maybe_edge.GetError();
-    edges.emplace_back(std::move(*maybe_edge));
+    edges.emplace_back(Value(std::move(*maybe_edge)));
  }
  map.emplace("edges", Value(edges));

--- a/src/helpers.hpp
+++ b/src/helpers.hpp
@@ -31,7 +31,7 @@ inline void LoadConfig(const std::string &product_name) {
  std::vector<fs::path> configs = {fs::path("/etc/memgraph/memgraph.conf")};
  if (getenv("HOME") != nullptr) configs.emplace_back(fs::path(getenv("HOME")) / fs::path(".memgraph/config"));
  {
-    auto *memgraph_config = getenv("MEMGRAPH_CONFIG");
+    auto memgraph_config = getenv("MEMGRAPH_CONFIG");
    if (memgraph_config != nullptr) {
      auto path = fs::path(memgraph_config);
      MG_ASSERT(fs::exists(path), "MEMGRAPH_CONFIG environment variable set to nonexisting path: {}",
--- a/src/http_handlers/metrics.hpp
+++ b/src/http_handlers/metrics.hpp
@@ -23,6 +23,7 @@
 #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 {
--- a/src/integrations/kafka/consumer.hpp
+++ b/src/integrations/kafka/consumer.hpp
@@ -171,10 +171,10 @@ class Consumer final : public RdKafka::EventCb {

  class ConsumerRebalanceCb : public RdKafka::RebalanceCb {
   public:
-    explicit ConsumerRebalanceCb(std::string consumer_name);
+    ConsumerRebalanceCb(std::string consumer_name);

    void rebalance_cb(RdKafka::KafkaConsumer *consumer, RdKafka::ErrorCode err,
-                      std::vector<RdKafka::TopicPartition *> &partitions) final;
+                      std::vector<RdKafka::TopicPartition *> &partitions) override final;

    void set_offset(int64_t offset);

--- a/src/integrations/pulsar/consumer.cpp
+++ b/src/integrations/pulsar/consumer.cpp
@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -67,7 +67,7 @@ utils::BasicResult<std::string, std::vector<Message>> GetBatch(TConsumer &consum
        return std::move(batch);
      case pulsar_client::Result::ResultOk:
        if (message.getMessageId() != last_message_id) {
-          batch.emplace_back(std::move(message));
+          batch.emplace_back(Message{std::move(message)});
        }
        break;
      default:
--- a/src/integrations/pulsar/consumer.hpp
+++ b/src/integrations/pulsar/consumer.hpp
@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -10,7 +10,6 @@
 // licenses/APL.txt.

 #pragma once
-
 #include <atomic>
 #include <optional>
 #include <span>
--- a/src/io/network/endpoint.cpp
+++ b/src/io/network/endpoint.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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
@@ -139,13 +139,18 @@ Endpoint::Endpoint(std::string ip_address, uint16_t port) : address(std::move(ip
 }

 // NOLINTNEXTLINE
-Endpoint::Endpoint(needs_resolving_t, std::string hostname, uint16_t port)
-    : address(std::move(hostname)), port(port), family{GetIpFamily(address)} {}
+Endpoint::Endpoint(needs_resolving_t, std::string hostname, uint16_t port) : port(port) {
+  address = ResolveHostnameIntoIpAddress(hostname, port);
+  IpFamily ip_family = GetIpFamily(address);
+  if (ip_family == IpFamily::NONE) {
+    throw NetworkError("Not a valid IPv4 or IPv6 address: {}", address);
+  }
+  family = ip_family;
+}

 std::ostream &operator<<(std::ostream &os, const Endpoint &endpoint) {
  // no need to cover the IpFamily::NONE case, as you can't even construct an
  // Endpoint object if the IpFamily is NONE (i.e. the IP address is invalid)
-  // unless you use DNS hostname
  if (endpoint.family == Endpoint::IpFamily::IP6) {
    return os << "[" << endpoint.address << "]"
              << ":" << endpoint.port;
@@ -161,7 +166,7 @@ bool Endpoint::IsResolvableAddress(const std::string &address, uint16_t port) {
  };
  addrinfo *info = nullptr;
  auto status = getaddrinfo(address.c_str(), std::to_string(port).c_str(), &hints, &info);
-  if (info) freeaddrinfo(info);
+  freeaddrinfo(info);
  return status == 0;
 }

@@ -184,4 +189,34 @@ std::optional<std::pair<std::string, uint16_t>> Endpoint::ParseSocketOrAddress(
  return std::nullopt;
 }

+std::string Endpoint::ResolveHostnameIntoIpAddress(const std::string &address, uint16_t port) {
+  addrinfo hints{
+      .ai_flags = AI_PASSIVE,
+      .ai_family = AF_UNSPEC,     // IPv4 and IPv6
+      .ai_socktype = SOCK_STREAM  // TCP socket
+  };
+  addrinfo *info = nullptr;
+  auto status = getaddrinfo(address.c_str(), std::to_string(port).c_str(), &hints, &info);
+  if (status != 0) throw NetworkError(gai_strerror(status));
+
+  for (auto *result = info; result != nullptr; result = result->ai_next) {
+    if (result->ai_family == AF_INET) {
+      char ipstr[INET_ADDRSTRLEN];
+      auto *ipv4 = reinterpret_cast<struct sockaddr_in *>(result->ai_addr);
+      inet_ntop(AF_INET, &(ipv4->sin_addr), ipstr, sizeof(ipstr));
+      freeaddrinfo(info);
+      return ipstr;
+    }
+    if (result->ai_family == AF_INET6) {
+      char ipstr[INET6_ADDRSTRLEN];
+      auto *ipv6 = reinterpret_cast<struct sockaddr_in6 *>(result->ai_addr);
+      inet_ntop(AF_INET6, &(ipv6->sin6_addr), ipstr, sizeof(ipstr));
+      freeaddrinfo(info);
+      return ipstr;
+    }
+  }
+  freeaddrinfo(info);
+  throw NetworkError("Not a valid address: {}", address);
+}
+
 }  // namespace memgraph::io::network
--- a/src/io/network/endpoint.hpp
+++ b/src/io/network/endpoint.hpp
@@ -48,8 +48,8 @@ struct Endpoint {
  uint16_t port{0};
  IpFamily family{IpFamily::NONE};

-  static std::optional<std::pair<std::string, uint16_t>> ParseSocketOrAddress(const std::string &address,
-                                                                              std::optional<uint16_t> default_port);
+  static std::optional<std::pair<std::string, uint16_t>> ParseSocketOrAddress(
+      const std::string &address, const std::optional<uint16_t> default_port);

  /**
   * Tries to parse the given string as either a socket address or ip address.
@@ -61,8 +61,8 @@ struct Endpoint {
   * it into an ip address and a port number; even if a default port is given,
   * it won't be used, as we expect that it is given in the address string.
   */
-  static std::optional<std::pair<std::string, uint16_t>> ParseSocketOrIpAddress(const std::string &address,
-                                                                                std::optional<uint16_t> default_port);
+  static std::optional<std::pair<std::string, uint16_t>> ParseSocketOrIpAddress(
+      const std::string &address, const std::optional<uint16_t> default_port);

  /**
   * Tries to parse given string as either socket address or hostname.
@@ -72,7 +72,7 @@ struct Endpoint {
   * After we parse hostname and port we try to resolve the hostname into an ip_address.
   */
  static std::optional<std::pair<std::string, uint16_t>> ParseHostname(const std::string &address,
-                                                                       std::optional<uint16_t> default_port);
+                                                                       const std::optional<uint16_t> default_port);

  static IpFamily GetIpFamily(const std::string &address);

--- a/src/io/network/epoll.hpp
+++ b/src/io/network/epoll.hpp
@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -32,7 +32,7 @@ class Epoll {
 public:
  using Event = struct epoll_event;

-  explicit Epoll(bool set_cloexec = false) : epoll_fd_(epoll_create1(set_cloexec ? EPOLL_CLOEXEC : 0)) {
+  Epoll(bool set_cloexec = false) : epoll_fd_(epoll_create1(set_cloexec ? EPOLL_CLOEXEC : 0)) {
    // epoll_create1 returns an error if there is a logical error in our code
    // (for example invalid flags) or if there is irrecoverable error. In both
    // cases it is best to terminate.
--- a/src/io/network/socket.cpp
+++ b/src/io/network/socket.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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,7 +15,6 @@
 #include <poll.h>

 #include "io/network/addrinfo.hpp"
-#include "io/network/network_error.hpp"
 #include "io/network/socket.hpp"
 #include "utils/likely.hpp"
 #include "utils/logging.hpp"
@@ -56,21 +55,17 @@ bool Socket::IsOpen() const { return socket_ != -1; }
 bool Socket::Connect(const Endpoint &endpoint) {
  if (socket_ != -1) return false;

-  try {
-    for (const auto &it : AddrInfo{endpoint}) {
-      int sfd = socket(it.ai_family, it.ai_socktype, it.ai_protocol);
-      if (sfd == -1) continue;
-      if (connect(sfd, it.ai_addr, it.ai_addrlen) == 0) {
-        socket_ = sfd;
-        endpoint_ = endpoint;
-        break;
-      }
-      // If the connect failed close the file descriptor to prevent file
-      // descriptors being leaked
-      close(sfd);
+  for (const auto &it : AddrInfo{endpoint}) {
+    int sfd = socket(it.ai_family, it.ai_socktype, it.ai_protocol);
+    if (sfd == -1) continue;
+    if (connect(sfd, it.ai_addr, it.ai_addrlen) == 0) {
+      socket_ = sfd;
+      endpoint_ = endpoint;
+      break;
    }
-  } catch (const NetworkError &e) {
-    return false;
+    // If the connect failed close the file descriptor to prevent file
+    // descriptors being leaked
+    close(sfd);
  }

  return !(socket_ == -1);
--- a/src/io/network/socket.hpp
+++ b/src/io/network/socket.hpp
@@ -14,7 +14,6 @@
 #include <functional>
 #include <iostream>
 #include <optional>
-#include <utility>

 #include "io/network/endpoint.hpp"

@@ -202,7 +201,7 @@ class Socket {
  bool WaitForReadyWrite();

 private:
-  Socket(int fd, Endpoint endpoint) : socket_(fd), endpoint_(std::move(endpoint)) {}
+  Socket(int fd, const Endpoint &endpoint) : socket_(fd), endpoint_(endpoint) {}

  int socket_ = -1;
  Endpoint endpoint_;
--- a/src/kvstore/kvstore.cpp
+++ b/src/kvstore/kvstore.cpp
@@ -128,7 +128,7 @@ KVStore::iterator::iterator(const KVStore *kvstore, const std::string &prefix, b

 KVStore::iterator::iterator(KVStore::iterator &&other) { pimpl_ = std::move(other.pimpl_); }

-KVStore::iterator::~iterator() = default;
+KVStore::iterator::~iterator() {}

 KVStore::iterator &KVStore::iterator::operator=(KVStore::iterator &&other) {
  pimpl_ = std::move(other.pimpl_);
--- a/src/license/license.cpp
+++ b/src/license/license.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -92,7 +92,7 @@ void RegisterLicenseSettings(LicenseChecker &license_checker, utils::Settings &s
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 LicenseChecker global_license_checker;

-LicenseChecker::~LicenseChecker() { Finalize(); }
+LicenseChecker::~LicenseChecker() { scheduler_.Stop(); }

 std::pair<std::string, std::string> LicenseChecker::ExtractLicenseInfo(const utils::Settings &settings) const {
  if (license_info_override_) {
--- a/src/license/license.hpp
+++ b/src/license/license.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -89,8 +89,6 @@ struct LicenseChecker {

  utils::Synchronized<std::optional<LicenseInfo>, utils::SpinLock> &GetLicenseInfo();

-  void Finalize() { scheduler_.Stop(); }
-
 private:
  std::pair<std::string, std::string> ExtractLicenseInfo(const utils::Settings &settings) const;
  void RevalidateLicense(const utils::Settings &settings);
--- a/src/memgraph.cpp
+++ b/src/memgraph.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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
@@ -65,13 +65,10 @@ void InitFromCypherlFile(memgraph::query::InterpreterContext &ctx, memgraph::dbm
  std::string line;
  while (std::getline(file, line)) {
    if (!line.empty()) {
-      try {
-        auto results = interpreter.Prepare(line, {}, {});
-        memgraph::query::DiscardValueResultStream stream;
-        interpreter.Pull(&stream, {}, results.qid);
-      } catch (const memgraph::query::UserAlreadyExistsException &e) {
-        spdlog::warn("{} The rest of the init-file will be run.", e.what());
-      }
+      auto results = interpreter.Prepare(line, {}, {});
+      memgraph::query::DiscardValueResultStream stream;
+      interpreter.Pull(&stream, {}, results.qid);
+
      if (audit_log) {
        audit_log->Record("", "", line, {}, memgraph::dbms::kDefaultDB);
      }
@@ -163,7 +160,7 @@ int main(int argc, char **argv) {
        // libstd.
        auto gil = memgraph::py::EnsureGIL();
        // NOLINTNEXTLINE(hicpp-signed-bitwise)
-        auto *flag = PyLong_FromLong(RTLD_NOW);
+        auto *flag = PyLong_FromLong(RTLD_NOW | RTLD_DEEPBIND);
        auto *setdl = PySys_GetObject("setdlopenflags");
        MG_ASSERT(setdl);
        auto *arg = PyTuple_New(1);
@@ -184,10 +181,6 @@ int main(int argc, char **argv) {
                                                   "https://memgr.ph/python"));
  }

-  memgraph::utils::Scheduler python_gc_scheduler;
-  python_gc_scheduler.Run("Python GC", std::chrono::seconds(FLAGS_storage_python_gc_cycle_sec),
-                          [] { memgraph::query::procedure::PyCollectGarbage(); });
-
  // Initialize the communication library.
  memgraph::communication::SSLInit sslInit;

@@ -257,8 +250,6 @@ int main(int argc, char **argv) {
  // register all runtime settings
  memgraph::license::RegisterLicenseSettings(memgraph::license::global_license_checker,
                                             memgraph::utils::global_settings);
-  memgraph::utils::OnScopeExit global_license_finalizer([] { memgraph::license::global_license_checker.Finalize(); });
-
  memgraph::flags::run_time::Initialize();

  memgraph::license::global_license_checker.CheckEnvLicense();
@@ -300,8 +291,7 @@ int main(int argc, char **argv) {
  memgraph::storage::Config db_config{
      .gc = {.type = memgraph::storage::Config::Gc::Type::PERIODIC,
             .interval = std::chrono::seconds(FLAGS_storage_gc_cycle_sec)},
-      .items = {.properties_on_edges = FLAGS_storage_properties_on_edges,
-                .enable_schema_metadata = FLAGS_storage_enable_schema_metadata},
+      .items = {.properties_on_edges = FLAGS_storage_properties_on_edges},
      .durability = {.storage_directory = FLAGS_data_directory,
                     .recover_on_startup = FLAGS_storage_recover_on_startup || FLAGS_data_recovery_on_startup,
                     .snapshot_retention_count = FLAGS_storage_snapshot_retention_count,
@@ -311,9 +301,7 @@ int main(int argc, char **argv) {
                     .restore_replication_state_on_startup = FLAGS_replication_restore_state_on_startup,
                     .items_per_batch = FLAGS_storage_items_per_batch,
                     .recovery_thread_count = FLAGS_storage_recovery_thread_count,
-                     // deprecated
-                     .allow_parallel_index_creation = FLAGS_storage_parallel_index_recovery,
-                     .allow_parallel_schema_creation = FLAGS_storage_parallel_schema_recovery},
+                     .allow_parallel_index_creation = FLAGS_storage_parallel_index_recovery},
      .transaction = {.isolation_level = memgraph::flags::ParseIsolationLevel()},
      .disk = {.main_storage_directory = FLAGS_data_directory + "/rocksdb_main_storage",
               .label_index_directory = FLAGS_data_directory + "/rocksdb_label_index",
@@ -324,11 +312,6 @@ int main(int argc, char **argv) {
               .durability_directory = FLAGS_data_directory + "/rocksdb_durability",
               .wal_directory = FLAGS_data_directory + "/rocksdb_wal"},
      .storage_mode = memgraph::flags::ParseStorageMode()};
-
-  memgraph::utils::Scheduler jemalloc_purge_scheduler;
-  jemalloc_purge_scheduler.Run("Jemalloc purge", std::chrono::seconds(FLAGS_storage_gc_cycle_sec),
-                               [] { memgraph::memory::PurgeUnusedMemory(); });
-
  if (FLAGS_storage_snapshot_interval_sec == 0) {
    if (FLAGS_storage_wal_enabled) {
      LOG_FATAL(
@@ -385,18 +368,35 @@ int main(int argc, char **argv) {
  std::unique_ptr<memgraph::query::AuthChecker> auth_checker;
  auth_glue(&auth_, auth_handler, auth_checker);

-  memgraph::dbms::DbmsHandler dbms_handler(db_config
+  memgraph::replication::ReplicationState repl_state(ReplicationStateRootPath(db_config));
+
+  memgraph::dbms::DbmsHandler dbms_handler(db_config, repl_state
 #ifdef MG_ENTERPRISE
                                           ,
                                           &auth_, FLAGS_data_recovery_on_startup, FLAGS_storage_delete_on_drop
 #endif
  );
  auto db_acc = dbms_handler.Get();
-
-  memgraph::query::InterpreterContext interpreter_context_(
-      interp_config, &dbms_handler, &dbms_handler.ReplicationState(), auth_handler.get(), auth_checker.get());
+  memgraph::query::InterpreterContext interpreter_context_(interp_config, &dbms_handler, &repl_state,
+                                                           auth_handler.get(), auth_checker.get());
  MG_ASSERT(db_acc, "Failed to access the main database");

+  // TODO: Move it somewhere better
+  // Startup replication state (if recovered at startup)
+  MG_ASSERT(std::visit(memgraph::utils::Overloaded{[](memgraph::replication::RoleMainData const &) { return true; },
+                                                   [&](memgraph::replication::RoleReplicaData const &data) {
+                                                     // Register handlers
+                                                     memgraph::dbms::InMemoryReplicationHandlers::Register(
+                                                         &dbms_handler, *data.server);
+                                                     if (!data.server->Start()) {
+                                                       spdlog::error("Unable to start the replication server.");
+                                                       return false;
+                                                     }
+                                                     return true;
+                                                   }},
+                       repl_state.ReplicationData()),
+            "Replica recovery failure!");
+
  memgraph::query::procedure::gModuleRegistry.SetModulesDirectory(memgraph::flags::ParseQueryModulesDirectory(),
                                                                  FLAGS_data_directory);
  memgraph::query::procedure::gModuleRegistry.UnloadAndLoadModulesFromDirectories();
@@ -548,7 +548,6 @@ int main(int argc, char **argv) {

  memgraph::query::procedure::gModuleRegistry.UnloadAllModules();

-  python_gc_scheduler.Stop();
  Py_END_ALLOW_THREADS;
  // Shutdown Python
  Py_Finalize();
--- a/src/memory/global_memory_control.cpp
+++ b/src/memory/global_memory_control.cpp
@@ -119,7 +119,7 @@ static bool my_commit(extent_hooks_t *extent_hooks, void *addr, size_t size, siz

  memgraph::utils::total_memory_tracker.Alloc(static_cast<int64_t>(length));
  if (GetQueriesMemoryControl().IsThreadTracked()) [[unlikely]] {
-    GetQueriesMemoryControl().TrackAllocOnCurrentThread(size);
+    GetQueriesMemoryControl().TrackFreeOnCurrentThread(size);
  }

  return false;
--- a/src/memory/query_memory_control.cpp
+++ b/src/memory/query_memory_control.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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,22 +36,14 @@ namespace memgraph::memory {

 void QueriesMemoryControl::UpdateThreadToTransactionId(const std::thread::id &thread_id, uint64_t transaction_id) {
  auto accessor = thread_id_to_transaction_id.access();
-  auto elem = accessor.find(thread_id);
-  if (elem == accessor.end()) {
-    accessor.insert({thread_id, {transaction_id, 1}});
-  } else {
-    elem->transaction_id.cnt++;
-  }
+  accessor.insert({thread_id, transaction_id});
 }

 void QueriesMemoryControl::EraseThreadToTransactionId(const std::thread::id &thread_id, uint64_t transaction_id) {
  auto accessor = thread_id_to_transaction_id.access();
  auto elem = accessor.find(thread_id);
  MG_ASSERT(elem != accessor.end() && elem->transaction_id == transaction_id);
-  elem->transaction_id.cnt--;
-  if (elem->transaction_id.cnt == 0) {
-    accessor.remove(thread_id);
-  }
+  accessor.remove(thread_id);
 }

 void QueriesMemoryControl::TrackAllocOnCurrentThread(size_t size) {
@@ -162,6 +154,12 @@ inline int &Get_Thread_Tracker() {

 bool QueriesMemoryControl::IsThreadTracked() { return Get_Thread_Tracker() == 1; }

+void QueriesMemoryControl::ResetTrackings() {
+  Get_Thread_Tracker() = 0;
+  transaction_id_to_tracker.clear();
+  thread_id_to_transaction_id.clear();
+}
+
 #endif

 void StartTrackingCurrentThreadTransaction(uint64_t transaction_id) {
@@ -198,6 +196,12 @@ void TryStopTrackingOnTransaction(uint64_t transaction_id) {
 #endif
 }

+void CleanTracker() {
+#if USE_JEMALLOC
+  GetQueriesMemoryControl().ResetTrackings();
+#endif
+}
+
 #if USE_JEMALLOC
 bool IsTransactionTracked(uint64_t transaction_id) {
  return GetQueriesMemoryControl().CheckTransactionIdTrackerExists(transaction_id);
--- a/src/memory/query_memory_control.hpp
+++ b/src/memory/query_memory_control.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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
@@ -77,21 +77,16 @@ class QueriesMemoryControl {

  bool IsThreadTracked();

+  // This method resets all the trackings.
+  // Method is not thread-safe so it should
+  // be called when there is global lock
+  // to not create new transactions
+  void ResetTrackings();
+
 private:
-  struct TransactionId {
-    uint64_t id;
-    uint64_t cnt;
-
-    bool operator<(const TransactionId &other) const { return id < other.id; }
-    bool operator==(const TransactionId &other) const { return id == other.id; }
-
-    bool operator<(uint64_t other) const { return id < other; }
-    bool operator==(uint64_t other) const { return id == other; }
-  };
-
  struct ThreadIdToTransactionId {
    std::thread::id thread_id;
-    TransactionId transaction_id;
+    uint64_t transaction_id;

    bool operator<(const ThreadIdToTransactionId &other) const { return thread_id < other.thread_id; }
    bool operator==(const ThreadIdToTransactionId &other) const { return thread_id == other.thread_id; }
@@ -109,9 +104,6 @@ class QueriesMemoryControl {

    bool operator<(uint64_t other) const { return transaction_id < other; }
    bool operator==(uint64_t other) const { return transaction_id == other; }
-
-    bool operator<(TransactionId other) const { return transaction_id < other.id; }
-    bool operator==(TransactionId other) const { return transaction_id == other.id; }
  };

  utils::SkipList<ThreadIdToTransactionId> thread_id_to_transaction_id;
@@ -141,6 +133,11 @@ void TryStartTrackingOnTransaction(uint64_t transaction_id, size_t limit);
 // Does nothing if jemalloc is not enabled. Does nothing if tracker doesn't exist
 void TryStopTrackingOnTransaction(uint64_t transaction_id);

+// This method requires lock on global storage
+// It will clean all trackers which may accidentally have left in system
+// It will reset any tracking on arenas
+void CleanTracker();
+
 // Is transaction with given id tracked in memory tracker
 bool IsTransactionTracked(uint64_t transaction_id);

--- a/src/mg_import_csv.cpp
+++ b/src/mg_import_csv.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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
@@ -32,8 +32,6 @@
 #include "utils/timer.hpp"
 #include "version.hpp"

-using memgraph::replication::ReplicationRole;
-
 bool ValidateControlCharacter(const char *flagname, const std::string &value) {
  if (value.empty()) {
    printf("The argument '%s' cannot be empty\n", flagname);
@@ -427,7 +425,7 @@ void ProcessNodeRow(memgraph::storage::Storage *store, const std::vector<std::st
                    const std::vector<Field> &fields, const std::vector<std::string> &additional_labels,
                    std::unordered_map<NodeId, memgraph::storage::Gid> *node_id_map) {
  std::optional<NodeId> id;
-  auto acc = store->Access(ReplicationRole::MAIN);
+  auto acc = store->Access();
  auto node = acc->CreateVertex();
  for (size_t i = 0; i < row.size(); ++i) {
    const auto &field = fields[i];
@@ -573,7 +571,7 @@ void ProcessRelationshipsRow(memgraph::storage::Storage *store, const std::vecto
  if (!end_id) throw LoadException("END_ID must be set");
  if (!relationship_type) throw LoadException("Relationship TYPE must be set");

-  auto acc = store->Access(ReplicationRole::MAIN);
+  auto acc = store->Access();
  auto from_node = acc->FindVertex(*start_id, memgraph::storage::View::NEW);
  if (!from_node) throw LoadException("From node must be in the storage");
  auto to_node = acc->FindVertex(*end_id, memgraph::storage::View::NEW);
--- a/src/query/common.cpp
+++ b/src/query/common.cpp
@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// Copyright 2022 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -62,7 +62,6 @@ bool TypedValueCompare(const TypedValue &a, const TypedValue &b) {
    case TypedValue::Type::Edge:
    case TypedValue::Type::Path:
    case TypedValue::Type::Graph:
-    case TypedValue::Type::Function:
      throw QueryRuntimeException("Comparison is not defined for values of type {}.", a.type());
    case TypedValue::Type::Null:
      LOG_FATAL("Invalid type");
--- a/src/query/common.hpp
+++ b/src/query/common.hpp
@@ -41,7 +41,7 @@ bool TypedValueCompare(const TypedValue &a, const TypedValue &b);
 /// the define how respective elements compare.
 class TypedValueVectorCompare final {
 public:
-  TypedValueVectorCompare() = default;
+  TypedValueVectorCompare() {}
  explicit TypedValueVectorCompare(const std::vector<Ordering> &ordering) : ordering_(ordering) {}

  template <class TAllocator>
@@ -147,8 +147,8 @@ concept AccessorWithUpdateProperties = requires(T accessor,
 ///
 /// @throw QueryRuntimeException if value cannot be set as a property value
 template <AccessorWithUpdateProperties T>
-auto UpdatePropertiesChecked(T *record, std::map<storage::PropertyId, storage::PropertyValue> &properties)
-    -> std::remove_reference_t<decltype(record->UpdateProperties(properties).GetValue())> {
+auto UpdatePropertiesChecked(T *record, std::map<storage::PropertyId, storage::PropertyValue> &properties) ->
+    typename std::remove_reference<decltype(record->UpdateProperties(properties).GetValue())>::type {
  try {
    auto maybe_values = record->UpdateProperties(properties);
    if (maybe_values.HasError()) {
--- a/src/query/cypher_query_interpreter.cpp
+++ b/src/query/cypher_query_interpreter.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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
@@ -12,6 +12,7 @@
 #include "query/cypher_query_interpreter.hpp"
 #include "query/frontend/ast/cypher_main_visitor.hpp"
 #include "query/frontend/opencypher/parser.hpp"
+#include "utils/synchronized.hpp"

 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_bool(query_cost_planner, true, "Use the cost-estimating query planner.");
@@ -79,7 +80,7 @@ ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::stri
    // Convert the ANTLR4 parse tree into an AST.
    AstStorage ast_storage;
    frontend::ParsingContext context{.is_query_cached = true};
-    frontend::CypherMainVisitor visitor(context, &ast_storage, &parameters);
+    frontend::CypherMainVisitor visitor(context, &ast_storage);

    visitor.visit(parser->tree());

--- a/src/query/cypher_query_interpreter.hpp
+++ b/src/query/cypher_query_interpreter.hpp
@@ -11,8 +11,6 @@

 #pragma once

-#include <utility>
-
 #include "query/config.hpp"
 #include "query/frontend/semantic/required_privileges.hpp"
 #include "query/frontend/semantic/symbol_generator.hpp"
@@ -100,8 +98,8 @@ ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::stri
 class SingleNodeLogicalPlan final : public LogicalPlan {
 public:
  SingleNodeLogicalPlan(std::unique_ptr<plan::LogicalOperator> root, double cost, AstStorage storage,
-                        SymbolTable symbol_table)
-      : root_(std::move(root)), cost_(cost), storage_(std::move(storage)), symbol_table_(std::move(symbol_table)) {}
+                        const SymbolTable &symbol_table)
+      : root_(std::move(root)), cost_(cost), storage_(std::move(storage)), symbol_table_(symbol_table) {}

  const plan::LogicalOperator &GetRoot() const override { return *root_; }
  double GetCost() const override { return cost_; }
--- a/src/query/db_accessor.cpp
+++ b/src/query/db_accessor.cpp
@@ -15,7 +15,6 @@

 #include <cppitertools/filter.hpp>
 #include <cppitertools/imap.hpp>
-#include "storage/v2/storage_mode.hpp"
 #include "utils/pmr/unordered_set.hpp"

 namespace memgraph::query {
@@ -140,8 +139,6 @@ std::optional<VertexAccessor> SubgraphDbAccessor::FindVertex(storage::Gid gid, s

 query::Graph *SubgraphDbAccessor::getGraph() { return graph_; }

-storage::StorageMode SubgraphDbAccessor::GetStorageMode() const noexcept { return db_accessor_.GetStorageMode(); }
-
 DbAccessor *SubgraphDbAccessor::GetAccessor() { return &db_accessor_; }

 VertexAccessor SubgraphVertexAccessor::GetVertexAccessor() const { return impl_; }
--- a/src/query/db_accessor.hpp
+++ b/src/query/db_accessor.hpp
@@ -40,10 +40,9 @@ class EdgeAccessor final {
 public:
  storage::EdgeAccessor impl_;

+ public:
  explicit EdgeAccessor(storage::EdgeAccessor impl) : impl_(std::move(impl)) {}

-  bool IsDeleted() const { return impl_.IsDeleted(); }
-
  bool IsVisible(storage::View view) const { return impl_.IsVisible(view); }

  storage::EdgeTypeId EdgeType() const { return impl_.EdgeType(); }
@@ -109,6 +108,7 @@ class VertexAccessor final {

  static EdgeAccessor MakeEdgeAccessor(const storage::EdgeAccessor impl) { return EdgeAccessor(impl); }

+ public:
  explicit VertexAccessor(storage::VertexAccessor impl) : impl_(impl) {}

  bool IsVisible(storage::View view) const { return impl_.IsVisible(view); }
@@ -545,7 +545,7 @@ class DbAccessor final {

  void Abort() { accessor_->Abort(); }

-  storage::StorageMode GetStorageMode() const noexcept { return accessor_->GetCreationStorageMode(); }
+  storage::StorageMode GetStorageMode() const { return accessor_->GetCreationStorageMode(); }

  bool LabelIndexExists(storage::LabelId label) const { return accessor_->LabelIndexExists(label); }

@@ -597,13 +597,6 @@ class DbAccessor final {
    return accessor_->ApproximateVertexCount(label, property, lower, upper);
  }

-  std::vector<storage::LabelId> ListAllPossiblyPresentVertexLabels() const {
-    return accessor_->ListAllPossiblyPresentVertexLabels();
-  }
-  std::vector<storage::EdgeTypeId> ListAllPossiblyPresentEdgeTypes() const {
-    return accessor_->ListAllPossiblyPresentEdgeTypes();
-  }
-
  storage::IndicesInfo ListAllIndices() const { return accessor_->ListAllIndices(); }

  storage::ConstraintsInfo ListAllConstraints() const { return accessor_->ListAllConstraints(); }
@@ -702,8 +695,6 @@ class SubgraphDbAccessor final {

  Graph *getGraph();

-  storage::StorageMode GetStorageMode() const noexcept;
-
  DbAccessor *GetAccessor();
 };

--- a/src/query/dump.cpp
+++ b/src/query/dump.cpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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,7 +11,6 @@

 #include "query/dump.hpp"

-#include <algorithm>
 #include <iomanip>
 #include <limits>
 #include <map>
@@ -22,11 +21,9 @@

 #include <fmt/format.h>

-#include "dbms/database.hpp"
 #include "query/db_accessor.hpp"
 #include "query/exceptions.hpp"
 #include "query/stream.hpp"
-#include "query/trigger_context.hpp"
 #include "query/typed_value.hpp"
 #include "storage/v2/property_value.hpp"
 #include "storage/v2/storage.hpp"
@@ -162,7 +159,7 @@ void DumpProperties(std::ostream *os, query::DbAccessor *dba,
  *os << "{";
  if (property_id) {
    *os << kInternalPropertyId << ": " << *property_id;
-    if (!store.empty()) *os << ", ";
+    if (store.size() > 0) *os << ", ";
  }
  utils::PrintIterable(*os, store, ", ", [&dba](auto &os, const auto &kv) {
    os << EscapeName(dba->PropertyToName(kv.first)) << ": ";
@@ -231,7 +228,7 @@ void DumpEdge(std::ostream *os, query::DbAccessor *dba, const query::EdgeAccesso
        throw query::QueryRuntimeException("Unexpected error when getting properties.");
    }
  }
-  if (!maybe_props->empty()) {
+  if (maybe_props->size() > 0) {
    *os << " ";
    DumpProperties(os, dba, *maybe_props);
  }
@@ -263,20 +260,10 @@ void DumpUniqueConstraint(std::ostream *os, query::DbAccessor *dba, storage::Lab
  *os << " IS UNIQUE;";
 }

-const char *triggerPhaseToString(TriggerPhase phase) {
-  switch (phase) {
-    case TriggerPhase::BEFORE_COMMIT:
-      return "BEFORE COMMIT EXECUTE";
-    case TriggerPhase::AFTER_COMMIT:
-      return "AFTER COMMIT EXECUTE";
-  }
-}
-
 }  // namespace

-PullPlanDump::PullPlanDump(DbAccessor *dba, dbms::DatabaseAccess db_acc)
+PullPlanDump::PullPlanDump(DbAccessor *dba)
    : dba_(dba),
-      db_acc_(db_acc),
      vertices_iterable_(dba->Vertices(storage::View::OLD)),
      pull_chunks_{// Dump all label indices
                   CreateLabelIndicesPullChunk(),
@@ -295,9 +282,7 @@ PullPlanDump::PullPlanDump(DbAccessor *dba, dbms::DatabaseAccess db_acc)
                   // Drop the internal index
                   CreateDropInternalIndexPullChunk(),
                   // Internal index cleanup
-                   CreateInternalIndexCleanupPullChunk(),
-                   // Dump all triggers
-                   CreateTriggersPullChunk()} {}
+                   CreateInternalIndexCleanupPullChunk()} {}

 bool PullPlanDump::Pull(AnyStream *stream, std::optional<int> n) {
  // Iterate all functions that stream some results.
@@ -551,23 +536,6 @@ PullPlanDump::PullChunk PullPlanDump::CreateInternalIndexCleanupPullChunk() {
  };
 }

-PullPlanDump::PullChunk PullPlanDump::CreateTriggersPullChunk() {
-  return [this](AnyStream *stream, std::optional<int>) {
-    auto triggers = db_acc_->trigger_store()->GetTriggerInfo();
-    for (const auto &trigger : triggers) {
-      std::ostringstream os;
-      auto trigger_statement_copy = trigger.statement;
-      std::replace(trigger_statement_copy.begin(), trigger_statement_copy.end(), '\n', ' ');
-      os << "CREATE TRIGGER " << trigger.name << " ON " << memgraph::query::TriggerEventTypeToString(trigger.event_type)
-         << " " << triggerPhaseToString(trigger.phase) << " " << trigger_statement_copy << ";";
-      stream->Result({TypedValue(os.str())});
-    }
-    return 0;
-  };
-}
-
-void DumpDatabaseToCypherQueries(query::DbAccessor *dba, AnyStream *stream, dbms::DatabaseAccess db_acc) {
-  PullPlanDump(dba, db_acc).Pull(stream, {});
-}
+void DumpDatabaseToCypherQueries(query::DbAccessor *dba, AnyStream *stream) { PullPlanDump(dba).Pull(stream, {}); }

 }  // namespace memgraph::query
--- a/src/query/dump.hpp
+++ b/src/query/dump.hpp
@@ -1,4 +1,4 @@
-// Copyright 2024 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,17 +11,18 @@

 #pragma once

-#include "dbms/database.hpp"
+#include <ostream>
+
 #include "query/db_accessor.hpp"
 #include "query/stream.hpp"
 #include "storage/v2/storage.hpp"

 namespace memgraph::query {

-void DumpDatabaseToCypherQueries(query::DbAccessor *dba, AnyStream *stream, dbms::DatabaseAccess db_acc);
+void DumpDatabaseToCypherQueries(query::DbAccessor *dba, AnyStream *stream);

 struct PullPlanDump {
-  explicit PullPlanDump(query::DbAccessor *dba, dbms::DatabaseAccess db_acc);
+  explicit PullPlanDump(query::DbAccessor *dba);

  /// Pull the dump results lazily
  /// @return true if all results were returned, false otherwise
@@ -29,7 +30,6 @@ struct PullPlanDump {

 private:
  query::DbAccessor *dba_ = nullptr;
-  dbms::DatabaseAccess db_acc_;

  std::optional<storage::IndicesInfo> indices_info_ = std::nullopt;
  std::optional<storage::ConstraintsInfo> constraints_info_ = std::nullopt;
@@ -62,6 +62,5 @@ struct PullPlanDump {
  PullChunk CreateEdgePullChunk();
  PullChunk CreateDropInternalIndexPullChunk();
  PullChunk CreateInternalIndexCleanupPullChunk();
-  PullChunk CreateTriggersPullChunk();
 };
 }  // namespace memgraph::query
--- a/src/query/exceptions.hpp
+++ b/src/query/exceptions.hpp
@@ -126,12 +126,6 @@ class InfoInMulticommandTxException : public QueryException {
  SPECIALIZE_GET_EXCEPTION_NAME(InfoInMulticommandTxException)
 };

-class UserAlreadyExistsException : public QueryException {
- public:
-  using QueryException::QueryException;
-  SPECIALIZE_GET_EXCEPTION_NAME(UserAlreadyExistsException)
-};
-
 /**
 * An exception for an illegal operation that can not be detected
 * before the query starts executing over data.
--- a/src/query/frame_change.hpp
+++ b/src/query/frame_change.hpp
@@ -8,49 +8,48 @@
 // 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 <tuple>
-#include <utility>
 #include "query/typed_value.hpp"
-#include "utils/fnv.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, utils::pmr::vector<TypedValue>>;
+using CachedType = utils::pmr::unordered_map<size_t, std::vector<TypedValue>>;

 struct CachedValue {
-  using allocator_type = utils::Allocator<CachedValue>;
-
  // Cached value, this can be probably templateized
  CachedType cache_;

-  explicit CachedValue(utils::MemoryResource *mem) : cache_{mem} {};
-  CachedValue(const CachedValue &other, utils::MemoryResource *mem) : cache_(other.cache_, mem) {}
-  CachedValue(CachedValue &&other, utils::MemoryResource *mem) : cache_(std::move(other.cache_), mem){};
+  explicit CachedValue(utils::MemoryResource *mem) : cache_(mem) {}

-  CachedValue(CachedValue &&other) noexcept : CachedValue(std::move(other), other.GetMemoryResource()) {}
+  CachedValue(CachedType &&cache, memgraph::utils::MemoryResource *memory) : cache_(std::move(cache), memory) {}

-  CachedValue(const CachedValue &other)
-      : CachedValue(other, std::allocator_traits<allocator_type>::select_on_container_copy_construction(
-                               other.GetMemoryResource())
-                               .GetMemoryResource()) {}
+  CachedValue(const CachedValue &other, memgraph::utils::MemoryResource *memory) : cache_(other.cache_, memory) {}

-  utils::MemoryResource *GetMemoryResource() const { return cache_.get_allocator().GetMemoryResource(); }
+  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();
+  }
+
  bool CacheValue(const TypedValue &maybe_list) {
    if (!maybe_list.IsList()) {
      return false;
    }
-    const auto &list = maybe_list.ValueList();
+    auto &list = maybe_list.ValueList();
    TypedValue::Hash hash{};
-    for (const auto &element : list) {
+    for (auto &element : list) {
      const auto key = hash(element);
      auto &vector_values = cache_[key];
      if (!IsValueInVec(vector_values, element)) {
@@ -71,7 +70,7 @@ struct CachedValue {
  }

 private:
-  static bool IsValueInVec(const utils::pmr::vector<TypedValue> &vec_values, const TypedValue &value) {
+  static bool IsValueInVec(const std::vector<TypedValue> &vec_values, const TypedValue &value) {
    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;
@@ -83,70 +82,35 @@ struct CachedValue {
 // Class tracks keys for which user can cache values which help with faster search or faster retrieval
 // in the future. Used for IN LIST operator.
 class FrameChangeCollector {
-  /** Allocator type so that STL containers are aware that we need one */
-  using allocator_type = utils::Allocator<FrameChangeCollector>;
-
 public:
-  explicit FrameChangeCollector(utils::MemoryResource *mem = utils::NewDeleteResource()) : tracked_values_{mem} {}
-
-  FrameChangeCollector(FrameChangeCollector &&other, utils::MemoryResource *mem)
-      : tracked_values_(std::move(other.tracked_values_), mem) {}
-  FrameChangeCollector(const FrameChangeCollector &other, utils::MemoryResource *mem)
-      : tracked_values_(other.tracked_values_, mem) {}
-
-  FrameChangeCollector(const FrameChangeCollector &other)
-      : FrameChangeCollector(other, std::allocator_traits<allocator_type>::select_on_container_copy_construction(
-                                        other.GetMemoryResource())
-                                        .GetMemoryResource()){};
-
-  FrameChangeCollector(FrameChangeCollector &&other) noexcept
-      : FrameChangeCollector(std::move(other), other.GetMemoryResource()) {}
-
-  /** Copy assign other, utils::MemoryResource of `this` is used */
-  FrameChangeCollector &operator=(const FrameChangeCollector &) = default;
-
-  /** Move assign other, utils::MemoryResource of `this` is used. */
-  FrameChangeCollector &operator=(FrameChangeCollector &&) noexcept = default;
-
-  utils::MemoryResource *GetMemoryResource() const { return tracked_values_.get_allocator().GetMemoryResource(); }
+  explicit FrameChangeCollector() : tracked_values_(&memory_resource_){};

  CachedValue &AddTrackingKey(const std::string &key) {
-    const auto &[it, _] = tracked_values_.emplace(
-        std::piecewise_construct, std::forward_as_tuple(utils::pmr::string(key, utils::NewDeleteResource())),
-        std::forward_as_tuple());
+    const auto &[it, _] = tracked_values_.emplace(key, tracked_values_.get_allocator().GetMemoryResource());
    return it->second;
  }

-  bool IsKeyTracked(const std::string &key) const {
-    return tracked_values_.contains(utils::pmr::string(key, utils::NewDeleteResource()));
-  }
+  bool IsKeyTracked(const std::string &key) const { return tracked_values_.contains(key); }

  bool IsKeyValueCached(const std::string &key) const {
-    return IsKeyTracked(key) && !tracked_values_.at(utils::pmr::string(key, utils::NewDeleteResource())).cache_.empty();
+    return IsKeyTracked(key) && !tracked_values_.at(key).cache_.empty();
  }

  bool ResetTrackingValue(const std::string &key) {
-    if (!tracked_values_.contains(utils::pmr::string(key, utils::NewDeleteResource()))) {
+    if (!tracked_values_.contains(key)) {
      return false;
    }
-    tracked_values_.erase(utils::pmr::string(key, utils::NewDeleteResource()));
+    tracked_values_.erase(key);
    AddTrackingKey(key);
    return true;
  }

-  CachedValue &GetCachedValue(const std::string &key) {
-    return tracked_values_.at(utils::pmr::string(key, utils::NewDeleteResource()));
-  }
+  CachedValue &GetCachedValue(const std::string &key) { return tracked_values_.at(key); }

  bool IsTrackingValues() const { return !tracked_values_.empty(); }

-  ~FrameChangeCollector() = default;
-
 private:
-  struct PmrStringHash {
-    size_t operator()(const utils::pmr::string &key) const { return utils::Fnv(key); }
-  };
-
-  utils::pmr::unordered_map<utils::pmr::string, CachedValue, PmrStringHash> tracked_values_;
+  utils::MonotonicBufferResource memory_resource_{0};
+  memgraph::utils::pmr::unordered_map<std::string, CachedValue> tracked_values_;
 };
 }  // namespace memgraph::query
--- a/src/query/frontend/ast/ast.cpp
+++ b/src/query/frontend/ast/ast.cpp
@@ -293,7 +293,4 @@ constexpr utils::TypeInfo query::ShowDatabasesQuery::kType{utils::TypeId::AST_SH
 constexpr utils::TypeInfo query::EdgeImportModeQuery::kType{utils::TypeId::AST_EDGE_IMPORT_MODE_QUERY,
                                                            "EdgeImportModeQuery", &query::Query::kType};

-constexpr utils::TypeInfo query::PatternComprehension::kType{utils::TypeId::AST_PATTERN_COMPREHENSION,
-                                                             "PatternComprehension", &query::Expression::kType};
-
 }  // namespace memgraph
--- a/src/query/frontend/ast/ast.hpp
+++ b/src/query/frontend/ast/ast.hpp
@@ -23,7 +23,9 @@
 #include "storage/v2/property_value.hpp"
 #include "utils/typeinfo.hpp"

-namespace memgraph::query {
+namespace memgraph {
+
+namespace query {

 struct LabelIx {
  static const utils::TypeInfo kType;
@@ -60,8 +62,8 @@ inline bool operator!=(const PropertyIx &a, const PropertyIx &b) { return !(a ==
 inline bool operator==(const EdgeTypeIx &a, const EdgeTypeIx &b) { return a.ix == b.ix && a.name == b.name; }

 inline bool operator!=(const EdgeTypeIx &a, const EdgeTypeIx &b) { return !(a == b); }
-}  // namespace memgraph::query
-
+}  // namespace query
+}  // namespace memgraph
 namespace std {

 template <>
@@ -81,7 +83,9 @@ struct hash<memgraph::query::EdgeTypeIx> {

 }  // namespace std

-namespace memgraph::query {
+namespace memgraph {
+
+namespace query {

 class Tree;

@@ -1818,10 +1822,6 @@ class EdgeAtom : public memgraph::query::PatternAtom {
    memgraph::query::Identifier *inner_edge{nullptr};
    /// Argument identifier for the destination node of the edge.
    memgraph::query::Identifier *inner_node{nullptr};
-    /// Argument identifier for the currently-accumulated path.
-    memgraph::query::Identifier *accumulated_path{nullptr};
-    /// Argument identifier for the weight of the currently-accumulated path.
-    memgraph::query::Identifier *accumulated_weight{nullptr};
    /// Evaluates the result of the lambda.
    memgraph::query::Expression *expression{nullptr};

@@ -1829,8 +1829,6 @@ class EdgeAtom : public memgraph::query::PatternAtom {
      Lambda object;
      object.inner_edge = inner_edge ? inner_edge->Clone(storage) : nullptr;
      object.inner_node = inner_node ? inner_node->Clone(storage) : nullptr;
-      object.accumulated_path = accumulated_path ? accumulated_path->Clone(storage) : nullptr;
-      object.accumulated_weight = accumulated_weight ? accumulated_weight->Clone(storage) : nullptr;
      object.expression = expression ? expression->Clone(storage) : nullptr;
      return object;
    }
@@ -2934,7 +2932,7 @@ class DatabaseInfoQuery : public memgraph::query::Query {
  static const utils::TypeInfo kType;
  const utils::TypeInfo &GetTypeInfo() const override { return kType; }

-  enum class InfoType { INDEX, CONSTRAINT, EDGE_TYPES, NODE_LABELS };
+  enum class InfoType { INDEX, CONSTRAINT };

  DEFVISITABLE(QueryVisitor<void>);

@@ -3031,7 +3029,7 @@ class ReplicationQuery : public memgraph::query::Query {

  enum class SyncMode { SYNC, ASYNC };

-  enum class ReplicaState { READY, REPLICATING, RECOVERY, MAYBE_BEHIND };
+  enum class ReplicaState { READY, REPLICATING, RECOVERY, INVALID };

  ReplicationQuery() = default;

@@ -3520,65 +3518,6 @@ class Exists : public memgraph::query::Expression {
  friend class AstStorage;
 };

-class PatternComprehension : public memgraph::query::Expression {
- public:
-  static const utils::TypeInfo kType;
-  const utils::TypeInfo &GetTypeInfo() const override { return kType; }
-
-  PatternComprehension() = default;
-
-  DEFVISITABLE(ExpressionVisitor<TypedValue>);
-  DEFVISITABLE(ExpressionVisitor<TypedValue *>);
-  DEFVISITABLE(ExpressionVisitor<void>);
-
-  bool Accept(HierarchicalTreeVisitor &visitor) override {
-    if (visitor.PreVisit(*this)) {
-      if (variable_) {
-        variable_->Accept(visitor);
-      }
-      pattern_->Accept(visitor);
-      if (filter_) {
-        filter_->Accept(visitor);
-      }
-      resultExpr_->Accept(visitor);
-    }
-    return visitor.PostVisit(*this);
-  }
-
-  PatternComprehension *MapTo(const Symbol &symbol) {
-    symbol_pos_ = symbol.position();
-    return this;
-  }
-
-  // The variable name.
-  Identifier *variable_{nullptr};
-  // The pattern to match.
-  Pattern *pattern_{nullptr};
-  // Optional WHERE clause for filtering.
-  Where *filter_{nullptr};
-  // The projection expression.
-  Expression *resultExpr_{nullptr};
-
-  /// Symbol table position of the symbol this Aggregation is mapped to.
-  int32_t symbol_pos_{-1};
-
-  PatternComprehension *Clone(AstStorage *storage) const override {
-    PatternComprehension *object = storage->Create<PatternComprehension>();
-    object->pattern_ = pattern_ ? pattern_->Clone(storage) : nullptr;
-    object->filter_ = filter_ ? filter_->Clone(storage) : nullptr;
-    object->resultExpr_ = resultExpr_ ? resultExpr_->Clone(storage) : nullptr;
-
-    object->symbol_pos_ = symbol_pos_;
-    return object;
-  }
-
- protected:
-  PatternComprehension(Identifier *variable, Pattern *pattern) : variable_(variable), pattern_(pattern) {}
-
- private:
-  friend class AstStorage;
-};
-
 class CallSubquery : public memgraph::query::Clause {
 public:
  static const utils::TypeInfo kType;
@@ -3638,4 +3577,5 @@ class ShowDatabasesQuery : public memgraph::query::Query {
  }
 };

-}  // namespace memgraph::query
+}  // namespace query
+}  // namespace memgraph
--- a/src/query/frontend/ast/ast_visitor.hpp
+++ b/src/query/frontend/ast/ast_visitor.hpp
@@ -107,7 +107,6 @@ class Exists;
 class MultiDatabaseQuery;
 class ShowDatabasesQuery;
 class EdgeImportModeQuery;
-class PatternComprehension;

 using TreeCompositeVisitor = utils::CompositeVisitor<
    SingleQuery, CypherUnion, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator, AdditionOperator,
@@ -117,7 +116,7 @@ using TreeCompositeVisitor = utils::CompositeVisitor<
    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, PatternComprehension>;
+    Foreach, Exists, CallSubquery, CypherQuery>;

 using TreeLeafVisitor = utils::LeafVisitor<Identifier, PrimitiveLiteral, ParameterLookup>;

@@ -138,7 +137,7 @@ class ExpressionVisitor
                            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, PatternComprehension> {};
+                            ParameterLookup, Identifier, PrimitiveLiteral, RegexMatch, Exists> {};

 template <class TResult>
 class QueryVisitor
--- a/src/query/frontend/ast/cypher_main_visitor.cpp
+++ b/src/query/frontend/ast/cypher_main_visitor.cpp
@@ -124,14 +124,6 @@ antlrcpp::Any CypherMainVisitor::visitDatabaseInfoQuery(MemgraphCypher::Database
    info_query->info_type_ = DatabaseInfoQuery::InfoType::CONSTRAINT;
    return info_query;
  }
-  if (ctx->edgetypeInfo()) {
-    info_query->info_type_ = DatabaseInfoQuery::InfoType::EDGE_TYPES;
-    return info_query;
-  }
-  if (ctx->nodelabelInfo()) {
-    info_query->info_type_ = DatabaseInfoQuery::InfoType::NODE_LABELS;
-    return info_query;
-  }
  // Should never get here
  throw utils::NotYetImplemented("Database info query: '{}'", ctx->getText());
 }
@@ -1276,59 +1268,28 @@ antlrcpp::Any CypherMainVisitor::visitCallProcedure(MemgraphCypher::CallProcedur
      call_proc->result_identifiers_.push_back(storage_->Create<Identifier>(result_alias));
    }
  } else {
-    call_proc->is_write_ = maybe_found->second->info.is_write;
-
-    auto *yield_ctx = ctx->yieldProcedureResults();
-    if (!yield_ctx) {
-      if (!maybe_found->second->results.empty() && !call_proc->void_procedure_) {
-        throw SemanticException(
-            "CALL without YIELD may only be used on procedures which do not "
-            "return any result fields.");
-      }
-      // When we return, we will release the lock on modules. This means that
-      // someone may reload the procedure and change the result signature. But to
-      // keep the implementation simple, we ignore the case as the rest of the
-      // code doesn't really care whether we yield or not, so it should not break.
-      return call_proc;
+    const auto &maybe_found =
+        procedure::FindProcedure(procedure::gModuleRegistry, call_proc->procedure_name_, utils::NewDeleteResource());
+    if (!maybe_found) {
+      throw SemanticException("There is no procedure named '{}'.", call_proc->procedure_name_);
    }
-    if (yield_ctx->getTokens(MemgraphCypher::ASTERISK).empty()) {
-      call_proc->result_fields_.reserve(yield_ctx->procedureResult().size());
-      call_proc->result_identifiers_.reserve(yield_ctx->procedureResult().size());
-      for (auto *result : yield_ctx->procedureResult()) {
-        MG_ASSERT(result->variable().size() == 1 || result->variable().size() == 2);
-        call_proc->result_fields_.push_back(std::any_cast<std::string>(result->variable()[0]->accept(this)));
-        std::string result_alias;
-        if (result->variable().size() == 2) {
-          result_alias = std::any_cast<std::string>(result->variable()[1]->accept(this));
-        } else {
-          result_alias = std::any_cast<std::string>(result->variable()[0]->accept(this));
-        }
-        call_proc->result_identifiers_.push_back(storage_->Create<Identifier>(result_alias));
-      }
-    } else {
-      const auto &maybe_found =
-          procedure::FindProcedure(procedure::gModuleRegistry, call_proc->procedure_name_, utils::NewDeleteResource());
-      if (!maybe_found) {
-        throw SemanticException("There is no procedure named '{}'.", call_proc->procedure_name_);
-      }
-      const auto &[module, proc] = *maybe_found;
-      call_proc->result_fields_.reserve(proc->results.size());
-      call_proc->result_identifiers_.reserve(proc->results.size());
-      for (const auto &[result_name, desc] : proc->results) {
-        bool is_deprecated = desc.second;
-        if (is_deprecated) continue;
-        call_proc->result_fields_.emplace_back(result_name);
-        call_proc->result_identifiers_.push_back(storage_->Create<Identifier>(std::string(result_name)));
-      }
-      // When we leave the scope, we will release the lock on modules. This means
-      // that someone may reload the procedure and change its result signature. We
-      // are fine with this, because if new result fields were added then we yield
-      // the subset of those and that will appear to a user as if they used the
-      // procedure before reload. Any subsequent `CALL ... YIELD *` will fetch the
-      // new fields as well. In case the result signature has had some result
-      // fields removed, then the query execution will report an error that we are
-      // yielding missing fields. The user can then just retry the query.
+    const auto &[module, proc] = *maybe_found;
+    call_proc->result_fields_.reserve(proc->results.size());
+    call_proc->result_identifiers_.reserve(proc->results.size());
+    for (const auto &[result_name, desc] : proc->results) {
+      bool is_deprecated = desc.second;
+      if (is_deprecated) continue;
+      call_proc->result_fields_.emplace_back(result_name);
+      call_proc->result_identifiers_.push_back(storage_->Create<Identifier>(std::string(result_name)));
    }
+    // When we leave the scope, we will release the lock on modules. This means
+    // that someone may reload the procedure and change its result signature. We
+    // are fine with this, because if new result fields were added then we yield
+    // the subset of those and that will appear to a user as if they used the
+    // procedure before reload. Any subsequent `CALL ... YIELD *` will fetch the
+    // new fields as well. In case the result signature has had some result
+    // fields removed, then the query execution will report an error that we are
+    // yielding missing fields. The user can then just retry the query.
  }

  return call_proc;
@@ -1825,15 +1786,7 @@ antlrcpp::Any CypherMainVisitor::visitNodePattern(MemgraphCypher::NodePatternCon
 antlrcpp::Any CypherMainVisitor::visitNodeLabels(MemgraphCypher::NodeLabelsContext *ctx) {
  std::vector<LabelIx> labels;
  for (auto *node_label : ctx->nodeLabel()) {
-    if (node_label->labelName()->symbolicName()) {
-      labels.emplace_back(AddLabel(std::any_cast<std::string>(node_label->accept(this))));
-    } else {
-      // If we have a parameter, we have to resolve it.
-      const auto *param_lookup = std::any_cast<ParameterLookup *>(node_label->accept(this));
-      const auto label_name = parameters_->AtTokenPosition(param_lookup->token_position_).ValueString();
-      labels.emplace_back(storage_->GetLabelIx(label_name));
-      query_info_.is_cacheable = false;  // We can't cache queries with label parameters.
-    }
+    labels.push_back(AddLabel(std::any_cast<std::string>(node_label->accept(this))));
  }
  return labels;
 }
@@ -1969,18 +1922,6 @@ antlrcpp::Any CypherMainVisitor::visitPatternElement(MemgraphCypher::PatternElem
  return pattern;
 }

-antlrcpp::Any CypherMainVisitor::visitRelationshipsPattern(MemgraphCypher::RelationshipsPatternContext *ctx) {
-  auto *pattern = storage_->Create<Pattern>();
-  pattern->atoms_.push_back(std::any_cast<NodeAtom *>(ctx->nodePattern()->accept(this)));
-  for (auto *pattern_element_chain : ctx->patternElementChain()) {
-    auto element = std::any_cast<std::pair<PatternAtom *, PatternAtom *>>(pattern_element_chain->accept(this));
-    pattern->atoms_.push_back(element.first);
-    pattern->atoms_.push_back(element.second);
-  }
-  anonymous_identifiers.push_back(&pattern->identifier_);
-  return pattern;
-}
-
 antlrcpp::Any CypherMainVisitor::visitPatternElementChain(MemgraphCypher::PatternElementChainContext *ctx) {
  return std::pair<PatternAtom *, PatternAtom *>(std::any_cast<EdgeAtom *>(ctx->relationshipPattern()->accept(this)),
                                                 std::any_cast<NodeAtom *>(ctx->nodePattern()->accept(this)));
@@ -2037,15 +1978,6 @@ antlrcpp::Any CypherMainVisitor::visitRelationshipPattern(MemgraphCypher::Relati
      edge_lambda.inner_edge = storage_->Create<Identifier>(traversed_edge_variable);
      auto traversed_node_variable = std::any_cast<std::string>(lambda->traversed_node->accept(this));
      edge_lambda.inner_node = storage_->Create<Identifier>(traversed_node_variable);
-      if (lambda->accumulated_path) {
-        auto accumulated_path_variable = std::any_cast<std::string>(lambda->accumulated_path->accept(this));
-        edge_lambda.accumulated_path = storage_->Create<Identifier>(accumulated_path_variable);
-
-        if (lambda->accumulated_weight) {
-          auto accumulated_weight_variable = std::any_cast<std::string>(lambda->accumulated_weight->accept(this));
-          edge_lambda.accumulated_weight = storage_->Create<Identifier>(accumulated_weight_variable);
-        }
-      }
      edge_lambda.expression = std::any_cast<Expression *>(lambda->expression()->accept(this));
      return edge_lambda;
    };
@@ -2070,15 +2002,6 @@ antlrcpp::Any CypherMainVisitor::visitRelationshipPattern(MemgraphCypher::Relati
        // In variable expansion inner variables are mandatory.
        anonymous_identifiers.push_back(&edge->filter_lambda_.inner_edge);
        anonymous_identifiers.push_back(&edge->filter_lambda_.inner_node);
-
-        // TODO: In what use case do we need accumulated path and weight here?
-        if (edge->filter_lambda_.accumulated_path) {
-          anonymous_identifiers.push_back(&edge->filter_lambda_.accumulated_path);
-
-          if (edge->filter_lambda_.accumulated_weight) {
-            anonymous_identifiers.push_back(&edge->filter_lambda_.accumulated_weight);
-          }
-        }
        break;
      case 1:
        if (edge->type_ == EdgeAtom::Type::WEIGHTED_SHORTEST_PATH ||
@@ -2090,21 +2013,9 @@ antlrcpp::Any CypherMainVisitor::visitRelationshipPattern(MemgraphCypher::Relati
          // Add mandatory inner variables for filter lambda.
          anonymous_identifiers.push_back(&edge->filter_lambda_.inner_edge);
          anonymous_identifiers.push_back(&edge->filter_lambda_.inner_node);
-          if (edge->filter_lambda_.accumulated_path) {
-            anonymous_identifiers.push_back(&edge->filter_lambda_.accumulated_path);
-
-            if (edge->filter_lambda_.accumulated_weight) {
-              anonymous_identifiers.push_back(&edge->filter_lambda_.accumulated_weight);
-            }
-          }
        } else {
          // Other variable expands only have the filter lambda.
          edge->filter_lambda_ = visit_lambda(relationshipLambdas[0]);
-          if (edge->filter_lambda_.accumulated_weight) {
-            throw SemanticException(
-                "Accumulated weight in filter lambda can be used only with "
-                "shortest paths expansion.");
-          }
        }
        break;
      case 2:
@@ -2475,8 +2386,6 @@ antlrcpp::Any CypherMainVisitor::visitAtom(MemgraphCypher::AtomContext *ctx) {
    return static_cast<Expression *>(storage_->Create<Extract>(ident, list, expr));
  } else if (ctx->existsExpression()) {
    return std::any_cast<Expression *>(ctx->existsExpression()->accept(this));
-  } else if (ctx->patternComprehension()) {
-    return std::any_cast<Expression *>(ctx->patternComprehension()->accept(this));
  }

  // TODO: Implement this. We don't support comprehensions, filtering... at
@@ -2537,19 +2446,6 @@ antlrcpp::Any CypherMainVisitor::visitExistsExpression(MemgraphCypher::ExistsExp
  return static_cast<Expression *>(exists);
 }

-antlrcpp::Any CypherMainVisitor::visitPatternComprehension(MemgraphCypher::PatternComprehensionContext *ctx) {
-  auto *comprehension = storage_->Create<PatternComprehension>();
-  if (ctx->variable()) {
-    comprehension->variable_ = storage_->Create<Identifier>(std::any_cast<std::string>(ctx->variable()->accept(this)));
-  }
-  comprehension->pattern_ = std::any_cast<Pattern *>(ctx->relationshipsPattern()->accept(this));
-  if (ctx->where()) {
-    comprehension->filter_ = std::any_cast<Where *>(ctx->where()->accept(this));
-  }
-  comprehension->resultExpr_ = std::any_cast<Expression *>(ctx->expression()->accept(this));
-  return static_cast<Expression *>(comprehension);
-}
-
 antlrcpp::Any CypherMainVisitor::visitParenthesizedExpression(MemgraphCypher::ParenthesizedExpressionContext *ctx) {
  return std::any_cast<Expression *>(ctx->expression()->accept(this));
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Antonio Filipovic	c77d84ef6d	Merge branch 'master' into add-gc-for-query-memory-tracker	2023-11-22 10:11:07 +01:00
antoniofilipovic	186be4c213	link mg-memory	2023-11-14 16:19:41 +01:00
antoniofilipovic	4e06e769f1	revert back on isTransactionTracked	2023-11-14 15:57:46 +01:00
antoniofilipovic	311c129bfc	clear only under main lock	2023-11-14 15:47:33 +01:00
antoniofilipovic	fe577aab18	resolve conflict	2023-11-14 15:14:58 +01:00
antoniofilipovic	9a3ce1ef01	add gc for query memory tracker	2023-11-06 16:45:00 +01:00