Add dot

The fields of ROUTE message were not read from the input buffer, thus the
input buffer got corrupted. Sending a new message to the server would result
reading the remaining fields from the buffer, which means reading some values
instead of message signature. Because of this unmet expectation, Memgraph closed
the connection. With this fix, the fields of the ROUTE message are properly
read and ignored.

.clang-tidy

@@ -61,7 +61,9 @@ Checks: '*,
          -readability-magic-numbers,
          -readability-named-parameter,
          -misc-no-recursion,
-         -concurrency-mt-unsafe'
+         -concurrency-mt-unsafe,
+         -bugprone-easily-swappable-parameters'
+
 WarningsAsErrors: ''
 HeaderFilterRegex: 'src/.*'
 AnalyzeTemporaryDtors: false

.github/pull_request_template.md

@@ -3,7 +3,9 @@
 - [ ] Update [changelog](https://docs.memgraph.com/memgraph/changelog)
 - [ ] Write E2E tests
 - [ ] Compare the [benchmarking results](https://bench-graph.memgraph.com/) between the master branch and the Epic branch
+- [ ] Provide the full content or a guide for the final git message
 
 [master < Task] PR
 - [ ] Check, and update documentation if necessary
 - [ ] Update [changelog](https://docs.memgraph.com/memgraph/changelog)
+- [ ] Provide the full content or a guide for the final git message

.github/workflows/diff.yaml

@@ -1,4 +1,7 @@
 name: Diff
+concurrency:
+  group: ${{ github.head_ref || github.sha }}
+  cancel-in-progress: true
 
 on:
   push:
@@ -67,6 +70,11 @@ jobs:
           # branches and tags. (default: 1)
           fetch-depth: 0
 
+        # This is also needed if we want do to comparison against other branches
+        # See https://github.community/t/checkout-code-fails-when-it-runs-lerna-run-test-since-master/17920
+      - name: Fetch all history for all tags and branches
+        run: git fetch
+
       - name: Build combined ASAN, UBSAN and coverage binaries
         run: |
           # Activate toolchain.
@@ -107,12 +115,22 @@ jobs:
           name: "Code coverage"
           path: tools/github/generated/code_coverage.tar.gz
 
+      - name: Set base branch
+        if: ${{ github.event_name == 'pull_request' }}
+        run: |
+          echo "BASE_BRANCH=origin/${{ github.base_ref }}" >> $GITHUB_ENV
+
+      - name: Set base branch # if we manually dispatch or push to master
+        if: ${{ github.event_name != 'pull_request' }}
+        run: |
+          echo "BASE_BRANCH=origin/master" >> $GITHUB_ENV
+
       - name: Run clang-tidy
         run: |
           source /opt/toolchain-v4/activate
 
           # Restrict clang-tidy results only to the modified parts
-          git diff -U0 master... -- src | ./tools/github/clang-tidy/clang-tidy-diff.py -p 1 -j $THREADS -path build | tee ./build/clang_tidy_output.txt
+          git diff -U0 ${{ env.BASE_BRANCH }}... -- src | ./tools/github/clang-tidy/clang-tidy-diff.py -p 1 -j $THREADS -path build | tee ./build/clang_tidy_output.txt
 
           # Fail if any warning is reported
           ! cat ./build/clang_tidy_output.txt | ./tools/github/clang-tidy/grep_error_lines.sh > /dev/null

.github/workflows/package_all.yaml

@@ -6,11 +6,11 @@ on: workflow_dispatch
 
 jobs:
   centos-7:
-    runs-on: [self-hosted, DockerMgBuild]
+    runs-on: [self-hosted, DockerMgBuild, X64]
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
@@ -22,29 +22,29 @@ jobs:
           name: centos-7
           path: build/output/centos-7/memgraph*.rpm
 
-  centos-8:
-    runs-on: [self-hosted, DockerMgBuild]
+  centos-9:
+    runs-on: [self-hosted, DockerMgBuild, X64]
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v2
+        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-8
+          ./release/package/run.sh package centos-9
       - name: "Upload package"
         uses: actions/upload-artifact@v2
         with:
-          name: centos-8
-          path: build/output/centos-8/memgraph*.rpm
+          name: centos-9
+          path: build/output/centos-9/memgraph*.rpm
 
   debian-10:
-    runs-on: [self-hosted, DockerMgBuild]
+    runs-on: [self-hosted, DockerMgBuild, X64]
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
@@ -57,11 +57,11 @@ jobs:
           path: build/output/debian-10/memgraph*.deb
 
   debian-11:
-    runs-on: [self-hosted, DockerMgBuild]
+    runs-on: [self-hosted, DockerMgBuild, X64]
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
@@ -74,11 +74,11 @@ jobs:
           path: build/output/debian-11/memgraph*.deb
 
   docker:
-    runs-on: [self-hosted, DockerMgBuild]
+    runs-on: [self-hosted, DockerMgBuild, X64]
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
@@ -93,11 +93,11 @@ jobs:
           path: build/output/docker/memgraph*.tar.gz
 
   ubuntu-1804:
-    runs-on: [self-hosted, DockerMgBuild]
+    runs-on: [self-hosted, DockerMgBuild, X64]
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
@@ -110,11 +110,11 @@ jobs:
           path: build/output/ubuntu-18.04/memgraph*.deb
 
   ubuntu-2004:
-    runs-on: [self-hosted, DockerMgBuild]
+    runs-on: [self-hosted, DockerMgBuild, X64]
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0 # Required because of release/get_version.py
       - name: "Build package"
@@ -126,12 +126,29 @@ jobs:
           name: ubuntu-2004
           path: build/output/ubuntu-20.04/memgraph*.deb
 
-  debian-11-platform:
-    runs-on: [self-hosted, DockerMgBuild]
+  ubuntu-2204:
+    runs-on: [self-hosted, DockerMgBuild, X64]
     timeout-minutes: 60
     steps:
       - name: "Set up repository"
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # Required because of release/get_version.py
+      - name: "Build package"
+        run: |
+          ./release/package/run.sh package ubuntu-22.04
+      - name: "Upload package"
+        uses: actions/upload-artifact@v2
+        with:
+          name: ubuntu-2204
+          path: build/output/ubuntu-22.04/memgraph*.deb
+
+  debian-11-platform:
+    runs-on: [self-hosted, DockerMgBuild, X64]
+    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"
@@ -142,3 +159,20 @@ jobs:
         with:
           name: debian-11-platform
           path: build/output/debian-11/memgraph*.deb
+
+  debian-11-arm:
+    runs-on: [self-hosted, DockerMgBuild, ARM64, strange]
+    timeout-minutes: 60
+    steps:
+      - name: "Set up repository"
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0 # Required because of release/get_version.py
+      - name: "Build package"
+        run: |
+          ./release/package/run.sh package debian-11-arm
+      - name: "Upload package"
+        uses: actions/upload-artifact@v2
+        with:
+          name: debian-11-arm
+          path: build/output/debian-11-arm/memgraph*.deb

.github/workflows/release_docker.yaml

@@ -4,8 +4,12 @@ on:
   workflow_dispatch:
     inputs:
       version:
-        description: "Memgraph binary version to publish on Dockerhub."
+        description: "Memgraph binary version to publish on DockerHub."
         required: true
+      force_release:
+        type: boolean
+        required: false
+        default: false
 
 jobs:
   docker_publish:
@@ -36,6 +40,22 @@ jobs:
           curl -L https://download.memgraph.com/memgraph/v${{ github.event.inputs.version }}/debian-11/memgraph_${{ github.event.inputs.version }}-1_amd64.deb > memgraph-amd64.deb
           curl -L https://download.memgraph.com/memgraph/v${{ github.event.inputs.version }}/debian-11-aarch64/memgraph_${{ github.event.inputs.version }}-1_arm64.deb > memgraph-arm64.deb
 
+      - name: Check if specified version is already pushed
+        run: |
+          EXISTS=$(docker manifest inspect $DOCKER_ORGANIZATION_NAME/$DOCKER_REPOSITORY_NAME:${{ github.event.inputs.version }} > /dev/null; echo $?)
+          echo $EXISTS
+          if [[ ${EXISTS} -eq 0 ]]; then
+              echo 'The specified version has been already released to DockerHub.'
+              if [[ ${{ github.event.inputs.force_release }} = true ]]; then
+                echo 'Forcing the release!'
+              else
+                echo 'Stopping the release!'
+                exit 1
+              fi
+          else
+              echo 'All good the specified version has not been release to DockerHub.'
+          fi
+
       - name: Build & push docker images
         run: |
           cd release/docker

CODEOWNERS

@@ -1 +0,0 @@
-* @antaljanosbenjamin @kostasrim

docs/csv-import-tool/README.md

@@ -0,0 +1,204 @@
+# CSV Import Tool Documentation
+
+CSV is a universal and very versatile data format used to store large quantities
+of data.  Each Memgraph database instance has a CSV import tool installed called
+`mg_import_csv`.  The CSV import tool should be used for initial bulk ingestion
+of data into the database.  Upon ingestion, the CSV importer creates a snapshot
+that will be used by the database to recover its state on its next startup.
+
+If you are already familiar with the Neo4j bulk import tool, then using the
+`mg_import_csv` tool should be easy.  The CSV import tool is fully compatible
+with the [Neo4j CSV
+format](https://neo4j.com/docs/operations-manual/current/tools/import/). If you
+already have a pipeline set-up for Neo4j, you should only replace `neo4j-admin
+import` with `mg_import_csv`.
+
+## CSV File Format
+
+Each row of a CSV file represents a single entry that should be imported into
+the database.  Both nodes and relationships can be imported into the database
+using CSV files.
+
+Each set of CSV files must have a header that describes the data that is stored
+in the CSV files. Each field in the CSV header is in the format
+`<name>[:<type>]` which identifies the name that should be used for that column
+and the type that should be used for that column. The type is optional and
+defaults to `string` (see the following chapter).
+
+Each CSV field must be divided using the delimiter and each CSV field can either
+be quoted or unquoted. When the field is quoted, the first and last character in
+the field *must* be the quote character. If the field isn't quoted, and a quote
+character appears in it, it is treated as a regular character. If a quote
+character appears inside a quoted string then the quote character must be
+doubled in order to escape it. Line feeds and carriage returns are ignored in
+the CSV file, also, the file can't contain a NULL character.
+
+## Properties
+
+Both nodes and relationships can have properties added to them.  When importing
+properties, the CSV importer uses the name specified in the header of the
+corresponding CSV column for the name of the property.  A property is designated
+by specifying one of the following types in the header:
+ - `integer`, `int`, `long`, `byte`, `short`: creates an integer property
+ - `float`, `double`: creates a float property
+ - `boolean`, `bool`: creates a boolean property
+ - `string`, `char`: creates a string property
+
+When importing a boolean value, the CSV field should contain exactly the text
+`true` to import a `True` boolean value.  All other text values are treated as a
+boolean value `False`.
+
+If you want to import an array of values, you can do so by appending `[]` to any
+of the above types.  The values of the array are then determined by splitting
+the raw CSV value using the array delimiter character.
+
+Assuming that the array delimiter is `;`, the following example:
+```plaintext
+first_name,last_name:string,number:integer,aliases:string[]
+John,Doe,1,Johnny;Jo;J-man
+Melissa,Doe,2,Mel
+```
+
+Will yield these results:
+```plaintext
+CREATE ({first_name: "John", last_name: "Doe", number: 1, aliases: ["Johnny", "Jo", "J-man"]});
+CREATE ({first_name: "Melissa", last_name: "Doe", number: 2, aliases: ["Mel"]});
+```
+### Nodes
+
+When importing nodes, several more types can be specified in the header of the
+CSV file (along with all property types):
+ - `ID`: id of the node that should be used as the node ID when importing
+   relationships
+ - `LABEL`: designates that the field contains additional labels for the node
+ - `IGNORE`: designates that the field should be ignored
+
+The `ID` field type sets the internal ID that will be used for the node when
+creating relationships.  It is optional and nodes that don't have an ID value
+specified will be imported, but can't be connected to any relationships.  If you
+want to save the ID value as a property in the database, just specify a name for
+the ID (`user_id:ID`).  If you just want to use the ID during the import, leave
+out the name of the field (`:ID`).  The `ID` field also supports creating
+separate ID spaces.  The ID space is specified with the ID space name appended
+to the `ID` type in parentheses (`ID(user)`).  That allows you to have the same
+IDs (by value) for multiple different node files (for example, numbers from 1 to
+N).  The IDs in each ID space will be treated as an independent set of IDs that
+don't interfere with IDs in another ID space.
+
+The `LABEL` field type adds additional labels to the node.  The value is treated
+as an array type so that multiple additional labels can be specified for each
+node.  The value is split using the array delimiter (`--array-delimiter` flag).
+
+### Relationships
+
+In order to be able to import relationships, you must import the nodes in the
+same invocation of `mg_import_csv` that is used to import the relationships.
+
+When importing relationships, several more types can be specified in the header
+of the CSV file (along with all property types):
+ - `START_ID`: id of the start node that should be connected with the
+   relationship
+ - `END_ID`: id of the end node that should be connected with the relationship
+ - `TYPE`: designates the type of the relationship
+ - `IGNORE`: designates that the field should be ignored
+
+The `START_ID` field type sets the start node that should be connected with the
+relationship to the end node.  The field *must* be specified and the node ID
+must be one of the node IDs that were specified in the node CSV files.  The name
+of this field is ignored.  If the node ID is in an ID space, you can specify the
+ID space for the in the same way as for the node ID (`START_ID(user)`).
+
+The `END_ID` field type sets the end node that should be connected with the
+relationship to the start node.  The field *must* be specified and the node ID
+must be one of the node IDs that were specified in the node CSV files.  The name
+of this field is ignored.  If the node ID is in an ID space, you can specify the
+ID space for the in the same way as for the node ID (`END_ID(user)`).
+
+The `TYPE` field type sets the type of the relationship.  Each relationship
+*must* have a relationship type, but it doesn't necessarily need to be specified
+in the CSV file, it can also be set externally for the whole CSV file.  The name
+of this field is ignored.
+
+## CSV Importer Flags
+
+The importer has many command line options that allow you to customize the way
+the importer loads your data.
+
+The two main flags that are used to specify the input CSV files are `--nodes`
+and `--relationships`. Basic description of these flags is provided in the table
+and more detailed explainion can be found further down bellow.
+
+
+| Flag                  | Description  |
+|-----------------------| -------------- |
+|`--nodes`                | Used to specify CSV files that contain the nodes to the importer. |
+|`--relationships`        |  Used to specify CSV files that contain the relationships to the importer.|
+|`--delimiter`            | Sets the delimiter that should be used when splitting the CSV fields (default `,`)|
+|`--quote`                | Sets the quote character that should be used to quote a CSV field (default `"`)|
+|`--array-delimiter`      | Sets the delimiter that should be used when splitting array values (default `;`)|
+|`--id-type`              | Specifies which data type should be used to store the supplied <br /> node IDs when storing them as properties (if the field name is supplied). <br /> The supported values are either `STRING` or `INTEGER`. (default `STRING`)|
+|`--ignore-empty-strings` | Instructs the importer to treat all empty strings as `Null` values  <br /> instead of an empty string value (default `false`)|
+|`--ignore-extra-columns` | Instructs the importer to ignore all columns (instead of raising an error) <br /> that aren't specified after the last specified column in the CSV header. (default `false`) |
+| `--skip-bad-relationships`| Instructs the importer to ignore all relationships (instead of raising an error) <br /> that refer to nodes that don't exist in the node files. (default `false`) |
+|`--skip-duplicate-nodes`  | Instructs the importer to ignore all duplicate nodes (instead of raising an error).  <br /> Duplicate nodes are nodes that have an ID that is the same as another node that was already imported. (default `false`) |
+| `--trim-strings`| Instructs the importer to trim all of the loaded CSV field values before processing them further. <br /> Trimming the fields removes all leading and trailing whitespace from them. (default `false`) |
+
+The `--nodes` and  `--relationships` flags are used to specify CSV files that
+contain the nodes and relationships to the importer.  Multiple files can be
+specified in each supplied `--nodes` or `--relationships` flag. Files that are
+supplied in one `--nodes` or `--relationships` flag are treated by the CSV
+parser as one big CSV file.  Only the first line of the first file is parsed for
+the CSV header, all other files (and rows) are treated as data.  This is useful
+when you have a very large CSV file and don't want to edit its first line just
+to add a CSV header.  Instead, you can specify the header in a separate file
+(e.g. `users_header.csv` or `friendships_header.csv`) and have the data intact
+in the large file (e.g. `users.csv` or `friendships.csv`).  Also, you can supply
+additional labels for each set of node files.
+
+The format of `--nodes` flag is:
+`[<label>[:<label>]...=]<file>[,<file>][,<file>]...`.  Take note that only the
+first `<file>` part is mandatory, all other parts of the flag value are
+optional. Multiple `--nodes` flags can be supplied to describe multiple sets of
+different node files.  For the importer to work, at least one `--nodes` flag
+*must* be supplied.
+
+The format of `--relationships` flag is: `[<type>=]<file>[,<file>][,<file>]...`.
+Take note that only the first `<file>` part is mandatory, all other parts of the
+flag value are optional.  Multiple `--relationships` flags can be supplied to
+describe multiple sets of different relationship files.  The `--relationships`
+flag isn't mandatory.
+
+## CSV Parser Logic
+
+The CSV parser uses the same logic as the standard Python CSV parser.  The data
+is parsed in the same way as the following snippet:
+
+```python
+import csv
+for row in csv.reader(stream, strict=True):
+    # process 'row'
+```
+
+Python uses 'excel' as the default dialect when parsing CSV files and the
+default settings for the CSV parser are:
+ - delimiter: `','`
+ - doublequote: `True`
+ - escapechar: `None`
+ - lineterminator: `'\r\n'`
+ - quotechar: `'"'`
+ - skipinitialspace: `False`
+
+The above snippet can be expanded to:
+
+```python
+import csv
+for row in csv.reader(stream, delimiter=',', doublequote=True,
+                      escapechar=None, lineterminator='\r\n',
+                      quotechar='"', skipinitialspace=False,
+                      strict=True):
+    # process 'row'
+```
+
+For more information about the meaning of the above values, see:
+https://docs.python.org/3/library/csv.html#csv.Dialect
+

environment/os/centos-7.sh

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

environment/os/centos-8.sh

@@ -1,161 +0,0 @@
-#!/bin/bash
-
-set -Eeuo pipefail
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-source "$DIR/../util.sh"
-
-TOOLCHAIN_BUILD_DEPS=(
-    coreutils-common gcc gcc-c++ make # generic build tools
-    wget # used for archive download
-    gnupg2 # used for archive signature verification
-    tar gzip bzip2 xz unzip # used for archive unpacking
-    zlib-devel # zlib library used for all builds
-    expat-devel libipt libipt-devel libbabeltrace-devel xz-devel python36-devel texinfo # for gdb
-    libcurl-devel # for cmake
-    curl # snappy
-    readline-devel # for cmake and llvm
-    libffi-devel libxml2-devel # for llvm
-    libedit-devel pcre-devel automake bison # for swig
-    file
-    openssl-devel
-    gmp-devel
-    gperf
-    patch
-)
-
-TOOLCHAIN_RUN_DEPS=(
-    make # generic build tools
-    tar gzip bzip2 xz # used for archive unpacking
-    zlib # zlib library used for all builds
-    expat libipt libbabeltrace xz-libs python36 # for gdb
-    readline # for cmake and llvm
-    libffi libxml2 # for llvm
-    openssl-devel
-)
-
-MEMGRAPH_BUILD_DEPS=(
-    git # source code control
-    make pkgconf-pkg-config # build system
-    curl wget # for downloading libs
-    libuuid-devel java-11-openjdk # required by antlr
-    readline-devel # for memgraph console
-    python36-devel # for query modules
-    openssl-devel
-    libseccomp-devel
-    python36 python3-virtualenv python3-pip nmap-ncat # for qa, macro_benchmark and stress tests
-    #
-    # IMPORTANT: python3-yaml does NOT exist on CentOS
-    # Install it manually using `pip3 install PyYAML`
-    #
-    PyYAML # Package name here does not correspond to the yum package!
-    libcurl-devel # mg-requests
-    rpm-build rpmlint # for RPM package building
-    doxygen graphviz # source documentation generators
-    which mono-complete dotnet-sdk-3.1 nodejs golang zip unzip java-11-openjdk-devel # for driver tests
-    sbcl # for custom Lisp C++ preprocessing
-    autoconf # for jemalloc code generation
-    libtool  # for protobuf code generation
-)
-
-list() {
-    echo "$1"
-}
-
-check() {
-    local missing=""
-    for pkg in $1; do
-        if [ "$pkg" == "PyYAML" ]; then
-            if ! python3 -c "import yaml" >/dev/null 2>/dev/null; then
-                missing="$pkg $missing"
-            fi
-            continue
-        fi
-        if ! yum list installed "$pkg" >/dev/null 2>/dev/null; then
-            missing="$pkg $missing"
-        fi
-    done
-    if [ "$missing" != "" ]; then
-        echo "MISSING PACKAGES: $missing"
-        exit 1
-    fi
-}
-
-install() {
-    cd "$DIR"
-    if [ "$EUID" -ne 0 ]; then
-        echo "Please run as root."
-        exit 1
-    fi
-    # If GitHub Actions runner is installed, append LANG to the environment.
-    # Python related tests doesn't work the LANG export.
-    if [ -d "/home/gh/actions-runner" ]; then
-        echo "LANG=en_US.utf8" >> /home/gh/actions-runner/.env
-    else
-        echo "NOTE: export LANG=en_US.utf8"
-    fi
-    dnf install -y epel-release
-    dnf install -y 'dnf-command(config-manager)'
-    dnf config-manager --set-enabled powertools # Required to install texinfo.
-    dnf update -y
-    dnf install -y wget git python36 python3-pip
-    for pkg in $1; do
-        if [ "$pkg" == libipt ]; then
-            if ! dnf list installed libipt >/dev/null 2>/dev/null; then
-                dnf install -y http://repo.okay.com.mx/centos/8/x86_64/release/libipt-1.6.1-8.el8.x86_64.rpm
-            fi
-            continue
-        fi
-        if [ "$pkg" == libipt-devel ]; then
-            if ! yum list installed libipt-devel >/dev/null 2>/dev/null; then
-                dnf install -y http://repo.okay.com.mx/centos/8/x86_64/release/libipt-devel-1.6.1-8.el8.x86_64.rpm
-            fi
-            continue
-        fi
-        # Install GDB dependencies not present in the standard repos.
-        # https://bugs.centos.org/view.php?id=17068
-        # https://centos.pkgs.org
-	    # Since 2020, there is Babeltrace2 (https://babeltrace.org). Not used
-        # within GDB yet (an assumption).
-        # http://mirror.centos.org/centos/8/PowerTools/x86_64/os/Packages/libbabeltrace-devel-1.5.4-3.el8.x86_64.rpm not working
-        if [ "$pkg" == libbabeltrace-devel ]; then
-            if ! dnf list installed libbabeltrace-devel >/dev/null 2>/dev/null; then
-                dnf install -y https://rpmfind.net/linux/centos/8-stream/PowerTools/x86_64/os/Packages/libbabeltrace-devel-1.5.4-3.el8.x86_64.rpm
-            fi
-            continue
-        fi
-        if [ "$pkg" == sbcl ]; then
-            if ! dnf list installed cl-asdf >/dev/null 2>/dev/null; then
-                dnf install -y 	https://pkgs.dyn.su/el8/base/x86_64/cl-asdf-20101028-18.el8.noarch.rpm
-            fi
-            if ! dnf list installed common-lisp-controller >/dev/null 2>/dev/null; then
-                dnf install -y https://pkgs.dyn.su/el8/base/x86_64/common-lisp-controller-7.4-20.el8.noarch.rpm
-            fi
-            if ! dnf list installed sbcl >/dev/null 2>/dev/null; then
-                dnf install -y https://pkgs.dyn.su/el8/base/x86_64/sbcl-2.0.1-4.el8.x86_64.rpm
-            fi
-            continue
-        fi
-        if [ "$pkg" == dotnet-sdk-3.1 ]; then
-            if ! dnf list installed dotnet-sdk-3.1 >/dev/null 2>/dev/null; then
-                wget -nv https://packages.microsoft.com/config/centos/8/packages-microsoft-prod.rpm -O packages-microsoft-prod.rpm
-                rpm -Uvh https://packages.microsoft.com/config/centos/8/packages-microsoft-prod.rpm
-                dnf update -y
-                dnf install -y dotnet-sdk-3.1
-            fi
-            continue
-        fi
-        if [ "$pkg" == PyYAML ]; then
-            if [ -z ${SUDO_USER+x} ]; then # Running as root (e.g. Docker).
-                pip3 install --user PyYAML
-            else # Running using sudo.
-                sudo -H -u "$SUDO_USER" bash -c "pip3 install --user PyYAML"
-            fi
-            continue
-        fi
-        dnf install -y "$pkg"
-    done
-}
-
-deps=$2"[*]"
-"$1" "${!deps}"

environment/os/centos-9.sh

@@ -5,15 +5,16 @@ set -Eeuo pipefail
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 source "$DIR/../util.sh"
 
+check_operating_system "centos-9"
+check_architecture "x86_64"
+
 TOOLCHAIN_BUILD_DEPS=(
-    coreutils gcc gcc-c++ make # generic build tools
+    coreutils-common gcc gcc-c++ make # generic build tools
     wget # used for archive download
     gnupg2 # used for archive signature verification
     tar gzip bzip2 xz unzip # used for archive unpacking
     zlib-devel # zlib library used for all builds
-    expat-devel xz-devel python3-devel texinfo # for gdb
-    libcurl-devel # for cmake
-    curl # snappy
+    expat-devel xz-devel python3-devel texinfo libbabeltrace-devel # for gdb
     readline-devel # for cmake and llvm
     libffi-devel libxml2-devel # for llvm
     libedit-devel pcre-devel automake bison # for swig
@@ -21,6 +22,9 @@ TOOLCHAIN_BUILD_DEPS=(
     openssl-devel
     gmp-devel
     gperf
+    diffutils
+    libipt libipt-devel # intel
+    patch
 )
 
 TOOLCHAIN_RUN_DEPS=(
@@ -31,18 +35,19 @@ TOOLCHAIN_RUN_DEPS=(
     readline # for cmake and llvm
     libffi libxml2 # for llvm
     openssl-devel
+    perl # for openssl
 )
 
 MEMGRAPH_BUILD_DEPS=(
     git # source code control
     make pkgconf-pkg-config # build system
-    curl wget # for downloading libs
+    wget # for downloading libs
     libuuid-devel java-11-openjdk # required by antlr
     readline-devel # for memgraph console
     python3-devel # for query modules
     openssl-devel
     libseccomp-devel
-    python3 python3-virtualenv python3-pip nmap-ncat # for qa, macro_benchmark and stress tests
+    python3 python3-pip python3-virtualenv nmap-ncat # for qa, macro_benchmark and stress tests
     #
     # IMPORTANT: python3-yaml does NOT exist on CentOS
     # Install it manually using `pip3 install PyYAML`
@@ -73,12 +78,6 @@ check() {
         if [ "$pkg" == "python3-virtualenv" ]; then
             continue
         fi
-        if [ "$pkg" == sbcl ]; then
-            if ! sbcl --version &> /dev/null; then
-	        missing="$pkg $missing"
-            fi
-            continue
-        fi
         if ! yum list installed "$pkg" >/dev/null 2>/dev/null; then
             missing="$pkg $missing"
         fi
@@ -105,13 +104,37 @@ install() {
     yum update -y
     yum install -y wget git python3 python3-pip
     for pkg in $1; do
+        # Since there is no support for libipt-devel for CentOS 9 we install
+        # Fedoras version of same libs, they are the same version but released
+        # for different OS
+        # TODO Update when libipt-devel releases for CentOS 9
+        if [ "$pkg" == libipt ]; then
+            if ! dnf list installed libipt >/dev/null 2>/dev/null; then
+                dnf install -y http://repo.okay.com.mx/centos/8/x86_64/release/libipt-1.6.1-8.el8.x86_64.rpm
+            fi
+            continue
+        fi
+        if [ "$pkg" == libipt-devel ]; then
+            if ! dnf list installed libipt-devel >/dev/null 2>/dev/null; then
+                dnf install -y http://repo.okay.com.mx/centos/8/x86_64/release/libipt-devel-1.6.1-8.el8.x86_64.rpm
+            fi
+            continue
+        fi
+        if [ "$pkg" == libbabeltrace-devel ]; then
+            if ! dnf list installed libbabeltrace-devel >/dev/null 2>/dev/null; then
+                dnf install -y http://mirror.stream.centos.org/9-stream/CRB/x86_64/os/Packages/libbabeltrace-devel-1.5.8-10.el9.x86_64.rpm
+            fi
+            continue
+        fi
         if [ "$pkg" == sbcl ]; then
-            if ! sbcl --version &> /dev/null; then
-	        curl -s https://altushost-swe.dl.sourceforge.net/project/sbcl/sbcl/1.4.2/sbcl-1.4.2-arm64-linux-binary.tar.bz2 -o /tmp/sbcl-arm64.tar.bz2
-		tar xvjf /tmp/sbcl-arm64.tar.bz2 -C /tmp
-		pushd /tmp/sbcl-1.4.2-arm64-linux
-		INSTALL_ROOT=/usr/local sh install.sh
-		popd
+            if ! dnf list installed cl-asdf >/dev/null 2>/dev/null; then
+                dnf install -y 	https://pkgs.dyn.su/el8/base/x86_64/cl-asdf-20101028-18.el8.noarch.rpm
+            fi
+            if ! dnf list installed common-lisp-controller >/dev/null 2>/dev/null; then
+                dnf install -y https://pkgs.dyn.su/el8/base/x86_64/common-lisp-controller-7.4-20.el8.noarch.rpm
+            fi
+            if ! dnf list installed sbcl >/dev/null 2>/dev/null; then
+                dnf install -y https://pkgs.dyn.su/el8/base/x86_64/sbcl-2.0.1-4.el8.x86_64.rpm
             fi
             continue
         fi
@@ -125,9 +148,11 @@ install() {
         fi
         if [ "$pkg" == python3-virtualenv ]; then
             if [ -z ${SUDO_USER+x} ]; then # Running as root (e.g. Docker).
-                pip3 install --user virtualenv
+                pip3 install virtualenv
+                pip3 install virtualenvwrapper
             else # Running using sudo.
-                sudo -H -u "$SUDO_USER" bash -c "pip3 install --user virtualenv"
+                sudo -H -u "$SUDO_USER" bash -c "pip3 install virtualenv"
+                sudo -H -u "$SUDO_USER" bash -c "pip3 install virtualenvwrapper"
             fi
             continue
         fi

environment/os/debian-10.sh

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

environment/os/debian-11-arm.sh

@@ -5,6 +5,9 @@ set -Eeuo pipefail
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 source "$DIR/../util.sh"
 
+check_operating_system "debian-11"
+check_architecture "arm64"
+
 TOOLCHAIN_BUILD_DEPS=(
     coreutils gcc g++ build-essential make # generic build tools
     wget # used for archive download
@@ -87,15 +90,6 @@ EOF
     fi
     apt install -y wget
     for pkg in $1; do
-        if [ "$pkg" == dotnet-sdk-3.1 ]; then
-            if ! dpkg -s "$pkg" 2>/dev/null >/dev/null; then
-                wget -nv https://packages.microsoft.com/config/debian/10/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
-                dpkg -i packages-microsoft-prod.deb
-                apt-get update
-                apt-get install -y apt-transport-https dotnet-sdk-3.1
-            fi
-            continue
-        fi
         apt install -y "$pkg"
     done
 }

environment/os/debian-11.sh

@@ -5,6 +5,9 @@ set -Eeuo pipefail
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 source "$DIR/../util.sh"
 
+check_operating_system "debian-11"
+check_architecture "x86_64"
+
 TOOLCHAIN_BUILD_DEPS=(
     coreutils gcc g++ build-essential make # generic build tools
     wget # used for archive download
@@ -87,7 +90,7 @@ EOF
     fi
     apt install -y wget
     for pkg in $1; do
-        if [ "$pkg" == dotnet-sdk-3.1 ]; then
+        if [ "$pkg" == dotnet-sdk-3.1  ]; then
             if ! dpkg -s "$pkg" 2>/dev/null >/dev/null; then
                 wget -nv https://packages.microsoft.com/config/debian/10/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
                 dpkg -i packages-microsoft-prod.deb

environment/os/template.sh

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

environment/os/ubuntu-18.04.sh

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

environment/os/ubuntu-20.04.sh

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

environment/os/ubuntu-22.04.sh

@@ -0,0 +1,96 @@
+#!/bin/bash
+
+set -Eeuo pipefail
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+source "$DIR/../util.sh"
+
+check_operating_system "ubuntu-22.04"
+check_architecture "x86_64"
+
+TOOLCHAIN_BUILD_DEPS=(
+    coreutils gcc g++ build-essential make # generic build tools
+    wget # used for archive download
+    gnupg # used for archive signature verification
+    tar gzip bzip2 xz-utils unzip # used for archive unpacking
+    zlib1g-dev # zlib library used for all builds
+    libexpat1-dev libipt-dev libbabeltrace-dev liblzma-dev python3-dev texinfo # for gdb
+    libcurl4-openssl-dev # for cmake
+    libreadline-dev # for cmake and llvm
+    libffi-dev libxml2-dev # for llvm
+    curl # snappy
+    file
+    git # for thrift
+    libgmp-dev # for gdb
+    gperf # for proxygen
+    libssl-dev
+    libedit-dev libpcre3-dev automake bison # for swig
+)
+
+TOOLCHAIN_RUN_DEPS=(
+    make # generic build tools
+    tar gzip bzip2 xz-utils # used for archive unpacking
+    zlib1g # zlib library used for all builds
+    libexpat1 libipt2 libbabeltrace1 liblzma5 python3 # for gdb
+    libcurl4 # for cmake
+    libreadline8 # for cmake and llvm
+    libffi7 libxml2 # for llvm
+    libssl-dev # for libevent
+)
+
+MEMGRAPH_BUILD_DEPS=(
+    git # source code control
+    make pkg-config # build system
+    curl wget # for downloading libs
+    uuid-dev default-jre-headless # required by antlr
+    libreadline-dev # for memgraph console
+    libpython3-dev python3-dev # for query modules
+    libssl-dev
+    libseccomp-dev
+    netcat # tests are using nc to wait for memgraph
+    python3 python3-virtualenv python3-pip # for qa, macro_benchmark and stress tests
+    python3-yaml # for the configuration generator
+    libcurl4-openssl-dev # mg-requests
+    sbcl # for custom Lisp C++ preprocessing
+    doxygen graphviz # source documentation generators
+    mono-runtime mono-mcs zip unzip default-jdk-headless # for driver tests
+    dotnet-sdk-6.0 golang nodejs npm
+    autoconf # for jemalloc code generation
+    libtool  # for protobuf code generation
+)
+
+list() {
+    echo "$1"
+}
+
+check() {
+    check_all_dpkg "$1"
+}
+
+install() {
+    cd "$DIR"
+    apt update
+    # If GitHub Actions runner is installed, append LANG to the environment.
+    # Python related tests doesn't work the LANG export.
+    if [ -d "/home/gh/actions-runner" ]; then
+        echo "LANG=en_US.utf8" >> /home/gh/actions-runner/.env
+    else
+        echo "NOTE: export LANG=en_US.utf8"
+    fi
+    apt install -y wget
+    for pkg in $1; do
+        if [ "$pkg" == dotnet-sdk-6.0 ]; then
+            if ! dpkg -s dotnet-sdk-6.0 2>/dev/null >/dev/null; then
+                wget -nv https://packages.microsoft.com/config/ubuntu/22.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
+                dpkg -i packages-microsoft-prod.deb
+                apt-get update
+                apt-get install -y apt-transport-https dotnet-sdk-6.0
+            fi
+            continue
+        fi
+        apt install -y "$pkg"
+    done
+}
+
+deps=$2"[*]"
+"$1" "${!deps}"

environment/toolchain/v4.sh

@@ -675,7 +675,7 @@ PROXYGEN_SHA256=5360a8ccdfb2f5a6c7b3eed331ec7ab0e2c792d579c6fff499c85c516c11fe14
 SNAPPY_SHA256=75c1fbb3d618dd3a0483bff0e26d0a92b495bbe5059c8b4f1c962b478b6e06e7
 SNAPPY_VERSION=1.1.9
 XZ_VERSION=5.2.5 # for LZMA
-ZLIB_VERSION=1.2.11
+ZLIB_VERSION=1.2.12
 ZSTD_VERSION=1.5.0
 WANGLE_SHA256=1002e9c32b6f4837f6a760016e3b3e22f3509880ef3eaad191c80dc92655f23f
 
@@ -1178,12 +1178,21 @@ popd
 
 # create toolchain archive
 if [ ! -f $NAME-binaries-$DISTRO.tar.gz ]; then
-    DISTRO_FULL_NAME=$DISTRO
-    if [ "$for_arm" = true ]; then
-        DISTRO_FULL_NAME="$DISTRO_FULL_NAME-aarch64"
+    DISTRO_FULL_NAME=${DISTRO}
+    if [[ "${DISTRO}" == centos* ]]; then
+        if [[ "$for_arm" = "true" ]]; then
+            DISTRO_FULL_NAME="$DISTRO_FULL_NAME-aarch64"
+        else
+            DISTRO_FULL_NAME="$DISTRO_FULL_NAME-x86_64"
+        fi
     else
-        DISTRO_FULL_NAME="$DISTRO_FULL_NAME-x86_64"
+        if [[ "$for_arm" = "true" ]]; then
+            DISTRO_FULL_NAME="$DISTRO_FULL_NAME-arm64"
+        else
+            DISTRO_FULL_NAME="$DISTRO_FULL_NAME-amd64"
+        fi
     fi
+
     tar --owner=root --group=root -cpvzf $NAME-binaries-$DISTRO_FULL_NAME.tar.gz -C /opt $NAME
 fi
 

environment/util.sh

@@ -5,10 +5,28 @@ operating_system() {
     sort | cut -d '=' -f 2- | sed 's/"//g' | paste -s -d '-'
 }
 
+check_operating_system() {
+    if [ "$(operating_system)" != "$1" ]; then
+        echo "Not the right operating system!"
+        exit 1
+    else
+        echo "The right operating system."
+    fi
+}
+
 architecture() {
     uname -m
 }
 
+check_architecture() {
+    if [ "$(architecture)" != "$1" ]; then
+        echo "Not the right architecture!"
+        exit 1
+    else
+        echo "The right architecture."
+    fi
+}
+
 check_all_yum() {
     local missing=""
     for pkg in $1; do

include/mg_procedure.h

@@ -1292,6 +1292,12 @@ struct mgp_proc;
 /// Describes a Memgraph magic function.
 struct mgp_func;
 
+/// All available log levels that can be used in mgp_log function
+MGP_ENUM_CLASS mgp_log_level{
+    MGP_LOG_LEVEL_TRACE, MGP_LOG_LEVEL_DEBUG, MGP_LOG_LEVEL_INFO,
+    MGP_LOG_LEVEL_WARN,  MGP_LOG_LEVEL_ERROR, MGP_LOG_LEVEL_CRITICAL,
+};
+
 /// Entry-point for a query module read procedure, invoked through openCypher.
 ///
 /// Passed in arguments will not live longer than the callback's execution.
@@ -1386,6 +1392,9 @@ enum mgp_error mgp_proc_add_result(struct mgp_proc *proc, const char *name, stru
 /// Return mgp_error::MGP_ERROR_INVALID_ARGUMENT if `name` is not a valid result name.
 /// RETURN mgp_error::MGP_ERROR_LOGIC_ERROR if a result field with the same name was already added.
 enum mgp_error mgp_proc_add_deprecated_result(struct mgp_proc *proc, const char *name, struct mgp_type *type);
+
+/// Log a message on a certain level.
+enum mgp_error mgp_log(enum mgp_log_level log_level, const char *output);
 ///@}
 
 /// @name Execution
@@ -1512,6 +1521,10 @@ enum mgp_error mgp_module_add_transformation(struct mgp_module *module, const ch
 ///
 ///@{
 
+/// State of the database that is exposed to magic functions. Currently it is unused, but it enables extending the
+/// functionalities of magic functions in future without breaking the API.
+struct mgp_func_context;
+
 /// Add a required argument to a function.
 ///
 /// The order of the added arguments corresponds to the signature of the openCypher function.

init

@@ -24,7 +24,7 @@ function setup_virtualenv () {
     fi
 
     # create new virtualenv
-    virtualenv -p python3 ve3 || exit 1
+    python3 -m virtualenv -p python3 ve3 || exit 1
     source ve3/bin/activate
     pip --timeout 1000 install -r requirements.txt || exit 1
     deactivate
@@ -66,7 +66,7 @@ fi
 
 DISTRO=$(operating_system)
 ARCHITECTURE=$(architecture)
-if [ "${ARCHITECTURE}" = "arm64" ]; then
+if [ "${ARCHITECTURE}" = "arm64" ] || [ "${ARCHITECTURE}" = "aarch64" ]; then
   OS_SCRIPT=$DIR/environment/os/$DISTRO-arm.sh
 else
   OS_SCRIPT=$DIR/environment/os/$DISTRO.sh
@@ -139,3 +139,6 @@ done;
 # Install precommit hook
 python3 -m pip install pre-commit
 python3 -m pre_commit install
+
+# Link `include/mgp.py` with `release/mgp/mgp.py`
+ln -v -f include/mgp.py release/mgp/mgp.py

libs/.gitignore

@@ -5,3 +5,4 @@
 !CMakeLists.txt
 !__main.cpp
 !pulsar.patch
+!antlr4.10.1.patch

libs/CMakeLists.txt

@@ -106,6 +106,7 @@ import_external_library(antlr4 STATIC
              -DWITH_LIBCXX=OFF # because of debian bug
              -DCMAKE_SKIP_INSTALL_ALL_DEPENDENCY=true
              -DCMAKE_CXX_STANDARD=20
+             -DANTLR_BUILD_CPP_TESTS=OFF
   BUILD_COMMAND $(MAKE) antlr4_static
   INSTALL_COMMAND $(MAKE) install)
 

libs/antlr4.10.1.patch

@@ -0,0 +1,13 @@
+diff --git a/runtime/Cpp/runtime/CMakeLists.txt b/runtime/Cpp/runtime/CMakeLists.txt
+index baf46cac9..2e7756de8 100644
+--- a/runtime/Cpp/runtime/CMakeLists.txt
++++ b/runtime/Cpp/runtime/CMakeLists.txt
+@@ -134,7 +134,7 @@ set_target_properties(antlr4_static
+                                  ARCHIVE_OUTPUT_DIRECTORY ${LIB_OUTPUT_DIR}
+                                  COMPILE_FLAGS "${disabled_compile_warnings} ${extra_static_compile_flags}")
+
+-install(TARGETS antlr4_shared
++install(TARGETS antlr4_shared OPTIONAL
+         EXPORT antlr4-targets
+         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}

libs/antlr4.patch

@@ -1,43 +0,0 @@
-diff --git a/runtime/Cpp/runtime/CMakeLists.txt b/runtime/Cpp/runtime/CMakeLists.txt
-index a8503bb..11362cf 100644
---- a/runtime/Cpp/runtime/CMakeLists.txt
-+++ b/runtime/Cpp/runtime/CMakeLists.txt
-@@ -5,8 +5,8 @@ set(THIRDPARTY_DIR ${CMAKE_BINARY_DIR}/runtime/thirdparty)
- set(UTFCPP_DIR ${THIRDPARTY_DIR}/utfcpp)
- ExternalProject_Add(
-   utfcpp
--  GIT_REPOSITORY        "git://github.com/nemtrif/utfcpp"
--  GIT_TAG               "v3.1.1"
-+  GIT_REPOSITORY        "https://github.com/nemtrif/utfcpp"
-+  GIT_TAG               "v3.2.1"
-   SOURCE_DIR            ${UTFCPP_DIR}
-   UPDATE_DISCONNECTED   1
-   CMAKE_ARGS            -DCMAKE_INSTALL_PREFIX=${UTFCPP_DIR}/install -Dgtest_force_shared_crt=ON
-@@ -118,7 +118,7 @@ set_target_properties(antlr4_static
-                                  ARCHIVE_OUTPUT_DIRECTORY ${LIB_OUTPUT_DIR}
-                                  COMPILE_FLAGS "${disabled_compile_warnings} ${extra_static_compile_flags}")
- 
--install(TARGETS antlr4_shared
-+install(TARGETS antlr4_shared OPTIONAL
-         DESTINATION lib
-         EXPORT antlr4-targets)
- install(TARGETS antlr4_static
-diff --git a/runtime/Cpp/runtime/src/support/Any.h b/runtime/Cpp/runtime/src/support/Any.h
-index 468db98..65a473b 100644
---- a/runtime/Cpp/runtime/src/support/Any.h
-+++ b/runtime/Cpp/runtime/src/support/Any.h
-@@ -122,12 +122,12 @@ private:
-     }
- 
-   private:
--    template<int N = 0, typename std::enable_if<N == N && std::is_nothrow_copy_constructible<T>::value, int>::type = 0>
-+    template<int N = 0, typename std::enable_if<N == N && std::is_copy_constructible<T>::value, int>::type = 0>
-     Base* clone() const {
-       return new Derived<T>(value);
-     }
- 
--    template<int N = 0, typename std::enable_if<N == N && !std::is_nothrow_copy_constructible<T>::value, int>::type = 0>
-+    template<int N = 0, typename std::enable_if<N == N && !std::is_copy_constructible<T>::value, int>::type = 0>
-     Base* clone() const {
-       return nullptr;
-     }

libs/setup.sh

@@ -105,7 +105,7 @@ repo_clone_try_double () {
 # Download from primary_urls might fail because the cache is not installed.
 declare -A primary_urls=(
   ["antlr4-code"]="http://$local_cache_host/git/antlr4.git"
-  ["antlr4-generator"]="http://$local_cache_host/file/antlr-4.9.2-complete.jar"
+  ["antlr4-generator"]="http://$local_cache_host/file/antlr-4.10.1-complete.jar"
   ["cppitertools"]="http://$local_cache_host/git/cppitertools.git"
   ["rapidcheck"]="http://$local_cache_host/git/rapidcheck.git"
   ["gbenchmark"]="http://$local_cache_host/git/benchmark.git"
@@ -130,7 +130,7 @@ declare -A primary_urls=(
 # should fail.
 declare -A secondary_urls=(
   ["antlr4-code"]="https://github.com/antlr/antlr4.git"
-  ["antlr4-generator"]="http://www.antlr.org/download/antlr-4.9.2-complete.jar"
+  ["antlr4-generator"]="https://www.antlr.org/download/antlr-4.10.1-complete.jar"
   ["cppitertools"]="https://github.com/ryanhaining/cppitertools.git"
   ["rapidcheck"]="https://github.com/emil-e/rapidcheck.git"
   ["gbenchmark"]="https://github.com/google/benchmark.git"
@@ -152,10 +152,10 @@ declare -A secondary_urls=(
 # antlr
 file_get_try_double "${primary_urls[antlr4-generator]}" "${secondary_urls[antlr4-generator]}"
 
-antlr4_tag="4.9.2" # v4.9.2
+antlr4_tag="4.10.1" # v4.10.1
 repo_clone_try_double "${primary_urls[antlr4-code]}" "${secondary_urls[antlr4-code]}" "antlr4" "$antlr4_tag" true
 pushd antlr4
-git apply ../antlr4.patch
+git apply ../antlr4.10.1.patch
 popd
 
 # cppitertools v2.0 2019-12-23
@@ -199,7 +199,7 @@ git apply ../rocksdb.patch
 popd
 
 # mgclient
-mgclient_tag="96e95c6845463cbe88948392be58d26da0d5ffd3" # (2022-02-08)
+mgclient_tag="v1.4.0" # (2022-06-14)
 repo_clone_try_double "${primary_urls[mgclient]}" "${secondary_urls[mgclient]}" "mgclient" "$mgclient_tag"
 sed -i 's/\${CMAKE_INSTALL_LIBDIR}/lib/' mgclient/src/CMakeLists.txt
 

release/CMakeLists.txt

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

release/docker/memgraph_rpm.dockerfile

@@ -1,31 +0,0 @@
-FROM dokken/centos-stream-9
-# NOTE: If you change the base distro update release/package as well.
-
-ARG release
-
-RUN yum update && yum install -y \
-    openssl libcurl libseccomp python3 python3-pip \
-    --nobest --allowerasing \
-  && rm -rf /tmp/* \
-  && yum clean all
-
-RUN pip3 install networkx==2.4 numpy==1.21.4 scipy==1.7.3
-
-COPY ${release} /
-
-# Install memgraph package
-RUN rpm -i ${release}
-
-# Memgraph listens for Bolt Protocol on this port by default.
-EXPOSE 7687
-# Snapshots and logging volumes
-VOLUME /var/log/memgraph
-VOLUME /var/lib/memgraph
-# Configuration volume
-VOLUME /etc/memgraph
-
-USER memgraph
-WORKDIR /usr/lib/memgraph
-
-ENTRYPOINT ["/usr/lib/memgraph/memgraph"]
-CMD [""]

release/mgp/.gitignore

@@ -0,0 +1,3 @@
+.venv
+dist
+mgp.py

release/mgp/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

release/mgp/README.md

@@ -0,0 +1,4 @@
+# mgp
+
+PyPi package used for type hinting when creating MAGE modules. The get started
+using MAGE repository checkout the repository here: https://github.com/memgraph/mage.

release/mgp/_mgp.py

@@ -0,0 +1,255 @@
+from typing import Any
+
+
+class MgpIterable:
+    def get() -> Any:
+        pass
+
+    def next() -> Any:
+        pass
+
+
+class Vertex:
+    def is_valid() -> bool:  # type: ignore
+        pass
+
+    def underlying_graph_is_mutable() -> bool:  # type: ignore
+        pass
+
+    def iter_properties() -> MgpIterable:  # type: ignore
+        pass
+
+    def get_property(self, property_name: str) -> "Property":  # type: ignore
+        pass
+
+    def set_property(self, property_name: str, value: Any) -> "Property":  # type: ignore
+        pass
+
+    def get_id() -> "VertexId":  # type: ignore
+        pass
+
+    def label_at(self, index: int) -> "Label":  # type: ignore
+        pass
+
+    def labels_count() -> int:  # type: ignore
+        pass
+
+    def add_label(self, label: Any):
+        pass
+
+    def remove_label(self, label: Any):
+        pass
+
+    def iter_in_edges() -> MgpIterable:  # type: ignore
+        pass
+
+    def iter_out_edges() -> MgpIterable:  # type: ignore
+        pass
+
+
+class Edge:
+    def is_valid() -> bool:  # type: ignore
+        pass
+
+    def underlying_graph_is_mutable() -> bool:  # type: ignore
+        pass
+
+    def iter_properties() -> MgpIterable:  # type: ignore
+        pass
+
+    def get_property(self, property_name: str) -> "Property":  # type: ignore
+        pass
+
+    def set_property(self, property_name: str, valuse: Any) -> "Property":  # type: ignore
+        pass
+
+    def get_type_name() -> str:  # type: ignore
+        pass
+
+    def get_id() -> "EdgeId":  # type: ignore
+        pass
+
+    def from_vertex() -> Vertex:  # type: ignore
+        pass
+
+    def to_vertex() -> Vertex:  # type: ignore
+        pass
+
+
+class Path:
+    def is_valid() -> bool:  # type: ignore
+        pass
+
+    @staticmethod
+    def make_with_start(vertex: Vertex) -> "Path":  # type: ignore
+        pass
+
+
+class Graph:
+    def is_valid() -> bool:  # type: ignore
+        pass
+
+
+class CypherType:
+    pass
+
+
+class Message:
+    def is_valid() -> bool:  # type: ignore
+        pass
+
+    def source_type() -> str:  # type: ignore
+        pass
+
+    def topic_name() -> str:  # type: ignore
+        pass
+
+    def key() -> bytes:  # type: ignore
+        pass
+
+    def timestamp() -> int:  # type: ignore
+        pass
+
+    def offset() -> int:  # type: ignore
+        pass
+
+    def payload() -> bytes:  # type: ignore
+        pass
+
+
+class Messages:
+    def is_valid() -> bool:  # type: ignore
+        pass
+
+    def message_at(self, id: int) -> Message:  # type: ignore
+        pass
+
+    def total_messages() -> int:  # type: ignore
+        pass
+
+
+class UnknownError(Exception):
+    pass
+
+
+class UnableToAllocateError(Exception):
+    pass
+
+
+class InsufficientBufferError(Exception):
+    pass
+
+
+class OutOfRangeError(Exception):
+    pass
+
+
+class LogicErrorError(Exception):
+
+    pass
+
+
+class DeletedObjectError(Exception):
+    pass
+
+
+class InvalidArgumentError(Exception):
+    pass
+
+
+class KeyAlreadyExistsError(Exception):
+    pass
+
+
+class ImmutableObjectError(Exception):
+    pass
+
+
+class ValueConversionError(Exception):
+    pass
+
+
+class SerializationError(Exception):
+    pass
+
+
+def type_nullable(elem: Any):
+    pass
+
+
+def type_list(elem: Any):
+    pass
+
+
+def type_bool():
+    pass
+
+
+def type_string():
+    pass
+
+
+def type_int():
+    pass
+
+
+def type_float():
+    pass
+
+
+def type_number():
+    pass
+
+
+def type_map():
+    pass
+
+
+def type_node():
+    pass
+
+
+def type_relationship():
+    pass
+
+
+def type_path():
+    pass
+
+
+def type_date():
+    pass
+
+
+def type_local_time():
+    pass
+
+
+def type_local_date_time():
+    pass
+
+
+def type_duration():
+    pass
+
+
+def type_any():
+    pass
+
+
+class _MODULE:
+    @staticmethod
+    def add_read_procedure(wrapper):
+        pass
+
+    @staticmethod
+    def add_write_procedure(wrapper):
+        pass
+
+    @staticmethod
+    def add_transformation(wrapper):
+        pass
+
+    @staticmethod
+    def add_function(wrapper):
+        pass

release/mgp/instructions.md

@@ -0,0 +1,22 @@
+# How to publish new versions
+## Prerequisites
+1. Installed poetry
+```
+pip install poetry
+```
+2. Set up [API tokens](https://pypi.org/help/#apitoken)
+3. Be a collaborator on [pypi](https://pypi.org/project/mgp/)
+
+## Making changes
+1. Make changes to the package
+2. Bump version in `pyproject.tml`
+3. `poetry build`
+4. `poetry publish`
+
+## Why is this not automatized?
+
+Because someone always has to manually bump up the version in `pyproject.toml`
+
+## Why does `_mgp.py` exists?
+Because we are mocking here all the types that are created by Memgraph
+in order to fix typing errors in `mgp.py`.

release/mgp/pyproject.toml

@@ -0,0 +1,23 @@
+[tool.poetry]
+name = "mgp"
+version = "1.0.0"
+description = "Memgraph's module for developing MAGE modules. Used only for type hinting!"
+authors = [
+    "MasterMedo <mislav.vuletic@gmail.com>",
+    "jbajic <jure.bajic@memgraph.io>",
+    "katarinasupe <katarina.supe@memgraph.io>",
+    "antejavor <ante.javor@memgraph.io>",
+    "antaljanosbenjamin <benjamin.antal@memgraph.io>",
+]
+license = "Apache-2.0"
+readme = "README.md"
+include = ["mgp.py", "_mgp.py"]
+
+[tool.poetry.dependencies]
+python = "^3.7"
+
+[tool.poetry.dev-dependencies]
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

release/package/centos-7/Dockerfile

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

release/package/centos-8/Dockerfile

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

release/package/centos-9/Dockerfile

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

release/package/debian-10/Dockerfile

@@ -10,8 +10,8 @@ RUN apt update && apt install -y \
 # Do NOT be smart here and clean the cache because the container is used in the
 # stateful context.
 
-RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-debian-10.tar.gz \
-    -O ${TOOLCHAIN_VERSION}-binaries-debian-10.tar.gz \
-    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-debian-10.tar.gz -C /opt
+RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-debian-10-amd64.tar.gz \
+    -O ${TOOLCHAIN_VERSION}-binaries-debian-10-amd64.tar.gz \
+    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-debian-10-amd64.tar.gz -C /opt
 
 ENTRYPOINT ["sleep", "infinity"]

release/package/debian-11-arm/Dockerfile

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

release/package/debian-11/Dockerfile

@@ -10,8 +10,8 @@ RUN apt update && apt install -y \
 # Do NOT be smart here and clean the cache because the container is used in the
 # stateful context.
 
-RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-debian-11.tar.gz \
-    -O ${TOOLCHAIN_VERSION}-binaries-debian-11.tar.gz \
-    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-debian-11.tar.gz -C /opt
+RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-debian-11-amd64.tar.gz \
+    -O ${TOOLCHAIN_VERSION}-binaries-debian-11-amd64.tar.gz \
+    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-debian-11-amd64.tar.gz -C /opt
 
 ENTRYPOINT ["sleep", "infinity"]

release/package/docker-compose.yml

@@ -4,10 +4,10 @@ services:
     build:
       context: centos-7
     container_name: "mgbuild_centos-7"
-  mgbuild_centos-8:
+  mgbuild_centos-9:
     build:
-      context: centos-8
-    container_name: "mgbuild_centos-8"
+      context: centos-9
+    container_name: "mgbuild_centos-9"
   mgbuild_debian-10:
     build:
       context: debian-10
@@ -24,3 +24,7 @@ services:
     build:
       context: ubuntu-20.04
     container_name: "mgbuild_ubuntu-20.04"
+  mgbuild_ubuntu-22.04:
+    build:
+      context: ubuntu-22.04
+    container_name: "mgbuild_ubuntu-22.04"

release/package/run.sh

@@ -3,7 +3,7 @@
 set -Eeuo pipefail
 
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-SUPPORTED_OS=(centos-7 centos-8 debian-10 debian-11 ubuntu-18.04 ubuntu-20.04)
+SUPPORTED_OS=(centos-7 centos-9 debian-10 debian-11 ubuntu-18.04 ubuntu-20.04 ubuntu-22.04 debian-11-arm)
 PROJECT_ROOT="$SCRIPT_DIR/../.."
 TOOLCHAIN_VERSION="toolchain-v4"
 ACTIVATE_TOOLCHAIN="source /opt/${TOOLCHAIN_VERSION}/activate"
@@ -67,14 +67,18 @@ make_package () {
     # environment/os/{os}.sh does not come within the toolchain package. When
     # migrating to the next version of toolchain do that, and remove the
     # TOOLCHAIN_RUN_DEPS installation from here.
-    echo "Installing dependencies..."
+    echo "Installing dependencies using '/memgraph/environment/os/$os.sh' script..."
     docker exec "$build_container" bash -c "/memgraph/environment/os/$os.sh install TOOLCHAIN_RUN_DEPS"
     docker exec "$build_container" bash -c "/memgraph/environment/os/$os.sh install MEMGRAPH_BUILD_DEPS"
 
     echo "Building targeted package..."
     docker exec "$build_container" bash -c "cd /memgraph && $ACTIVATE_TOOLCHAIN && ./init"
     docker exec "$build_container" bash -c "cd $container_build_dir && rm -rf ./*"
-    docker exec "$build_container" bash -c "cd $container_build_dir && $ACTIVATE_TOOLCHAIN && cmake -DCMAKE_BUILD_TYPE=release $telemetry_id_override_flag .."
+    if [[ "$os" == "debian-11-arm" ]]; then
+        docker exec "$build_container" bash -c "cd $container_build_dir && $ACTIVATE_TOOLCHAIN && cmake -DCMAKE_BUILD_TYPE=release -DMG_ARCH="ARM64" $telemetry_id_override_flag .."
+    else
+        docker exec "$build_container" bash -c "cd $container_build_dir && $ACTIVATE_TOOLCHAIN && cmake -DCMAKE_BUILD_TYPE=release $telemetry_id_override_flag .."
+    fi
     # ' is used instead of " because we need to run make within the allowed
     # container resources.
     # shellcheck disable=SC2016

release/package/ubuntu-18.04/Dockerfile

@@ -10,8 +10,8 @@ RUN apt update && apt install -y \
 # Do NOT be smart here and clean the cache because the container is used in the
 # stateful context.
 
-RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-ubuntu-18.04.tar.gz \
-    -O ${TOOLCHAIN_VERSION}-binaries-ubuntu-18.04.tar.gz \
-    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-ubuntu-18.04.tar.gz -C /opt
+RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-ubuntu-18.04-amd64.tar.gz \
+    -O ${TOOLCHAIN_VERSION}-binaries-ubuntu-18.04-amd64.tar.gz \
+    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-ubuntu-18.04-amd64.tar.gz -C /opt
 
 ENTRYPOINT ["sleep", "infinity"]

release/package/ubuntu-20.04/Dockerfile

@@ -10,8 +10,8 @@ RUN apt update && apt install -y \
 # Do NOT be smart here and clean the cache because the container is used in the
 # stateful context.
 
-RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-ubuntu-20.04.tar.gz \
-    -O ${TOOLCHAIN_VERSION}-binaries-ubuntu-20.04.tar.gz \
-    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-ubuntu-20.04.tar.gz -C /opt
+RUN wget -q https://s3-eu-west-1.amazonaws.com/deps.memgraph.io/${TOOLCHAIN_VERSION}/${TOOLCHAIN_VERSION}-binaries-ubuntu-20.04-amd64.tar.gz \
+    -O ${TOOLCHAIN_VERSION}-binaries-ubuntu-20.04-amd64.tar.gz \
+    && tar xzvf ${TOOLCHAIN_VERSION}-binaries-ubuntu-20.04-amd64.tar.gz -C /opt
 
 ENTRYPOINT ["sleep", "infinity"]

release/package/ubuntu-22.04/Dockerfile

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

src/communication/CMakeLists.txt

@@ -7,6 +7,7 @@ set(communication_src_files
     websocket/listener.cpp
     websocket/session.cpp
     bolt/v1/value.cpp
+    bolt/client.cpp
     buffer.cpp
     client.cpp
     context.cpp

src/communication/bolt/client.cpp

@@ -0,0 +1,262 @@
+// Copyright 2022 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "communication/bolt/client.hpp"
+
+#include "communication/bolt/v1/codes.hpp"
+#include "communication/bolt/v1/value.hpp"
+#include "utils/logging.hpp"
+
+namespace {
+constexpr uint8_t kBoltV43Version[4] = {0x00, 0x00, 0x03, 0x04};
+constexpr uint8_t kEmptyBoltVersion[4] = {0x00, 0x00, 0x00, 0x00};
+}  // namespace
+namespace memgraph::communication::bolt {
+
+Client::Client(communication::ClientContext &context) : client_{&context} {}
+
+void Client::Connect(const io::network::Endpoint &endpoint, const std::string &username, const std::string &password,
+                     const std::string &client_name) {
+  if (!client_.Connect(endpoint)) {
+    throw ClientFatalException("Couldn't connect to {}!", endpoint);
+  }
+
+  if (!client_.Write(kPreamble, sizeof(kPreamble), true)) {
+    spdlog::error("Couldn't send preamble!");
+    throw ServerCommunicationException();
+  }
+
+  if (!client_.Write(kBoltV43Version, sizeof(kBoltV43Version), true)) {
+    spdlog::error("Couldn't send protocol version!");
+    throw ServerCommunicationException();
+  }
+
+  for (int i = 0; i < 3; ++i) {
+    if (!client_.Write(kEmptyBoltVersion, sizeof(kEmptyBoltVersion), i != 2)) {
+      spdlog::error("Couldn't send protocol version!");
+      throw ServerCommunicationException();
+    }
+  }
+
+  if (!client_.Read(sizeof(kBoltV43Version))) {
+    spdlog::error("Couldn't get negotiated protocol version!");
+    throw ServerCommunicationException();
+  }
+
+  if (memcmp(kBoltV43Version, client_.GetData(), sizeof(kBoltV43Version)) != 0) {
+    spdlog::error("Server negotiated unsupported protocol version!");
+    throw ClientFatalException("The server negotiated an usupported protocol version!");
+  }
+  client_.ShiftData(sizeof(kBoltV43Version));
+
+  if (!encoder_.MessageInit({{"user_agent", client_name},
+                             {"scheme", "basic"},
+                             {"principal", username},
+                             {"credentials", password},
+                             {"routing", {}}})) {
+    spdlog::error("Couldn't send init message!");
+    throw ServerCommunicationException();
+  }
+
+  Signature signature{};
+  Value metadata;
+  if (!ReadMessage(signature, metadata)) {
+    spdlog::error("Couldn't read init message response!");
+    throw ServerCommunicationException();
+  }
+  if (signature != Signature::Success) {
+    spdlog::error("Handshake failed!");
+    throw ClientFatalException("Handshake with the server failed!");
+  }
+
+  spdlog::debug("Metadata of init message response: {}", metadata);
+}
+
+QueryData Client::Execute(const std::string &query, const std::map<std::string, Value> &parameters) {
+  if (!client_.IsConnected()) {
+    throw ClientFatalException("You must first connect to the server before using the client!");
+  }
+
+  spdlog::debug("Sending run message with statement: '{}'; parameters: {}", query, parameters);
+
+  // It is super critical from performance point of view to send the pull message right after the run message. Otherwise
+  // the performance will degrade multiple magnitudes.
+  encoder_.MessageRun(query, parameters, {});
+  encoder_.MessagePull({});
+
+  spdlog::debug("Reading run message response");
+  Signature signature{};
+  Value fields;
+  if (!ReadMessage(signature, fields)) {
+    throw ServerCommunicationException();
+  }
+  if (fields.type() != Value::Type::Map) {
+    throw ServerMalformedDataException();
+  }
+
+  if (signature == Signature::Failure) {
+    HandleFailure<ClientQueryException>(fields.ValueMap());
+  }
+  if (signature != Signature::Success) {
+    throw ServerMalformedDataException();
+  }
+
+  spdlog::debug("Reading pull_all message response");
+  Marker marker{};
+  Value metadata;
+  std::vector<std::vector<Value>> records;
+  while (true) {
+    if (!GetMessage()) {
+      throw ServerCommunicationException();
+    }
+    if (!decoder_.ReadMessageHeader(&signature, &marker)) {
+      throw ServerCommunicationException();
+    }
+    if (signature == Signature::Record) {
+      Value record;
+      if (!decoder_.ReadValue(&record, Value::Type::List)) {
+        throw ServerCommunicationException();
+      }
+      records.emplace_back(std::move(record.ValueList()));
+    } else if (signature == Signature::Success) {
+      if (!decoder_.ReadValue(&metadata)) {
+        throw ServerCommunicationException();
+      }
+      break;
+    } else if (signature == Signature::Failure) {
+      Value data;
+      if (!decoder_.ReadValue(&data)) {
+        throw ServerCommunicationException();
+      }
+      HandleFailure<ClientQueryException>(data.ValueMap());
+    } else {
+      throw ServerMalformedDataException();
+    }
+  }
+
+  if (metadata.type() != Value::Type::Map) {
+    throw ServerMalformedDataException();
+  }
+
+  QueryData ret{{}, std::move(records), std::move(metadata.ValueMap())};
+
+  auto &header = fields.ValueMap();
+  if (header.find("fields") == header.end()) {
+    throw ServerMalformedDataException();
+  }
+  if (header["fields"].type() != Value::Type::List) {
+    throw ServerMalformedDataException();
+  }
+  auto &field_vector = header["fields"].ValueList();
+
+  for (auto &field_item : field_vector) {
+    if (field_item.type() != Value::Type::String) {
+      throw ServerMalformedDataException();
+    }
+    ret.fields.emplace_back(std::move(field_item.ValueString()));
+  }
+
+  return ret;
+}
+
+void Client::Reset() {
+  if (!client_.IsConnected()) {
+    throw ClientFatalException("You must first connect to the server before using the client!");
+  }
+
+  spdlog::debug("Sending reset message");
+
+  encoder_.MessageReset();
+
+  Signature signature{};
+  Value fields;
+  // In Execute the pull message is sent right after the run message without reading the answer for the run message.
+  // That means some of the messages sent might get ignored.
+  while (true) {
+    if (!ReadMessage(signature, fields)) {
+      throw ServerCommunicationException();
+    }
+    if (signature == Signature::Success) {
+      break;
+    }
+    if (signature != Signature::Ignored) {
+      throw ServerMalformedDataException();
+    }
+  }
+}
+
+std::optional<std::map<std::string, Value>> Client::Route(const std::map<std::string, Value> &routing,
+                                                          const std::vector<Value> &bookmarks,
+                                                          const std::optional<std::string> &db) {
+  if (!client_.IsConnected()) {
+    throw ClientFatalException("You must first connect to the server before using the client!");
+  }
+
+  spdlog::debug("Sending route message with routing: {}; bookmarks: {}; db: {}", routing, bookmarks,
+                db.has_value() ? *db : Value());
+
+  encoder_.MessageRoute(routing, bookmarks, db);
+
+  spdlog::debug("Reading route message response");
+  Signature signature{};
+  Value fields;
+  if (!ReadMessage(signature, fields)) {
+    throw ServerCommunicationException();
+  }
+  if (signature == Signature::Ignored) {
+    return std::nullopt;
+  }
+  if (signature == Signature::Failure) {
+    HandleFailure(fields.ValueMap());
+  }
+  if (signature != Signature::Success) {
+    throw ServerMalformedDataException{};
+  }
+  return fields.ValueMap();
+}
+
+void Client::Close() { client_.Close(); };
+
+bool Client::GetMessage() {
+  client_.ClearData();
+  while (true) {
+    if (!client_.Read(kChunkHeaderSize)) return false;
+
+    size_t chunk_size = client_.GetData()[0];
+    chunk_size <<= 8U;
+    chunk_size += client_.GetData()[1];
+    if (chunk_size == 0) return true;
+
+    if (!client_.Read(chunk_size)) return false;
+    if (decoder_buffer_.GetChunk() != ChunkState::Whole) return false;
+    client_.ClearData();
+  }
+  return true;
+}
+
+bool Client::ReadMessage(Signature &signature, Value &ret) {
+  Marker marker{};
+  if (!GetMessage()) return false;
+  if (!decoder_.ReadMessageHeader(&signature, &marker)) return false;
+  return ReadMessageData(marker, ret);
+}
+
+bool Client::ReadMessageData(Marker marker, Value &ret) {
+  if (marker == Marker::TinyStruct) {
+    ret = Value();
+    return true;
+  }
+  if (marker == Marker::TinyStruct1) {
+    return decoder_.ReadValue(&ret);
+  }
+  return false;
+}
+}  // namespace memgraph::communication::bolt

src/communication/bolt/client.hpp

@@ -11,6 +11,12 @@
 
 #pragma once
 
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "communication/bolt/v1/codes.hpp"
 #include "communication/bolt/v1/decoder/chunked_decoder_buffer.hpp"
 #include "communication/bolt/v1/decoder/decoder.hpp"
 #include "communication/bolt/v1/encoder/chunked_encoder_buffer.hpp"
@@ -19,22 +25,17 @@
 #include "communication/context.hpp"
 #include "io/network/endpoint.hpp"
 #include "utils/exceptions.hpp"
-#include "utils/logging.hpp"
 
 namespace memgraph::communication::bolt {
 
-/// This exception is thrown whenever an error occurs during query execution
-/// that isn't fatal (eg. mistyped query or some transient error occurred).
-/// It should be handled by everyone who uses the client.
-class ClientQueryException : public utils::BasicException {
+class FailureResponseException : public utils::BasicException {
  public:
-  using utils::BasicException::BasicException;
+  FailureResponseException() : utils::BasicException{"Couldn't execute query!"} {}
 
-  ClientQueryException() : utils::BasicException("Couldn't execute query!") {}
+  explicit FailureResponseException(const std::string &message) : utils::BasicException{message} {}
 
-  template <class... Args>
-  ClientQueryException(const std::string &code, Args &&...args)
-      : utils::BasicException(std::forward<Args>(args)...), code_(code) {}
+  FailureResponseException(const std::string &code, const std::string &message)
+      : utils::BasicException{message}, code_{code} {}
 
   const std::string &code() const { return code_; }
 
@@ -42,6 +43,14 @@ class ClientQueryException : public utils::BasicException {
   std::string code_;
 };
 
+/// This exception is thrown whenever an error occurs during query execution
+/// that isn't fatal (eg. mistyped query or some transient error occurred).
+/// It should be handled by everyone who uses the client.
+class ClientQueryException : public FailureResponseException {
+ public:
+  using FailureResponseException::FailureResponseException;
+};
+
 /// This exception is thrown whenever a fatal error occurs during query
 /// execution and/or connecting to the server.
 /// It should be handled by everyone who uses the client.
@@ -76,12 +85,13 @@ struct QueryData {
 /// server. It supports both SSL and plaintext connections.
 class Client final {
  public:
-  explicit Client(communication::ClientContext *context) : client_(context) {}
+  explicit Client(communication::ClientContext &context);
 
   Client(const Client &) = delete;
   Client(Client &&) = delete;
   Client &operator=(const Client &) = delete;
   Client &operator=(Client &&) = delete;
+  ~Client() = default;
 
   /// Method used to connect to the server. Before executing queries this method
   /// should be called to set-up the connection to the server. After the
@@ -89,50 +99,7 @@ class Client final {
   /// established connection.
   /// @throws ClientFatalException when we couldn't connect to the server
   void Connect(const io::network::Endpoint &endpoint, const std::string &username, const std::string &password,
-               const std::string &client_name = "memgraph-bolt") {
-    if (!client_.Connect(endpoint)) {
-      throw ClientFatalException("Couldn't connect to {}!", endpoint);
-    }
-
-    if (!client_.Write(kPreamble, sizeof(kPreamble), true)) {
-      SPDLOG_ERROR("Couldn't send preamble!");
-      throw ServerCommunicationException();
-    }
-    for (int i = 0; i < 4; ++i) {
-      if (!client_.Write(kProtocol, sizeof(kProtocol), i != 3)) {
-        SPDLOG_ERROR("Couldn't send protocol version!");
-        throw ServerCommunicationException();
-      }
-    }
-
-    if (!client_.Read(sizeof(kProtocol))) {
-      SPDLOG_ERROR("Couldn't get negotiated protocol version!");
-      throw ServerCommunicationException();
-    }
-    if (memcmp(kProtocol, client_.GetData(), sizeof(kProtocol)) != 0) {
-      SPDLOG_ERROR("Server negotiated unsupported protocol version!");
-      throw ClientFatalException("The server negotiated an usupported protocol version!");
-    }
-    client_.ShiftData(sizeof(kProtocol));
-
-    if (!encoder_.MessageInit(client_name, {{"scheme", "basic"}, {"principal", username}, {"credentials", password}})) {
-      SPDLOG_ERROR("Couldn't send init message!");
-      throw ServerCommunicationException();
-    }
-
-    Signature signature;
-    Value metadata;
-    if (!ReadMessage(&signature, &metadata)) {
-      SPDLOG_ERROR("Couldn't read init message response!");
-      throw ServerCommunicationException();
-    }
-    if (signature != Signature::Success) {
-      SPDLOG_ERROR("Handshake failed!");
-      throw ClientFatalException("Handshake with the server failed!");
-    }
-
-    SPDLOG_INFO("Metadata of init message response: {}", metadata);
-  }
+               const std::string &client_name = "memgraph-bolt");
 
   /// Function used to execute queries against the server. Before you can
   /// execute queries you must connect the client to the server.
@@ -140,168 +107,41 @@ class Client final {
   ///                              executing the query (eg. mistyped query,
   ///                              etc.)
   /// @throws ClientFatalException when we couldn't communicate with the server
-  QueryData Execute(const std::string &query, const std::map<std::string, Value> &parameters) {
-    if (!client_.IsConnected()) {
-      throw ClientFatalException("You must first connect to the server before using the client!");
-    }
-
-    SPDLOG_INFO("Sending run message with statement: '{}'; parameters: {}", query, parameters);
-
-    encoder_.MessageRun(query, parameters);
-    encoder_.MessagePullAll();
-
-    SPDLOG_INFO("Reading run message response");
-    Signature signature;
-    Value fields;
-    if (!ReadMessage(&signature, &fields)) {
-      throw ServerCommunicationException();
-    }
-    if (fields.type() != Value::Type::Map) {
-      throw ServerMalformedDataException();
-    }
-
-    if (signature == Signature::Failure) {
-      HandleFailure();
-      auto &tmp = fields.ValueMap();
-      auto it = tmp.find("message");
-      if (it != tmp.end()) {
-        auto it_code = tmp.find("code");
-        if (it_code != tmp.end()) {
-          throw ClientQueryException(it_code->second.ValueString(), it->second.ValueString());
-        } else {
-          throw ClientQueryException("", it->second.ValueString());
-        }
-      }
-      throw ClientQueryException();
-    } else if (signature != Signature::Success) {
-      throw ServerMalformedDataException();
-    }
-
-    SPDLOG_INFO("Reading pull_all message response");
-    Marker marker;
-    Value metadata;
-    std::vector<std::vector<Value>> records;
-    while (true) {
-      if (!GetMessage()) {
-        throw ServerCommunicationException();
-      }
-      if (!decoder_.ReadMessageHeader(&signature, &marker)) {
-        throw ServerCommunicationException();
-      }
-      if (signature == Signature::Record) {
-        Value record;
-        if (!decoder_.ReadValue(&record, Value::Type::List)) {
-          throw ServerCommunicationException();
-        }
-        records.emplace_back(std::move(record.ValueList()));
-      } else if (signature == Signature::Success) {
-        if (!decoder_.ReadValue(&metadata)) {
-          throw ServerCommunicationException();
-        }
-        break;
-      } else if (signature == Signature::Failure) {
-        Value data;
-        if (!decoder_.ReadValue(&data)) {
-          throw ServerCommunicationException();
-        }
-        HandleFailure();
-        auto &tmp = data.ValueMap();
-        auto it = tmp.find("message");
-        if (it != tmp.end()) {
-          auto it_code = tmp.find("code");
-          if (it_code != tmp.end()) {
-            throw ClientQueryException(it_code->second.ValueString(), it->second.ValueString());
-          } else {
-            throw ClientQueryException("", it->second.ValueString());
-          }
-        }
-        throw ClientQueryException();
-      } else {
-        throw ServerMalformedDataException();
-      }
-    }
-
-    if (metadata.type() != Value::Type::Map) {
-      throw ServerMalformedDataException();
-    }
-
-    QueryData ret{{}, std::move(records), std::move(metadata.ValueMap())};
-
-    auto &header = fields.ValueMap();
-    if (header.find("fields") == header.end()) {
-      throw ServerMalformedDataException();
-    }
-    if (header["fields"].type() != Value::Type::List) {
-      throw ServerMalformedDataException();
-    }
-    auto &field_vector = header["fields"].ValueList();
-
-    for (auto &field_item : field_vector) {
-      if (field_item.type() != Value::Type::String) {
-        throw ServerMalformedDataException();
-      }
-      ret.fields.emplace_back(std::move(field_item.ValueString()));
-    }
-
-    return ret;
-  }
+  QueryData Execute(const std::string &query, const std::map<std::string, Value> &parameters);
 
   /// Close the active client connection.
-  void Close() { client_.Close(); };
+  void Close();
+
+  /// Can be used to reset the active client connection. Reset is automatically sent after receiving a failure message
+  /// from the server, which result in throwing an FailureResponseException or any exception derived from it.
+  void Reset();
+
+  /// Can be used to send a route message.
+  std::optional<std::map<std::string, Value>> Route(const std::map<std::string, Value> &routing,
+                                                    const std::vector<Value> &bookmarks,
+                                                    const std::optional<std::string> &db);
 
  private:
-  bool GetMessage() {
-    client_.ClearData();
-    while (true) {
-      if (!client_.Read(kChunkHeaderSize)) return false;
+  using ClientEncoder = ClientEncoder<ChunkedEncoderBuffer<communication::ClientOutputStream>>;
 
-      size_t chunk_size = client_.GetData()[0];
-      chunk_size <<= 8;
-      chunk_size += client_.GetData()[1];
-      if (chunk_size == 0) return true;
-
-      if (!client_.Read(chunk_size)) return false;
-      if (decoder_buffer_.GetChunk() != ChunkState::Whole) return false;
-      client_.ClearData();
-    }
-    return true;
-  }
-
-  bool ReadMessage(Signature *signature, Value *ret) {
-    Marker marker;
-    if (!GetMessage()) return false;
-    if (!decoder_.ReadMessageHeader(signature, &marker)) return false;
-    return ReadMessageData(marker, ret);
-  }
-
-  bool ReadMessageData(Marker marker, Value *ret) {
-    if (marker == Marker::TinyStruct) {
-      *ret = Value();
-      return true;
-    } else if (marker == Marker::TinyStruct1) {
-      return decoder_.ReadValue(ret);
-    }
-    return false;
-  }
-
-  void HandleFailure() {
-    if (!encoder_.MessageAckFailure()) {
-      throw ServerCommunicationException();
-    }
-    while (true) {
-      Signature signature;
-      Value data;
-      if (!ReadMessage(&signature, &data)) {
-        throw ServerCommunicationException();
-      }
-      if (signature == Signature::Success) {
-        break;
-      } else if (signature != Signature::Ignored) {
-        throw ServerMalformedDataException();
+  template <typename TException = FailureResponseException>
+  [[noreturn]] void HandleFailure(const std::map<std::string, Value> &response_map) {
+    Reset();
+    auto it = response_map.find("message");
+    if (it != response_map.end()) {
+      auto it_code = response_map.find("code");
+      if (it_code != response_map.end()) {
+        throw TException(it_code->second.ValueString(), it->second.ValueString());
       }
+      throw TException("", it->second.ValueString());
     }
+    throw TException();
   }
 
+  bool GetMessage();
+  bool ReadMessage(Signature &signature, Value &ret);
+  bool ReadMessageData(Marker marker, Value &ret);
+
   // client
   communication::Client client_;
   communication::ClientInputStream input_stream_{client_};
@@ -313,6 +153,6 @@ class Client final {
 
   // encoder objects
   ChunkedEncoderBuffer<communication::ClientOutputStream> encoder_buffer_{output_stream_};
-  ClientEncoder<ChunkedEncoderBuffer<communication::ClientOutputStream>> encoder_{encoder_buffer_};
+  ClientEncoder encoder_{encoder_buffer_};
 };
 }  // namespace memgraph::communication::bolt

src/communication/bolt/v1/codes.hpp

@@ -16,7 +16,6 @@
 namespace memgraph::communication::bolt {
 
 inline constexpr uint8_t kPreamble[4] = {0x60, 0x60, 0xB0, 0x17};
-inline constexpr uint8_t kProtocol[4] = {0x00, 0x00, 0x00, 0x01};
 
 enum class Signature : uint8_t {
   Noop = 0x00,

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

@@ -11,6 +11,11 @@
 
 #pragma once
 
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
 #include "communication/bolt/v1/codes.hpp"
 #include "communication/bolt/v1/encoder/base_encoder.hpp"
 
@@ -30,6 +35,7 @@ class ClientEncoder : private BaseEncoder<Buffer> {
   using BaseEncoder<Buffer>::WriteList;
   using BaseEncoder<Buffer>::WriteMap;
   using BaseEncoder<Buffer>::WriteString;
+  using BaseEncoder<Buffer>::WriteNull;
   using BaseEncoder<Buffer>::buffer_;
 
  public:
@@ -38,10 +44,9 @@ class ClientEncoder : private BaseEncoder<Buffer> {
   /**
    * Writes a Init message.
    *
-   * From the Bolt v1 documentation:
-   *   InitMessage (signature=0x01) {
-   *     String clientName
-   *     Map<String,Value> authToken
+   * From the Bolt v4.3 documentation:
+   *   HelloMess (signature=0x01) {
+   *     Map<String,Value> extra
    *   }
    *
    * @param client_name the name of the connected client
@@ -49,11 +54,10 @@ class ClientEncoder : private BaseEncoder<Buffer> {
    * @returns true if the data was successfully sent to the client
    *          when flushing, false otherwise
    */
-  bool MessageInit(const std::string client_name, const std::map<std::string, Value> &auth_token) {
-    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct2));
+  bool MessageInit(const std::map<std::string, Value> &extra) {
+    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct1));
     WriteRAW(utils::UnderlyingCast(Signature::Init));
-    WriteString(client_name);
-    WriteMap(auth_token);
+    WriteMap(extra);
     // Try to flush all remaining data in the buffer, but tell it that we will
     // send more data (the end of message chunk).
     if (!buffer_.Flush(true)) return false;
@@ -64,10 +68,11 @@ class ClientEncoder : private BaseEncoder<Buffer> {
   /**
    * Writes a Run message.
    *
-   * From the Bolt v1 documentation:
+   * From the Bolt v4.3 documentation:
    *   RunMessage (signature=0x10) {
-   *     String             statement
-   *     Map<String,Value>  parameters
+   *     String            statement
+   *     Map<String,Value> parameters
+   *     Map<String,Value> extra
    *   }
    *
    * @param statement the statement that should be executed
@@ -75,11 +80,13 @@ class ClientEncoder : private BaseEncoder<Buffer> {
    * @returns true if the data was successfully sent to the client
    *          when flushing, false otherwise
    */
-  bool MessageRun(const std::string &statement, const std::map<std::string, Value> &parameters, bool have_more = true) {
-    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct2));
+  bool MessageRun(const std::string &statement, const std::map<std::string, Value> &parameters,
+                  const std::map<std::string, Value> &extra, bool have_more = true) {
+    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct3));
     WriteRAW(utils::UnderlyingCast(Signature::Run));
     WriteString(statement);
     WriteMap(parameters);
+    WriteMap(extra);
     // Try to flush all remaining data in the buffer, but tell it that we will
     // send more data (the end of message chunk).
     if (!buffer_.Flush(true)) return false;
@@ -90,18 +97,20 @@ class ClientEncoder : private BaseEncoder<Buffer> {
   }
 
   /**
-   * Writes a DiscardAll message.
+   * Writes a Discard message.
    *
-   * From the Bolt v1 documentation:
+   * From the Bolt v4.3 documentation:
    *   DiscardMessage (signature=0x2F) {
+   *     Map<String,Value> extra
    *   }
    *
    * @returns true if the data was successfully sent to the client
    *          when flushing, false otherwise
    */
-  bool MessageDiscardAll() {
-    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct));
+  bool MessageDiscard(const std::map<std::string, Value> &extra) {
+    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct1));
     WriteRAW(utils::UnderlyingCast(Signature::Discard));
+    WriteMap(extra);
     // Try to flush all remaining data in the buffer, but tell it that we will
     // send more data (the end of message chunk).
     if (!buffer_.Flush(true)) return false;
@@ -112,36 +121,18 @@ class ClientEncoder : private BaseEncoder<Buffer> {
   /**
    * Writes a PullAll message.
    *
-   * From the Bolt v1 documentation:
-   *   PullAllMessage (signature=0x3F) {
+   * From the Bolt v4.3 documentation:
+   *   PullMessage (signature=0x3F) {
+   *     Map<String,Value> extra
    *   }
    *
    * @returns true if the data was successfully sent to the client
    *          when flushing, false otherwise
    */
-  bool MessagePullAll() {
-    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct));
+  bool MessagePull(const std::map<std::string, Value> &extra) {
+    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct1));
     WriteRAW(utils::UnderlyingCast(Signature::Pull));
-    // Try to flush all remaining data in the buffer, but tell it that we will
-    // send more data (the end of message chunk).
-    if (!buffer_.Flush(true)) return false;
-    // Flush an empty chunk to indicate that the message is done.
-    return buffer_.Flush();
-  }
-
-  /**
-   * Writes a AckFailure message.
-   *
-   * From the Bolt v1 documentation:
-   *   AckFailureMessage (signature=0x0E) {
-   *   }
-   *
-   * @returns true if the data was successfully sent to the client
-   *          when flushing, false otherwise
-   */
-  bool MessageAckFailure() {
-    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct));
-    WriteRAW(utils::UnderlyingCast(Signature::AckFailure));
+    WriteMap(extra);
     // Try to flush all remaining data in the buffer, but tell it that we will
     // send more data (the end of message chunk).
     if (!buffer_.Flush(true)) return false;
@@ -152,7 +143,7 @@ class ClientEncoder : private BaseEncoder<Buffer> {
   /**
    * Writes a Reset message.
    *
-   * From the Bolt v1 documentation:
+   * From the Bolt v4.3 documentation:
    *   ResetMessage (signature=0x0F) {
    *   }
    *
@@ -168,5 +159,36 @@ class ClientEncoder : private BaseEncoder<Buffer> {
     // Flush an empty chunk to indicate that the message is done.
     return buffer_.Flush();
   }
+
+  /**
+   * Writes a Route message.
+   *
+   * From the Bolt v4.3 documentation:
+   *   RouteMessage (signature=0x0F) {
+   *     Map<String,Value> routing
+   *     List<String>      bookmarks
+   *     String            db
+   *   }
+   *
+   * @returns true if the data was successfully sent to the client
+   *          when flushing, false otherwise
+   */
+  bool MessageRoute(const std::map<std::string, Value> &routing, const std::vector<Value> &bookmarks,
+                    const std::optional<std::string> &db) {
+    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct3));
+    WriteRAW(utils::UnderlyingCast(Signature::Route));
+    WriteMap(routing);
+    WriteList(bookmarks);
+    if (db.has_value()) {
+      WriteString(*db);
+    } else {
+      WriteNull();
+    }
+    // Try to flush all remaining data in the buffer, but tell it that we will
+    // send more data (the end of message chunk).
+    if (!buffer_.Flush(true)) return false;
+    // Flush an empty chunk to indicate that the message is done.
+    return buffer_.Flush();
+  }
 };
 }  // namespace memgraph::communication::bolt

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

@@ -117,29 +117,6 @@ class Encoder : private BaseEncoder<Buffer> {
     return buffer_.Flush();
   }
 
-  /**
-   * Sends an Ignored message.
-   *
-   * From the bolt v1 documentation:
-   *   IgnoredMessage (signature=0x7E) {
-   *     Map<String,Value> metadata
-   *   }
-   *
-   * @param metadata the metadata map object that should be sent
-   * @returns true if the data was successfully sent to the client,
-   *          false otherwise
-   */
-  bool MessageIgnored(const std::map<std::string, Value> &metadata) {
-    WriteRAW(utils::UnderlyingCast(Marker::TinyStruct1));
-    WriteRAW(utils::UnderlyingCast(Signature::Ignored));
-    WriteMap(metadata);
-    // Try to flush all remaining data in the buffer, but tell it that we will
-    // send more data (the end of message chunk).
-    if (!buffer_.Flush(true)) return false;
-    // Flush an empty chunk to indicate that the message is done.
-    return buffer_.Flush();
-  }
-
   /**
    * Sends an Ignored message.
    *

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

@@ -15,6 +15,7 @@
 
 #include "communication/bolt/v1/codes.hpp"
 #include "communication/bolt/v1/state.hpp"
+#include "communication/bolt/v1/states/handlers.hpp"
 #include "communication/bolt/v1/value.hpp"
 #include "utils/cast.hpp"
 #include "utils/likely.hpp"
@@ -30,8 +31,8 @@ namespace memgraph::communication::bolt {
  */
 template <typename TSession>
 State StateErrorRun(TSession &session, State state) {
-  Marker marker;
-  Signature signature;
+  Marker marker{};
+  Signature signature{};
   if (!session.decoder_.ReadMessageHeader(&signature, &marker)) {
     spdlog::trace("Missing header data!");
     return State::Close;
@@ -45,54 +46,49 @@ State StateErrorRun(TSession &session, State state) {
   // Clear the data buffer if it has any leftover data.
   session.encoder_buffer_.Clear();
 
-  if ((session.version_.major == 1 && signature == Signature::AckFailure) || signature == Signature::Reset) {
-    if (signature == Signature::AckFailure) {
-      spdlog::trace("AckFailure received");
-    } else {
-      spdlog::trace("Reset received");
-    }
+  if (session.version_.major == 1 && signature == Signature::AckFailure) {
+    spdlog::trace("AckFailure received");
 
     if (!session.encoder_.MessageSuccess()) {
       spdlog::trace("Couldn't send success message!");
       return State::Close;
     }
 
-    if (signature == Signature::Reset) {
-      session.Abort();
-      return State::Idle;
-    }
-
     // We got AckFailure get back to right state.
     MG_ASSERT(state == State::Error, "Shouldn't happen");
     return State::Idle;
-  } else {
-    uint8_t value = utils::UnderlyingCast(marker);
-
-    // All bolt client messages have less than 15 parameters so if we receive
-    // anything than a TinyStruct it's an error.
-    if ((value & 0xF0) != utils::UnderlyingCast(Marker::TinyStruct)) {
-      spdlog::trace("Expected TinyStruct marker, but received 0x{:02X}!", value);
-      return State::Close;
-    }
-
-    // We need to clean up all parameters from this command.
-    value &= 0x0F;  // The length is stored in the lower nibble.
-    Value dv;
-    for (int i = 0; i < value; ++i) {
-      if (!session.decoder_.ReadValue(&dv)) {
-        spdlog::trace("Couldn't clean up parameter {} / {}!", i, value);
-        return State::Close;
-      }
-    }
-
-    // Ignore this message.
-    if (!session.encoder_.MessageIgnored()) {
-      spdlog::trace("Couldn't send ignored message!");
-      return State::Close;
-    }
-
-    // Cleanup done, command ignored, stay in error state.
-    return state;
   }
+  if (signature == Signature::Reset) {
+    spdlog::trace("Reset received");
+    return HandleReset(session, marker);
+  }
+
+  uint8_t value = utils::UnderlyingCast(marker);
+
+  // All bolt client messages have less than 15 parameters so if we receive
+  // anything than a TinyStruct it's an error.
+  if ((value & 0xF0U) != utils::UnderlyingCast(Marker::TinyStruct)) {
+    spdlog::trace("Expected TinyStruct marker, but received 0x{:02X}!", value);
+    return State::Close;
+  }
+
+  // We need to clean up all parameters from this command.
+  value &= 0x0FU;  // The length is stored in the lower nibble.
+  Value dv;
+  for (int i = 0; i < value; ++i) {
+    if (!session.decoder_.ReadValue(&dv)) {
+      spdlog::trace("Couldn't clean up parameter {} / {}!", i, value);
+      return State::Close;
+    }
+  }
+
+  // Ignore this message.
+  if (!session.encoder_.MessageIgnored()) {
+    spdlog::trace("Couldn't send ignored message!");
+    return State::Close;
+  }
+
+  // Cleanup done, command ignored, stay in error state.
+  return state;
 }
 }  // namespace memgraph::communication::bolt

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

@@ -74,7 +74,7 @@ State RunHandlerV4(Signature signature, TSession &session, State state, Marker m
     }
     case Signature::Route: {
       if constexpr (bolt_minor >= 3) {
-        if (signature == Signature::Route) return HandleRoute<TSession>(session);
+        if (signature == Signature::Route) return HandleRoute<TSession>(session, marker);
       } else {
         spdlog::trace("Supported only in bolt v4.3");
         return State::Close;

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

@@ -18,6 +18,7 @@
 
 #include "communication/bolt/v1/codes.hpp"
 #include "communication/bolt/v1/constants.hpp"
+#include "communication/bolt/v1/exceptions.hpp"
 #include "communication/bolt/v1/state.hpp"
 #include "communication/bolt/v1/value.hpp"
 #include "communication/exceptions.hpp"
@@ -136,7 +137,7 @@ template <bool is_pull, typename TSession>
 State HandlePullDiscardV1(TSession &session, const State state, const Marker marker) {
   const auto expected_marker = Marker::TinyStruct;
   if (marker != expected_marker) {
-    spdlog::trace("Expected {} marker, but received 0x{:02X}!", "TinyStruct", utils::UnderlyingCast(marker));
+    spdlog::trace("Expected TinyStruct marker, but received 0x{:02X}!", utils::UnderlyingCast(marker));
     return State::Close;
   }
 
@@ -157,7 +158,7 @@ template <bool is_pull, typename TSession>
 State HandlePullDiscardV4(TSession &session, const State state, const Marker marker) {
   const auto expected_marker = Marker::TinyStruct1;
   if (marker != expected_marker) {
-    spdlog::trace("Expected {} marker, but received 0x{:02X}!", "TinyStruct1", utils::UnderlyingCast(marker));
+    spdlog::trace("Expected TinyStruct1 marker, but received 0x{:02X}!", utils::UnderlyingCast(marker));
     return State::Close;
   }
 
@@ -216,7 +217,8 @@ State HandleRunV1(TSession &session, const State state, const Marker marker) {
                   session.version_.major == 1 ? "TinyStruct2" : "TinyStruct3", utils::UnderlyingCast(marker));
     return State::Close;
   }
-  Value query, params;
+  Value query;
+  Value params;
   if (!session.decoder_.ReadValue(&query, Value::Type::String)) {
     spdlog::trace("Couldn't read query string!");
     return State::Close;
@@ -234,10 +236,12 @@ template <typename TSession>
 State HandleRunV4(TSession &session, const State state, const Marker marker) {
   const auto expected_marker = Marker::TinyStruct3;
   if (marker != expected_marker) {
-    spdlog::trace("Expected {} marker, but received 0x{:02X}!", "TinyStruct3", utils::UnderlyingCast(marker));
+    spdlog::trace("Expected TinyStruct3 marker, but received 0x{:02X}!", utils::UnderlyingCast(marker));
     return State::Close;
   }
-  Value query, params, extra;
+  Value query;
+  Value params;
+  Value extra;
   if (!session.decoder_.ReadValue(&query, Value::Type::String)) {
     spdlog::trace("Couldn't read query string!");
     return State::Close;
@@ -292,9 +296,6 @@ State HandleReset(TSession &session, const Marker marker) {
     return State::Close;
   }
 
-  // Clear all pending data and send a success message.
-  session.encoder_buffer_.Clear();
-
   if (!session.encoder_.MessageSuccess()) {
     spdlog::trace("Couldn't send success message!");
     return State::Close;
@@ -403,12 +404,33 @@ State HandleGoodbye() {
 }
 
 template <typename TSession>
-State HandleRoute(TSession &session) {
-  // Route message is not implemented since it is neo4j specific, therefore we
-  // will receive it an inform user that there is no implementation.
+State HandleRoute(TSession &session, const Marker marker) {
+  // Route message is not implemented since it is Neo4j specific, therefore we will receive it and inform user that
+  // there is no implementation. Before that, we have to read out the fields from the buffer to leave it in a clean
+  // state.
+  if (marker != Marker::TinyStruct3) {
+    spdlog::trace("Expected TinyStruct3 marker, but received 0x{:02x}!", utils::UnderlyingCast(marker));
+    return State::Close;
+  }
+  Value routing;
+  if (!session.decoder_.ReadValue(&routing, Value::Type::Map)) {
+    spdlog::trace("Couldn't read routing field!");
+    return State::Close;
+  }
+
+  Value bookmarks;
+  if (!session.decoder_.ReadValue(&bookmarks, Value::Type::List)) {
+    spdlog::trace("Couldn't read bookmarks field!");
+    return State::Close;
+  }
+  Value db;
+  if (!session.decoder_.ReadValue(&db)) {
+    spdlog::trace("Couldn't read db field!");
+    return State::Close;
+  }
   session.encoder_buffer_.Clear();
   bool fail_sent =
-      session.encoder_.MessageFailure({{"code", 66}, {"message", "Route message not supported in Memgraph!"}});
+      session.encoder_.MessageFailure({{"code", "66"}, {"message", "Route message is not supported in Memgraph!"}});
   if (!fail_sent) {
     spdlog::trace("Couldn't send failure message!");
     return State::Close;

src/memgraph.cpp

@@ -164,8 +164,6 @@ DEFINE_string(bolt_server_name_for_init, "",
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_string(data_directory, "mg_data", "Path to directory in which to save all permanent data.");
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_HIDDEN_string(log_link_basename, "", "Basename used for symlink creation to the last log file.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_uint64(memory_warning_threshold, 1024,
               "Memory warning threshold, in MB. If Memgraph detects there is "
               "less available RAM it will log a warning. Set to 0 to "
@@ -349,7 +347,8 @@ DEFINE_VALIDATED_string(query_modules_directory, "",
                         });
 
 // Logging flags
-DEFINE_bool(also_log_to_stderr, false, "Log messages go to stderr in addition to logfiles");
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_HIDDEN_bool(also_log_to_stderr, false, "Log messages go to stderr in addition to logfiles");
 DEFINE_string(log_file, "", "Path to where the log should be stored.");
 
 namespace {
@@ -429,9 +428,9 @@ void AddLoggerSink(spdlog::sink_ptr new_sink) {
 }  // namespace
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_string(license_key, "", "License key for Memgraph Enterprise.");
+DEFINE_HIDDEN_string(license_key, "", "License key for Memgraph Enterprise.");
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_string(organization_name, "", "Organization name.");
+DEFINE_HIDDEN_string(organization_name, "", "Organization name.");
 
 /// Encapsulates Dbms and Interpreter that are passed through the network server
 /// and worker to the session.
@@ -901,6 +900,8 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
       // 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) {
+      throw memgraph::communication::bolt::ClientError(e.what());
     }
   }
 
@@ -1195,7 +1196,8 @@ int main(int argc, char **argv) {
                      .snapshot_retention_count = FLAGS_storage_snapshot_retention_count,
                      .wal_file_size_kibibytes = FLAGS_storage_wal_file_size_kib,
                      .wal_file_flush_every_n_tx = FLAGS_storage_wal_file_flush_every_n_tx,
-                     .snapshot_on_exit = FLAGS_storage_snapshot_on_exit},
+                     .snapshot_on_exit = FLAGS_storage_snapshot_on_exit,
+                     .restore_replicas_on_startup = true},
       .transaction = {.isolation_level = ParseIsolationLevel()}};
   if (FLAGS_storage_snapshot_interval_sec == 0) {
     if (FLAGS_storage_wal_enabled) {
@@ -1246,9 +1248,8 @@ int main(int argc, char **argv) {
     // the triggers
     auto storage_accessor = interpreter_context.db->Access();
     auto dba = memgraph::query::DbAccessor{&storage_accessor};
-    interpreter_context.trigger_store.RestoreTriggers(&interpreter_context.ast_cache, &dba,
-                                                      &interpreter_context.antlr_lock, interpreter_context.config.query,
-                                                      interpreter_context.auth_checker);
+    interpreter_context.trigger_store.RestoreTriggers(
+        &interpreter_context.ast_cache, &dba, interpreter_context.config.query, interpreter_context.auth_checker);
   }
 
   // As the Stream transformations are using modules, they have to be restored after the query modules are loaded.

src/mg_import_csv.cpp

@@ -170,7 +170,7 @@ enum class CsvParserState {
   EXPECT_DELIMITER,
 };
 
-bool SubstringStartsWith(const std::string_view &str, size_t pos, const std::string_view &what) {
+bool SubstringStartsWith(const std::string_view str, size_t pos, const std::string_view what) {
   return memgraph::utils::StartsWith(memgraph::utils::Substr(str, pos), what);
 }
 

src/query/CMakeLists.txt

@@ -82,7 +82,7 @@ add_custom_command(
     OUTPUT ${antlr_opencypher_generated_src} ${antlr_opencypher_generated_include}
     COMMAND ${CMAKE_COMMAND} -E make_directory ${opencypher_generated}
     COMMAND
-        java -jar ${CMAKE_SOURCE_DIR}/libs/antlr-4.9.2-complete.jar
+        java -jar ${CMAKE_SOURCE_DIR}/libs/antlr-4.10.1-complete.jar
             -Dlanguage=Cpp -visitor -package antlropencypher
             -o ${opencypher_generated}
             ${opencypher_lexer_grammar} ${opencypher_parser_grammar}

src/query/cypher_query_interpreter.cpp

@@ -12,7 +12,7 @@
 #include "query/cypher_query_interpreter.hpp"
 
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_HIDDEN_bool(query_cost_planner, true, "Use the cost-estimating query planner.");
+DEFINE_bool(query_cost_planner, true, "Use the cost-estimating query planner.");
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_VALIDATED_int32(query_plan_cache_ttl, 60, "Time to live for cached query plans, in seconds.",
                        FLAG_IN_RANGE(0, std::numeric_limits<int32_t>::max()));
@@ -21,8 +21,7 @@ namespace memgraph::query {
 CachedPlan::CachedPlan(std::unique_ptr<LogicalPlan> plan) : plan_(std::move(plan)) {}
 
 ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::string, storage::PropertyValue> &params,
-                       utils::SkipList<QueryCacheEntry> *cache, utils::SpinLock *antlr_lock,
-                       const InterpreterConfig::Query &query_config) {
+                       utils::SkipList<QueryCacheEntry> *cache, const InterpreterConfig::Query &query_config) {
   // Strip the query for caching purposes. The process of stripping a query
   // "normalizes" it by replacing any literals with new parameters. This
   // results in just the *structure* of the query being taken into account for
@@ -63,20 +62,16 @@ ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::stri
   };
 
   if (it == accessor.end()) {
-    {
-      std::unique_lock<utils::SpinLock> guard(*antlr_lock);
+    try {
+      parser = std::make_unique<frontend::opencypher::Parser>(stripped_query.query());
+    } catch (const SyntaxException &e) {
+      // There is a syntax exception in the stripped query. Re-run the parser
+      // on the original query to get an appropriate error messsage.
+      parser = std::make_unique<frontend::opencypher::Parser>(query_string);
 
-      try {
-        parser = std::make_unique<frontend::opencypher::Parser>(stripped_query.query());
-      } catch (const SyntaxException &e) {
-        // There is a syntax exception in the stripped query. Re-run the parser
-        // on the original query to get an appropriate error messsage.
-        parser = std::make_unique<frontend::opencypher::Parser>(query_string);
-
-        // If an exception was not thrown here, the stripper messed something
-        // up.
-        LOG_FATAL("The stripped query can't be parsed, but the original can.");
-      }
+      // If an exception was not thrown here, the stripper messed something
+      // up.
+      LOG_FATAL("The stripped query can't be parsed, but the original can.");
     }
 
     // Convert the ANTLR4 parse tree into an AST.

src/query/cypher_query_interpreter.hpp

@@ -111,8 +111,7 @@ struct ParsedQuery {
 };
 
 ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::string, storage::PropertyValue> &params,
-                       utils::SkipList<QueryCacheEntry> *cache, utils::SpinLock *antlr_lock,
-                       const InterpreterConfig::Query &query_config);
+                       utils::SkipList<QueryCacheEntry> *cache, const InterpreterConfig::Query &query_config);
 
 class SingleNodeLogicalPlan final : public LogicalPlan {
  public:

src/query/db_accessor.hpp

@@ -310,11 +310,11 @@ class DbAccessor final {
     return std::make_optional<VertexAccessor>(*value);
   }
 
-  storage::PropertyId NameToProperty(const std::string_view &name) { return accessor_->NameToProperty(name); }
+  storage::PropertyId NameToProperty(const std::string_view name) { return accessor_->NameToProperty(name); }
 
-  storage::LabelId NameToLabel(const std::string_view &name) { return accessor_->NameToLabel(name); }
+  storage::LabelId NameToLabel(const std::string_view name) { return accessor_->NameToLabel(name); }
 
-  storage::EdgeTypeId NameToEdgeType(const std::string_view &name) { return accessor_->NameToEdgeType(name); }
+  storage::EdgeTypeId NameToEdgeType(const std::string_view name) { return accessor_->NameToEdgeType(name); }
 
   const std::string &PropertyToName(storage::PropertyId prop) const { return accessor_->PropertyToName(prop); }
 
@@ -324,7 +324,7 @@ class DbAccessor final {
 
   void AdvanceCommand() { accessor_->AdvanceCommand(); }
 
-  utils::BasicResult<storage::ConstraintViolation, void> Commit() { return accessor_->Commit(); }
+  utils::BasicResult<storage::StorageDataManipulationError, void> Commit() { return accessor_->Commit(); }
 
   void Abort() { accessor_->Abort(); }
 

src/query/dump.cpp

@@ -46,7 +46,7 @@ const char *kInternalPropertyId = "__mg_id__";
 const char *kInternalVertexLabel = "__mg_vertex__";
 
 /// A helper function that escapes label, edge type and property names.
-std::string EscapeName(const std::string_view &value) {
+std::string EscapeName(const std::string_view value) {
   std::string out;
   out.reserve(value.size() + 2);
   out.append(1, '`');

src/query/exceptions.hpp

@@ -188,6 +188,12 @@ class FreeMemoryModificationInMulticommandTxException : public QueryException {
       : QueryException("Free memory query not allowed in multicommand transactions.") {}
 };
 
+class ShowConfigModificationInMulticommandTxException : public QueryException {
+ public:
+  ShowConfigModificationInMulticommandTxException()
+      : QueryException("Show config query not allowed in multicommand transactions.") {}
+};
+
 class TriggerModificationInMulticommandTxException : public QueryException {
  public:
   TriggerModificationInMulticommandTxException()
@@ -224,4 +230,11 @@ class VersionInfoInMulticommandTxException : public QueryException {
       : QueryException("Version info query not allowed in multicommand transactions.") {}
 };
 
+class ReplicationException : public utils::BasicException {
+ public:
+  using utils::BasicException::BasicException;
+  explicit ReplicationException(const std::string &message)
+      : utils::BasicException("Replication Exception: {} Check the status of the replicas using 'SHOW REPLICA' query.",
+                              message) {}
+};
 }  // namespace memgraph::query

src/query/frontend/ast/ast.lcp

@@ -2375,10 +2375,7 @@ cpp<#
    (port "Expression *" :initval "nullptr" :scope :public
              :slk-save #'slk-save-ast-pointer
              :slk-load (slk-load-ast-pointer "Expression"))
-   (sync_mode "SyncMode" :scope :public)
-   (timeout "Expression *" :initval "nullptr" :scope :public
-             :slk-save #'slk-save-ast-pointer
-             :slk-load (slk-load-ast-pointer "Expression")))
+   (sync_mode "SyncMode" :scope :public))
 
   (:public
     (lcp:define-enum action
@@ -2668,5 +2665,13 @@ cpp<#
   (:serialize (:slk))
   (:clone))
 
+  (lcp:define-class show-config-query (query) ()
+  (:public
+    #>cpp
+    DEFVISITABLE(QueryVisitor<void>);
+    cpp<#)
+  (:serialize (:slk))
+  (:clone))
+
 (lcp:pop-namespace) ;; namespace query
 (lcp:pop-namespace) ;; namespace memgraph

src/query/frontend/ast/ast_visitor.hpp

@@ -94,6 +94,7 @@ class StreamQuery;
 class SettingQuery;
 class VersionQuery;
 class Foreach;
+class ShowConfigQuery;
 
 using TreeCompositeVisitor = utils::CompositeVisitor<
     SingleQuery, CypherUnion, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator, AdditionOperator,
@@ -125,9 +126,9 @@ class ExpressionVisitor
           None, ParameterLookup, Identifier, PrimitiveLiteral, RegexMatch> {};
 
 template <class TResult>
-class QueryVisitor
-    : public utils::Visitor<TResult, CypherQuery, ExplainQuery, ProfileQuery, IndexQuery, AuthQuery, InfoQuery,
-                            ConstraintQuery, DumpQuery, ReplicationQuery, LockPathQuery, FreeMemoryQuery, TriggerQuery,
-                            IsolationLevelQuery, CreateSnapshotQuery, StreamQuery, SettingQuery, VersionQuery> {};
+class QueryVisitor : public utils::Visitor<TResult, CypherQuery, ExplainQuery, ProfileQuery, IndexQuery, AuthQuery,
+                                           InfoQuery, ConstraintQuery, DumpQuery, ReplicationQuery, LockPathQuery,
+                                           FreeMemoryQuery, TriggerQuery, IsolationLevelQuery, CreateSnapshotQuery,
+                                           StreamQuery, SettingQuery, VersionQuery, ShowConfigQuery> {};
 
 }  // namespace memgraph::query

src/query/frontend/ast/cypher_main_visitor.hpp

@@ -115,7 +115,7 @@ class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
     auto operators = ExtractOperators(all_children, allowed_operators);
 
     for (auto *expression : _expressions) {
-      expressions.push_back(expression->accept(this));
+      expressions.push_back(std::any_cast<Expression *>(expression->accept(this)));
     }
 
     Expression *first_operand = expressions[0];
@@ -131,7 +131,7 @@ class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
     DMG_ASSERT(_expression, "can't happen");
     auto operators = ExtractOperators(all_children, allowed_operators);
 
-    Expression *expression = _expression->accept(this);
+    Expression *expression = std::any_cast<Expression *>(_expression->accept(this));
     for (int i = (int)operators.size() - 1; i >= 0; --i) {
       expression = CreateUnaryOperatorByToken(operators[i], expression);
     }
@@ -849,6 +849,11 @@ class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
    */
   antlrcpp::Any visitForeach(MemgraphCypher::ForeachContext *ctx) override;
 
+  /**
+   * @return ShowConfigQuery*
+   */
+  antlrcpp::Any visitShowConfigQuery(MemgraphCypher::ShowConfigQueryContext *ctx) override;
+
  public:
   Query *query() { return query_; }
   const static std::string kAnonPrefix;

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

@@ -122,6 +122,7 @@ query : cypherQuery
       | streamQuery
       | settingQuery
       | versionQuery
+      | showConfigQuery
       ;
 
 authQuery : createRole
@@ -276,7 +277,6 @@ replicaName : symbolicName ;
 socketAddress : literal ;
 
 registerReplica : REGISTER REPLICA replicaName ( SYNC | ASYNC )
-                ( WITH TIMEOUT timeout=literal ) ?
                 TO socketAddress ;
 
 dropReplica : DROP REPLICA replicaName ;
@@ -373,4 +373,6 @@ showSetting : SHOW DATABASE SETTING settingName ;
 
 showSettings : SHOW DATABASE SETTINGS ;
 
+showConfigQuery : SHOW CONFIG ;
+
 versionQuery : SHOW VERSION ;

src/query/frontend/semantic/required_privileges.cpp

@@ -66,6 +66,8 @@ class PrivilegeExtractor : public QueryVisitor<void>, public HierarchicalTreeVis
 
   void Visit(FreeMemoryQuery &free_memory_query) override { AddPrivilege(AuthQuery::Privilege::FREE_MEMORY); }
 
+  void Visit(ShowConfigQuery & /*show_config_query*/) override { AddPrivilege(AuthQuery::Privilege::CONFIG); }
+
   void Visit(TriggerQuery &trigger_query) override { AddPrivilege(AuthQuery::Privilege::TRIGGER); }
 
   void Visit(StreamQuery &stream_query) override { AddPrivilege(AuthQuery::Privilege::STREAM); }

src/query/frontend/stripped_lexer_constants.hpp

@@ -204,6 +204,7 @@ const trie::Trie kKeywords = {"union",
                               "pulsar",
                               "service_url",
                               "version",
+                              "config",
                               "websocket"
                               "foreach"};
 

src/query/interpret/awesome_memgraph_functions.cpp

@@ -882,21 +882,36 @@ TypedValue Id(const TypedValue *args, int64_t nargs, const FunctionContext &ctx)
 }
 
 TypedValue ToString(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
-  FType<Or<Null, String, Number, Bool>>("toString", args, nargs);
+  FType<Or<Null, String, Number, Date, LocalTime, LocalDateTime, Duration, Bool>>("toString", args, nargs);
   const auto &arg = args[0];
   if (arg.IsNull()) {
     return TypedValue(ctx.memory);
-  } else if (arg.IsString()) {
+  }
+  if (arg.IsString()) {
     return TypedValue(arg, ctx.memory);
-  } else if (arg.IsInt()) {
+  }
+  if (arg.IsInt()) {
     // TODO: This is making a pointless copy of std::string, we may want to
     // use a different conversion to string
     return TypedValue(std::to_string(arg.ValueInt()), ctx.memory);
-  } else if (arg.IsDouble()) {
-    return TypedValue(std::to_string(arg.ValueDouble()), ctx.memory);
-  } else {
-    return TypedValue(arg.ValueBool() ? "true" : "false", ctx.memory);
   }
+  if (arg.IsDouble()) {
+    return TypedValue(std::to_string(arg.ValueDouble()), ctx.memory);
+  }
+  if (arg.IsDate()) {
+    return TypedValue(arg.ValueDate().ToString(), ctx.memory);
+  }
+  if (arg.IsLocalTime()) {
+    return TypedValue(arg.ValueLocalTime().ToString(), ctx.memory);
+  }
+  if (arg.IsLocalDateTime()) {
+    return TypedValue(arg.ValueLocalDateTime().ToString(), ctx.memory);
+  }
+  if (arg.IsDuration()) {
+    return TypedValue(arg.ValueDuration().ToString(), ctx.memory);
+  }
+
+  return TypedValue(arg.ValueBool() ? "true" : "false", ctx.memory);
 }
 
 TypedValue Timestamp(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
@@ -1309,6 +1324,8 @@ std::function<TypedValue(const TypedValue *, int64_t, const FunctionContext &ctx
   if (function_name == "LOCALDATETIME") return LocalDateTime;
   if (function_name == "DURATION") return Duration;
 
+  // TODO(gitbuda): Add sum function.
+
   const auto &maybe_found =
       procedure::FindFunction(procedure::gModuleRegistry, function_name, utils::NewDeleteResource());
 

src/query/interpret/eval.hpp

@@ -111,7 +111,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
   TypedValue Visit(IfOperator &if_operator) override {
     auto condition = if_operator.condition_->Accept(*this);
     if (condition.IsNull()) {
-      return if_operator.then_expression_->Accept(*this);
+      return if_operator.else_expression_->Accept(*this);
     }
     if (condition.type() != TypedValue::Type::Bool) {
       // At the moment IfOperator is used only in CASE construct.
@@ -716,7 +716,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
   }
 
   template <class TRecordAccessor>
-  storage::PropertyValue GetProperty(const TRecordAccessor &record_accessor, const std::string_view &name) {
+  storage::PropertyValue GetProperty(const TRecordAccessor &record_accessor, const std::string_view name) {
     auto maybe_prop = record_accessor.GetProperty(view_, dba_->NameToProperty(name));
     if (maybe_prop.HasError() && maybe_prop.GetError() == storage::Error::NONEXISTENT_OBJECT) {
       // This is a very nasty and temporary hack in order to make MERGE work.

src/query/interpreter.cpp

@@ -20,6 +20,7 @@
 #include <functional>
 #include <limits>
 #include <optional>
+#include <variant>
 
 #include "glue/communication.hpp"
 #include "memory/memory_control.hpp"
@@ -44,6 +45,7 @@
 #include "query/trigger.hpp"
 #include "query/typed_value.hpp"
 #include "storage/v2/property_value.hpp"
+#include "storage/v2/replication/enums.hpp"
 #include "utils/algorithm.hpp"
 #include "utils/csv_parsing.hpp"
 #include "utils/event_counter.hpp"
@@ -74,6 +76,9 @@ extern const Event TriggersCreated;
 
 namespace memgraph::query {
 
+template <typename>
+constexpr auto kAlwaysFalse = false;
+
 namespace {
 void UpdateTypeCount(const plan::ReadWriteTypeChecker::RWType type) {
   switch (type) {
@@ -160,7 +165,7 @@ class ReplQueryHandler final : public query::ReplicationQueryHandler {
 
   /// @throw QueryRuntimeException if an error ocurred.
   void RegisterReplica(const std::string &name, const std::string &socket_address,
-                       const ReplicationQuery::SyncMode sync_mode, const std::optional<double> timeout,
+                       const ReplicationQuery::SyncMode sync_mode,
                        const std::chrono::seconds replica_check_frequency) override {
     if (db_->GetReplicationRole() == storage::ReplicationRole::REPLICA) {
       // replica can't register another replica
@@ -183,9 +188,9 @@ class ReplQueryHandler final : public query::ReplicationQueryHandler {
         io::network::Endpoint::ParseSocketOrIpAddress(socket_address, query::kDefaultReplicationPort);
     if (maybe_ip_and_port) {
       auto [ip, port] = *maybe_ip_and_port;
-      auto ret = db_->RegisterReplica(
-          name, {std::move(ip), port}, repl_mode,
-          {.timeout = timeout, .replica_check_frequency = replica_check_frequency, .ssl = std::nullopt});
+      auto ret = db_->RegisterReplica(name, {std::move(ip), port}, repl_mode,
+                                      storage::replication::RegistrationMode::MUST_BE_INSTANTLY_VALID,
+                                      {.replica_check_frequency = replica_check_frequency, .ssl = std::nullopt});
       if (ret.HasError()) {
         throw QueryRuntimeException(fmt::format("Couldn't register replica '{}'!", name));
       }
@@ -228,9 +233,11 @@ class ReplQueryHandler final : public query::ReplicationQueryHandler {
           replica.sync_mode = ReplicationQuery::SyncMode::ASYNC;
           break;
       }
-      if (repl_info.timeout) {
-        replica.timeout = *repl_info.timeout;
-      }
+
+      replica.current_timestamp_of_replica = repl_info.timestamp_info.current_timestamp_of_replica;
+      replica.current_number_of_timestamp_behind_master =
+          repl_info.timestamp_info.current_number_of_timestamp_behind_master;
+
       switch (repl_info.state) {
         case storage::replication::ReplicaState::READY:
           replica.state = ReplicationQuery::ReplicaState::READY;
@@ -245,6 +252,7 @@ class ReplQueryHandler final : public query::ReplicationQueryHandler {
           replica.state = ReplicationQuery::ReplicaState::INVALID;
           break;
       }
+
       return replica;
     };
 
@@ -481,18 +489,11 @@ Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &
       const auto &name = repl_query->replica_name_;
       const auto &sync_mode = repl_query->sync_mode_;
       auto socket_address = repl_query->socket_address_->Accept(evaluator);
-      auto timeout = EvaluateOptionalExpression(repl_query->timeout_, &evaluator);
       const auto replica_check_frequency = interpreter_context->config.replication_replica_check_frequency;
-      std::optional<double> maybe_timeout;
-      if (timeout.IsDouble()) {
-        maybe_timeout = timeout.ValueDouble();
-      } else if (timeout.IsInt()) {
-        maybe_timeout = static_cast<double>(timeout.ValueInt());
-      }
+
       callback.fn = [handler = ReplQueryHandler{interpreter_context->db}, name, socket_address, sync_mode,
-                     maybe_timeout, replica_check_frequency]() mutable {
-        handler.RegisterReplica(name, std::string(socket_address.ValueString()), sync_mode, maybe_timeout,
-                                replica_check_frequency);
+                     replica_check_frequency]() mutable {
+        handler.RegisterReplica(name, std::string(socket_address.ValueString()), sync_mode, replica_check_frequency);
         return std::vector<std::vector<TypedValue>>();
       };
       notifications->emplace_back(SeverityLevel::INFO, NotificationCode::REGISTER_REPLICA,
@@ -512,7 +513,9 @@ Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &
     }
 
     case ReplicationQuery::Action::SHOW_REPLICAS: {
-      callback.header = {"name", "socket_address", "sync_mode", "timeout", "state"};
+      callback.header = {
+          "name", "socket_address", "sync_mode", "current_timestamp_of_replica", "number_of_timestamp_behind_master",
+          "state"};
       callback.fn = [handler = ReplQueryHandler{interpreter_context->db}, replica_nfields = callback.header.size()] {
         const auto &replicas = handler.ShowReplicas();
         auto typed_replicas = std::vector<std::vector<TypedValue>>{};
@@ -533,11 +536,9 @@ Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &
               break;
           }
 
-          if (replica.timeout) {
-            typed_replica.emplace_back(TypedValue(*replica.timeout));
-          } else {
-            typed_replica.emplace_back(TypedValue());
-          }
+          typed_replica.emplace_back(TypedValue(static_cast<int64_t>(replica.current_timestamp_of_replica)));
+          typed_replica.emplace_back(
+              TypedValue(static_cast<int64_t>(replica.current_number_of_timestamp_behind_master)));
 
           switch (replica.state) {
             case ReplicationQuery::ReplicaState::READY:
@@ -794,6 +795,37 @@ Callback HandleStreamQuery(StreamQuery *stream_query, const Parameters &paramete
   }
 }
 
+Callback HandleConfigQuery() {
+  Callback callback;
+  callback.header = {"name", "default_value", "current_value", "description"};
+
+  callback.fn = [] {
+    std::vector<GFLAGS_NAMESPACE::CommandLineFlagInfo> flags;
+    GetAllFlags(&flags);
+
+    std::vector<std::vector<TypedValue>> results;
+
+    for (const auto &flag : flags) {
+      if (flag.hidden ||
+          // These flags are not defined with gflags macros but are specified in config/flags.yaml
+          flag.name == "help" || flag.name == "help_xml" || flag.name == "version") {
+        continue;
+      }
+
+      std::vector<TypedValue> current_fields;
+      current_fields.emplace_back(flag.name);
+      current_fields.emplace_back(flag.default_value);
+      current_fields.emplace_back(flag.current_value);
+      current_fields.emplace_back(flag.description);
+
+      results.emplace_back(std::move(current_fields));
+    }
+
+    return results;
+  };
+  return callback;
+}
+
 Callback HandleSettingQuery(SettingQuery *setting_query, const Parameters &parameters, DbAccessor *db_accessor) {
   Frame frame(0);
   SymbolTable symbol_table;
@@ -1184,7 +1216,7 @@ PreparedQuery PrepareExplainQuery(ParsedQuery parsed_query, std::map<std::string
   // full query string) when given just the inner query to execute.
   ParsedQuery parsed_inner_query =
       ParseQuery(parsed_query.query_string.substr(kExplainQueryStart.size()), parsed_query.user_parameters,
-                 &interpreter_context->ast_cache, &interpreter_context->antlr_lock, interpreter_context->config.query);
+                 &interpreter_context->ast_cache, interpreter_context->config.query);
 
   auto *cypher_query = utils::Downcast<CypherQuery>(parsed_inner_query.query);
   MG_ASSERT(cypher_query, "Cypher grammar should not allow other queries in EXPLAIN");
@@ -1251,7 +1283,7 @@ PreparedQuery PrepareProfileQuery(ParsedQuery parsed_query, bool in_explicit_tra
   // full query string) when given just the inner query to execute.
   ParsedQuery parsed_inner_query =
       ParseQuery(parsed_query.query_string.substr(kProfileQueryStart.size()), parsed_query.user_parameters,
-                 &interpreter_context->ast_cache, &interpreter_context->antlr_lock, interpreter_context->config.query);
+                 &interpreter_context->ast_cache, interpreter_context->config.query);
 
   auto *cypher_query = utils::Downcast<CypherQuery>(parsed_inner_query.query);
   MG_ASSERT(cypher_query, "Cypher grammar should not allow other queries in PROFILE");
@@ -1355,23 +1387,34 @@ PreparedQuery PrepareIndexQuery(ParsedQuery parsed_query, bool in_explicit_trans
       handler = [interpreter_context, label, properties_stringified = std::move(properties_stringified),
                  label_name = index_query->label_.name, properties = std::move(properties),
                  invalidate_plan_cache = std::move(invalidate_plan_cache)](Notification &index_notification) {
-        if (properties.empty()) {
-          if (!interpreter_context->db->CreateIndex(label)) {
-            index_notification.code = NotificationCode::EXISTANT_INDEX;
-            index_notification.title =
-                fmt::format("Index on label {} on properties {} already exists.", label_name, properties_stringified);
-          }
-          EventCounter::IncrementCounter(EventCounter::LabelIndexCreated);
+        MG_ASSERT(properties.size() <= 1U);
+        auto maybe_index_error = properties.empty() ? interpreter_context->db->CreateIndex(label)
+                                                    : interpreter_context->db->CreateIndex(label, properties[0]);
+        utils::OnScopeExit invalidator(invalidate_plan_cache);
+
+        if (maybe_index_error.HasError()) {
+          const auto &error = maybe_index_error.GetError();
+          std::visit(
+              [&index_notification, &label_name, &properties_stringified]<typename T>(T &&) {
+                using ErrorType = std::remove_cvref_t<T>;
+                if constexpr (std::is_same_v<ErrorType, storage::ReplicationError>) {
+                  EventCounter::IncrementCounter(EventCounter::LabelIndexCreated);
+                  throw ReplicationException(
+                      fmt::format("At least one SYNC replica has not confirmed the creation of the index on label {} "
+                                  "on properties {}.",
+                                  label_name, properties_stringified));
+                } else if constexpr (std::is_same_v<ErrorType, storage::IndexDefinitionError>) {
+                  index_notification.code = NotificationCode::EXISTENT_INDEX;
+                  index_notification.title = fmt::format("Index on label {} on properties {} already exists.",
+                                                         label_name, properties_stringified);
+                } else {
+                  static_assert(kAlwaysFalse<T>, "Missing type from variant visitor");
+                }
+              },
+              error);
         } else {
-          MG_ASSERT(properties.size() == 1U);
-          if (!interpreter_context->db->CreateIndex(label, properties[0])) {
-            index_notification.code = NotificationCode::EXISTANT_INDEX;
-            index_notification.title =
-                fmt::format("Index on label {} on properties {} already exists.", label_name, properties_stringified);
-          }
-          EventCounter::IncrementCounter(EventCounter::LabelPropertyIndexCreated);
+          EventCounter::IncrementCounter(EventCounter::LabelIndexCreated);
         }
-        invalidate_plan_cache();
       };
       break;
     }
@@ -1382,21 +1425,31 @@ PreparedQuery PrepareIndexQuery(ParsedQuery parsed_query, bool in_explicit_trans
       handler = [interpreter_context, label, properties_stringified = std::move(properties_stringified),
                  label_name = index_query->label_.name, properties = std::move(properties),
                  invalidate_plan_cache = std::move(invalidate_plan_cache)](Notification &index_notification) {
-        if (properties.empty()) {
-          if (!interpreter_context->db->DropIndex(label)) {
-            index_notification.code = NotificationCode::NONEXISTANT_INDEX;
-            index_notification.title =
-                fmt::format("Index on label {} on properties {} doesn't exist.", label_name, properties_stringified);
-          }
-        } else {
-          MG_ASSERT(properties.size() == 1U);
-          if (!interpreter_context->db->DropIndex(label, properties[0])) {
-            index_notification.code = NotificationCode::NONEXISTANT_INDEX;
-            index_notification.title =
-                fmt::format("Index on label {} on properties {} doesn't exist.", label_name, properties_stringified);
-          }
+        MG_ASSERT(properties.size() <= 1U);
+        auto maybe_index_error = properties.empty() ? interpreter_context->db->DropIndex(label)
+                                                    : interpreter_context->db->DropIndex(label, properties[0]);
+        utils::OnScopeExit invalidator(invalidate_plan_cache);
+
+        if (maybe_index_error.HasError()) {
+          const auto &error = maybe_index_error.GetError();
+          std::visit(
+              [&index_notification, &label_name, &properties_stringified]<typename T>(T &&) {
+                using ErrorType = std::remove_cvref_t<T>;
+                if constexpr (std::is_same_v<ErrorType, storage::ReplicationError>) {
+                  throw ReplicationException(
+                      fmt::format("At least one SYNC replica has not confirmed the dropping of the index on label {} "
+                                  "on properties {}.",
+                                  label_name, properties_stringified));
+                } else if constexpr (std::is_same_v<ErrorType, storage::IndexDefinitionError>) {
+                  index_notification.code = NotificationCode::NONEXISTENT_INDEX;
+                  index_notification.title = fmt::format("Index on label {} on properties {} doesn't exist.",
+                                                         label_name, properties_stringified);
+                } else {
+                  static_assert(kAlwaysFalse<T>, "Missing type from variant visitor");
+                }
+              },
+              error);
         }
-        invalidate_plan_cache();
       };
       break;
     }
@@ -1524,6 +1577,28 @@ PreparedQuery PrepareFreeMemoryQuery(ParsedQuery parsed_query, const bool in_exp
       RWType::NONE};
 }
 
+PreparedQuery PrepareShowConfigQuery(ParsedQuery parsed_query, const bool in_explicit_transaction) {
+  if (in_explicit_transaction) {
+    throw ShowConfigModificationInMulticommandTxException();
+  }
+
+  auto callback = HandleConfigQuery();
+
+  return PreparedQuery{std::move(callback.header), std::move(parsed_query.required_privileges),
+                       [callback_fn = std::move(callback.fn), pull_plan = std::shared_ptr<PullPlanVector>{nullptr}](
+                           AnyStream *stream, std::optional<int> n) mutable -> std::optional<QueryHandlerResult> {
+                         if (!pull_plan) [[unlikely]] {
+                           pull_plan = std::make_shared<PullPlanVector>(callback_fn());
+                         }
+
+                         if (pull_plan->Pull(stream, n)) {
+                           return QueryHandlerResult::COMMIT;
+                         }
+                         return std::nullopt;
+                       },
+                       RWType::NONE};
+}
+
 TriggerEventType ToTriggerEventType(const TriggerQuery::EventType event_type) {
   switch (event_type) {
     case TriggerQuery::EventType::ANY:
@@ -1569,8 +1644,7 @@ Callback CreateTrigger(TriggerQuery *trigger_query,
         interpreter_context->trigger_store.AddTrigger(
             std::move(trigger_name), trigger_statement, user_parameters, ToTriggerEventType(event_type),
             before_commit ? TriggerPhase::BEFORE_COMMIT : TriggerPhase::AFTER_COMMIT, &interpreter_context->ast_cache,
-            dba, &interpreter_context->antlr_lock, interpreter_context->config.query, std::move(owner),
-            interpreter_context->auth_checker);
+            dba, interpreter_context->config.query, std::move(owner), interpreter_context->auth_checker);
         return {};
       }};
 }
@@ -1924,21 +1998,37 @@ PreparedQuery PrepareConstraintQuery(ParsedQuery parsed_query, bool in_explicit_
           handler = [interpreter_context, label, label_name = constraint_query->constraint_.label.name,
                      properties_stringified = std::move(properties_stringified),
                      properties = std::move(properties)](Notification &constraint_notification) {
-            auto res = interpreter_context->db->CreateExistenceConstraint(label, properties[0]);
-            if (res.HasError()) {
-              auto violation = res.GetError();
-              auto label_name = interpreter_context->db->LabelToName(violation.label);
-              MG_ASSERT(violation.properties.size() == 1U);
-              auto property_name = interpreter_context->db->PropertyToName(*violation.properties.begin());
-              throw QueryRuntimeException(
-                  "Unable to create existence constraint :{}({}), because an "
-                  "existing node violates it.",
-                  label_name, property_name);
-            }
-            if (res.HasValue() && !res.GetValue()) {
-              constraint_notification.code = NotificationCode::EXISTANT_CONSTRAINT;
-              constraint_notification.title = fmt::format(
-                  "Constraint EXISTS on label {} on properties {} already exists.", label_name, properties_stringified);
+            auto maybe_constraint_error = interpreter_context->db->CreateExistenceConstraint(label, properties[0]);
+
+            if (maybe_constraint_error.HasError()) {
+              const auto &error = maybe_constraint_error.GetError();
+              std::visit(
+                  [&interpreter_context, &label_name, &properties_stringified,
+                   &constraint_notification]<typename T>(T &&arg) {
+                    using ErrorType = std::remove_cvref_t<T>;
+                    if constexpr (std::is_same_v<ErrorType, storage::ConstraintViolation>) {
+                      auto &violation = arg;
+                      MG_ASSERT(violation.properties.size() == 1U);
+                      auto property_name = interpreter_context->db->PropertyToName(*violation.properties.begin());
+                      throw QueryRuntimeException(
+                          "Unable to create existence constraint :{}({}), because an "
+                          "existing node violates it.",
+                          label_name, property_name);
+                    } else if constexpr (std::is_same_v<ErrorType, storage::ConstraintDefinitionError>) {
+                      constraint_notification.code = NotificationCode::EXISTENT_CONSTRAINT;
+                      constraint_notification.title =
+                          fmt::format("Constraint EXISTS on label {} on properties {} already exists.", label_name,
+                                      properties_stringified);
+                    } else if constexpr (std::is_same_v<ErrorType, storage::ReplicationError>) {
+                      throw ReplicationException(
+                          "At least one SYNC replica has not confirmed the creation of the EXISTS constraint on label "
+                          "{} on properties {}.",
+                          label_name, properties_stringified);
+                    } else {
+                      static_assert(kAlwaysFalse<T>, "Missing type from variant visitor");
+                    }
+                  },
+                  error);
             }
           };
           break;
@@ -1956,21 +2046,35 @@ PreparedQuery PrepareConstraintQuery(ParsedQuery parsed_query, bool in_explicit_
           handler = [interpreter_context, label, label_name = constraint_query->constraint_.label.name,
                      properties_stringified = std::move(properties_stringified),
                      property_set = std::move(property_set)](Notification &constraint_notification) {
-            auto res = interpreter_context->db->CreateUniqueConstraint(label, property_set);
-            if (res.HasError()) {
-              auto violation = res.GetError();
-              auto label_name = interpreter_context->db->LabelToName(violation.label);
-              std::stringstream property_names_stream;
-              utils::PrintIterable(property_names_stream, violation.properties, ", ",
-                                   [&interpreter_context](auto &stream, const auto &prop) {
-                                     stream << interpreter_context->db->PropertyToName(prop);
-                                   });
-              throw QueryRuntimeException(
-                  "Unable to create unique constraint :{}({}), because an "
-                  "existing node violates it.",
-                  label_name, property_names_stream.str());
+            auto maybe_constraint_error = interpreter_context->db->CreateUniqueConstraint(label, property_set);
+            if (maybe_constraint_error.HasError()) {
+              const auto &error = maybe_constraint_error.GetError();
+              std::visit(
+                  [&interpreter_context, &label_name, &properties_stringified]<typename T>(T &&arg) {
+                    using ErrorType = std::remove_cvref_t<T>;
+                    if constexpr (std::is_same_v<ErrorType, storage::ConstraintViolation>) {
+                      auto &violation = arg;
+                      auto violation_label_name = interpreter_context->db->LabelToName(violation.label);
+                      std::stringstream property_names_stream;
+                      utils::PrintIterable(property_names_stream, violation.properties, ", ",
+                                           [&interpreter_context](auto &stream, const auto &prop) {
+                                             stream << interpreter_context->db->PropertyToName(prop);
+                                           });
+                      throw QueryRuntimeException(
+                          "Unable to create unique constraint :{}({}), because an "
+                          "existing node violates it.",
+                          violation_label_name, property_names_stream.str());
+                    } else if constexpr (std::is_same_v<ErrorType, storage::ReplicationError>) {
+                      throw ReplicationException(fmt::format(
+                          "At least one SYNC replica has not confirmed the creation of the UNIQUE constraint: {}({}).",
+                          label_name, properties_stringified));
+                    } else {
+                      static_assert(kAlwaysFalse<T>, "Missing type from variant visitor");
+                    }
+                  },
+                  error);
             }
-            switch (res.GetValue()) {
+            switch (maybe_constraint_error.GetValue()) {
               case storage::UniqueConstraints::CreationStatus::EMPTY_PROPERTIES:
                 throw SyntaxException(
                     "At least one property must be used for unique "
@@ -1981,7 +2085,7 @@ PreparedQuery PrepareConstraintQuery(ParsedQuery parsed_query, bool in_explicit_
                     "for unique constraints is exceeded.",
                     storage::kUniqueConstraintsMaxProperties);
               case storage::UniqueConstraints::CreationStatus::ALREADY_EXISTS:
-                constraint_notification.code = NotificationCode::EXISTANT_CONSTRAINT;
+                constraint_notification.code = NotificationCode::EXISTENT_CONSTRAINT;
                 constraint_notification.title =
                     fmt::format("Constraint UNIQUE on label {} on properties {} already exists.", label_name,
                                 properties_stringified);
@@ -2009,10 +2113,27 @@ PreparedQuery PrepareConstraintQuery(ParsedQuery parsed_query, bool in_explicit_
           handler = [interpreter_context, label, label_name = constraint_query->constraint_.label.name,
                      properties_stringified = std::move(properties_stringified),
                      properties = std::move(properties)](Notification &constraint_notification) {
-            if (!interpreter_context->db->DropExistenceConstraint(label, properties[0])) {
-              constraint_notification.code = NotificationCode::NONEXISTANT_CONSTRAINT;
-              constraint_notification.title = fmt::format(
-                  "Constraint EXISTS on label {} on properties {} doesn't exist.", label_name, properties_stringified);
+            auto maybe_constraint_error = interpreter_context->db->DropExistenceConstraint(label, properties[0]);
+            if (maybe_constraint_error.HasError()) {
+              const auto &error = maybe_constraint_error.GetError();
+              std::visit(
+                  [&label_name, &properties_stringified, &constraint_notification]<typename T>(T &&) {
+                    using ErrorType = std::remove_cvref_t<T>;
+                    if constexpr (std::is_same_v<ErrorType, storage::ConstraintDefinitionError>) {
+                      constraint_notification.code = NotificationCode::NONEXISTENT_CONSTRAINT;
+                      constraint_notification.title =
+                          fmt::format("Constraint EXISTS on label {} on properties {} doesn't exist.", label_name,
+                                      properties_stringified);
+                    } else if constexpr (std::is_same_v<ErrorType, storage::ReplicationError>) {
+                      throw ReplicationException(
+                          fmt::format("At least one SYNC replica has not confirmed the dropping of the EXISTS "
+                                      "constraint  on label {} on properties {}.",
+                                      label_name, properties_stringified));
+                    } else {
+                      static_assert(kAlwaysFalse<T>, "Missing type from variant visitor");
+                    }
+                  },
+                  error);
             }
             return std::vector<std::vector<TypedValue>>();
           };
@@ -2031,7 +2152,24 @@ PreparedQuery PrepareConstraintQuery(ParsedQuery parsed_query, bool in_explicit_
           handler = [interpreter_context, label, label_name = constraint_query->constraint_.label.name,
                      properties_stringified = std::move(properties_stringified),
                      property_set = std::move(property_set)](Notification &constraint_notification) {
-            auto res = interpreter_context->db->DropUniqueConstraint(label, property_set);
+            auto maybe_constraint_error = interpreter_context->db->DropUniqueConstraint(label, property_set);
+            if (maybe_constraint_error.HasError()) {
+              const auto &error = maybe_constraint_error.GetError();
+              std::visit(
+                  [&label_name, &properties_stringified]<typename T>(T &&) {
+                    using ErrorType = std::remove_cvref_t<T>;
+                    if constexpr (std::is_same_v<ErrorType, storage::ReplicationError>) {
+                      throw ReplicationException(
+                          fmt::format("At least one SYNC replica has not confirmed the dropping of the UNIQUE "
+                                      "constraint on label {} on properties {}.",
+                                      label_name, properties_stringified));
+                    } else {
+                      static_assert(kAlwaysFalse<T>, "Missing type from variant visitor");
+                    }
+                  },
+                  error);
+            }
+            const auto &res = maybe_constraint_error.GetValue();
             switch (res) {
               case storage::UniqueConstraints::DeletionStatus::EMPTY_PROPERTIES:
                 throw SyntaxException(
@@ -2045,7 +2183,7 @@ PreparedQuery PrepareConstraintQuery(ParsedQuery parsed_query, bool in_explicit_
                     storage::kUniqueConstraintsMaxProperties);
                 break;
               case storage::UniqueConstraints::DeletionStatus::NOT_FOUND:
-                constraint_notification.code = NotificationCode::NONEXISTANT_CONSTRAINT;
+                constraint_notification.code = NotificationCode::NONEXISTENT_CONSTRAINT;
                 constraint_notification.title =
                     fmt::format("Constraint UNIQUE on label {} on properties {} doesn't exist.", label_name,
                                 properties_stringified);
@@ -2126,8 +2264,8 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
     query_execution->summary["cost_estimate"] = 0.0;
 
     utils::Timer parsing_timer;
-    ParsedQuery parsed_query = ParseQuery(query_string, params, &interpreter_context_->ast_cache,
-                                          &interpreter_context_->antlr_lock, interpreter_context_->config.query);
+    ParsedQuery parsed_query =
+        ParseQuery(query_string, params, &interpreter_context_->ast_cache, interpreter_context_->config.query);
     query_execution->summary["parsing_time"] = parsing_timer.Elapsed().count();
 
     // Some queries require an active transaction in order to be prepared.
@@ -2185,6 +2323,8 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
                                             &*execution_db_accessor_);
     } else if (utils::Downcast<FreeMemoryQuery>(parsed_query.query)) {
       prepared_query = PrepareFreeMemoryQuery(std::move(parsed_query), in_explicit_transaction_, interpreter_context_);
+    } else if (utils::Downcast<ShowConfigQuery>(parsed_query.query)) {
+      prepared_query = PrepareShowConfigQuery(std::move(parsed_query), in_explicit_transaction_);
     } else if (utils::Downcast<TriggerQuery>(parsed_query.query)) {
       prepared_query =
           PrepareTriggerQuery(std::move(parsed_query), in_explicit_transaction_, &query_execution->notifications,
@@ -2261,28 +2401,41 @@ void RunTriggersIndividually(const utils::SkipList<Trigger> &triggers, Interpret
       continue;
     }
 
-    auto maybe_constraint_violation = db_accessor.Commit();
-    if (maybe_constraint_violation.HasError()) {
-      const auto &constraint_violation = maybe_constraint_violation.GetError();
-      switch (constraint_violation.type) {
-        case storage::ConstraintViolation::Type::EXISTENCE: {
-          const auto &label_name = db_accessor.LabelToName(constraint_violation.label);
-          MG_ASSERT(constraint_violation.properties.size() == 1U);
-          const auto &property_name = db_accessor.PropertyToName(*constraint_violation.properties.begin());
-          spdlog::warn("Trigger '{}' failed to commit due to existence constraint violation on :{}({})", trigger.Name(),
-                       label_name, property_name);
-          break;
-        }
-        case storage::ConstraintViolation::Type::UNIQUE: {
-          const auto &label_name = db_accessor.LabelToName(constraint_violation.label);
-          std::stringstream property_names_stream;
-          utils::PrintIterable(property_names_stream, constraint_violation.properties, ", ",
-                               [&](auto &stream, const auto &prop) { stream << db_accessor.PropertyToName(prop); });
-          spdlog::warn("Trigger '{}' failed to commit due to unique constraint violation on :{}({})", trigger.Name(),
-                       label_name, property_names_stream.str());
-          break;
-        }
-      }
+    auto maybe_commit_error = db_accessor.Commit();
+    if (maybe_commit_error.HasError()) {
+      const auto &error = maybe_commit_error.GetError();
+
+      std::visit(
+          [&trigger, &db_accessor]<typename T>(T &&arg) {
+            using ErrorType = std::remove_cvref_t<T>;
+            if constexpr (std::is_same_v<ErrorType, storage::ReplicationError>) {
+              spdlog::warn("At least one SYNC replica has not confirmed execution of the trigger '{}'.",
+                           trigger.Name());
+            } else if constexpr (std::is_same_v<ErrorType, storage::ConstraintViolation>) {
+              const auto &constraint_violation = arg;
+              switch (constraint_violation.type) {
+                case storage::ConstraintViolation::Type::EXISTENCE: {
+                  const auto &label_name = db_accessor.LabelToName(constraint_violation.label);
+                  MG_ASSERT(constraint_violation.properties.size() == 1U);
+                  const auto &property_name = db_accessor.PropertyToName(*constraint_violation.properties.begin());
+                  spdlog::warn("Trigger '{}' failed to commit due to existence constraint violation on: {}({}) ",
+                               trigger.Name(), label_name, property_name);
+                }
+                case storage::ConstraintViolation::Type::UNIQUE: {
+                  const auto &label_name = db_accessor.LabelToName(constraint_violation.label);
+                  std::stringstream property_names_stream;
+                  utils::PrintIterable(
+                      property_names_stream, constraint_violation.properties, ", ",
+                      [&](auto &stream, const auto &prop) { stream << db_accessor.PropertyToName(prop); });
+                  spdlog::warn("Trigger '{}' failed to commit due to unique constraint violation on :{}({})",
+                               trigger.Name(), label_name, property_names_stream.str());
+                }
+              }
+            } else {
+              static_assert(kAlwaysFalse<T>, "Missing type from variant visitor");
+            }
+          },
+          error);
     }
   }
 }
@@ -2323,32 +2476,45 @@ void Interpreter::Commit() {
     db_accessor_.reset();
     trigger_context_collector_.reset();
   };
+  utils::OnScopeExit members_reseter(reset_necessary_members);
 
-  auto maybe_constraint_violation = db_accessor_->Commit();
-  if (maybe_constraint_violation.HasError()) {
-    const auto &constraint_violation = maybe_constraint_violation.GetError();
-    switch (constraint_violation.type) {
-      case storage::ConstraintViolation::Type::EXISTENCE: {
-        auto label_name = execution_db_accessor_->LabelToName(constraint_violation.label);
-        MG_ASSERT(constraint_violation.properties.size() == 1U);
-        auto property_name = execution_db_accessor_->PropertyToName(*constraint_violation.properties.begin());
-        reset_necessary_members();
-        throw QueryException("Unable to commit due to existence constraint violation on :{}({})", label_name,
-                             property_name);
-        break;
-      }
-      case storage::ConstraintViolation::Type::UNIQUE: {
-        auto label_name = execution_db_accessor_->LabelToName(constraint_violation.label);
-        std::stringstream property_names_stream;
-        utils::PrintIterable(
-            property_names_stream, constraint_violation.properties, ", ",
-            [this](auto &stream, const auto &prop) { stream << execution_db_accessor_->PropertyToName(prop); });
-        reset_necessary_members();
-        throw QueryException("Unable to commit due to unique constraint violation on :{}({})", label_name,
-                             property_names_stream.str());
-        break;
-      }
-    }
+  auto commit_confirmed_by_all_sync_repplicas = true;
+
+  auto maybe_commit_error = db_accessor_->Commit();
+  if (maybe_commit_error.HasError()) {
+    const auto &error = maybe_commit_error.GetError();
+
+    std::visit(
+        [&execution_db_accessor = execution_db_accessor_,
+         &commit_confirmed_by_all_sync_repplicas]<typename T>(T &&arg) {
+          using ErrorType = std::remove_cvref_t<T>;
+          if constexpr (std::is_same_v<ErrorType, storage::ReplicationError>) {
+            commit_confirmed_by_all_sync_repplicas = false;
+          } else if constexpr (std::is_same_v<ErrorType, storage::ConstraintViolation>) {
+            const auto &constraint_violation = arg;
+            auto &label_name = execution_db_accessor->LabelToName(constraint_violation.label);
+            switch (constraint_violation.type) {
+              case storage::ConstraintViolation::Type::EXISTENCE: {
+                MG_ASSERT(constraint_violation.properties.size() == 1U);
+                auto &property_name = execution_db_accessor->PropertyToName(*constraint_violation.properties.begin());
+                throw QueryException("Unable to commit due to existence constraint violation on :{}({})", label_name,
+                                     property_name);
+              }
+              case storage::ConstraintViolation::Type::UNIQUE: {
+                std::stringstream property_names_stream;
+                utils::PrintIterable(property_names_stream, constraint_violation.properties, ", ",
+                                     [&execution_db_accessor](auto &stream, const auto &prop) {
+                                       stream << execution_db_accessor->PropertyToName(prop);
+                                     });
+                throw QueryException("Unable to commit due to unique constraint violation on :{}({})", label_name,
+                                     property_names_stream.str());
+              }
+            }
+          } else {
+            static_assert(kAlwaysFalse<T>, "Missing type from variant visitor");
+          }
+        },
+        error);
   }
 
   // The ordered execution of after commit triggers is heavily depending on the exclusiveness of db_accessor_->Commit():
@@ -2367,9 +2533,10 @@ void Interpreter::Commit() {
         });
   }
 
-  reset_necessary_members();
-
   SPDLOG_DEBUG("Finished committing the transaction");
+  if (!commit_confirmed_by_all_sync_repplicas) {
+    throw ReplicationException("At least one SYNC replica has not confirmed committing last transaction.");
+  }
 }
 
 void Interpreter::AdvanceCommand() {

src/query/interpreter.hpp

@@ -127,6 +127,8 @@ class ReplicationQueryHandler {
     std::string socket_address;
     ReplicationQuery::SyncMode sync_mode;
     std::optional<double> timeout;
+    uint64_t current_timestamp_of_replica;
+    uint64_t current_number_of_timestamp_behind_master;
     ReplicationQuery::ReplicaState state;
   };
 
@@ -138,7 +140,7 @@ class ReplicationQueryHandler {
 
   /// @throw QueryRuntimeException if an error ocurred.
   virtual void RegisterReplica(const std::string &name, const std::string &socket_address,
-                               const ReplicationQuery::SyncMode sync_mode, const std::optional<double> timeout,
+                               ReplicationQuery::SyncMode sync_mode,
                                const std::chrono::seconds replica_check_frequency) = 0;
 
   /// @throw QueryRuntimeException if an error ocurred.
@@ -171,13 +173,6 @@ struct InterpreterContext {
 
   storage::Storage *db;
 
-  // ANTLR has singleton instance that is shared between threads. It is
-  // protected by locks inside of ANTLR. Unfortunately, they are not protected
-  // in a very good way. Once we have ANTLR version without race conditions we
-  // can remove this lock. This will probably never happen since ANTLR
-  // developers introduce more bugs in each version. Fortunately, we have
-  // cache so this lock probably won't impact performance much...
-  utils::SpinLock antlr_lock;
   std::optional<double> tsc_frequency{utils::GetTSCFrequency()};
   std::atomic<bool> is_shutting_down{false};
 

src/query/metadata.cpp

@@ -52,15 +52,15 @@ constexpr std::string_view GetCodeString(const NotificationCode code) {
       return "DropStream"sv;
     case NotificationCode::DROP_TRIGGER:
       return "DropTrigger"sv;
-    case NotificationCode::EXISTANT_CONSTRAINT:
+    case NotificationCode::EXISTENT_CONSTRAINT:
       return "ConstraintAlreadyExists"sv;
-    case NotificationCode::EXISTANT_INDEX:
+    case NotificationCode::EXISTENT_INDEX:
       return "IndexAlreadyExists"sv;
     case NotificationCode::LOAD_CSV_TIP:
       return "LoadCSVTip"sv;
-    case NotificationCode::NONEXISTANT_INDEX:
+    case NotificationCode::NONEXISTENT_INDEX:
       return "IndexDoesNotExist"sv;
-    case NotificationCode::NONEXISTANT_CONSTRAINT:
+    case NotificationCode::NONEXISTENT_CONSTRAINT:
       return "ConstraintDoesNotExist"sv;
     case NotificationCode::REGISTER_REPLICA:
       return "RegisterReplica"sv;
@@ -114,4 +114,4 @@ std::string ExecutionStatsKeyToString(const ExecutionStats::Key key) {
   }
 }
 
-}  // namespace memgraph::query
+}  // namespace memgraph::query

src/query/metadata.hpp

@@ -34,11 +34,11 @@ enum class NotificationCode : uint8_t {
   DROP_REPLICA,
   DROP_STREAM,
   DROP_TRIGGER,
-  EXISTANT_INDEX,
-  EXISTANT_CONSTRAINT,
+  EXISTENT_INDEX,
+  EXISTENT_CONSTRAINT,
   LOAD_CSV_TIP,
-  NONEXISTANT_INDEX,
-  NONEXISTANT_CONSTRAINT,
+  NONEXISTENT_INDEX,
+  NONEXISTENT_CONSTRAINT,
   REPLICA_PORT_WARNING,
   REGISTER_REPLICA,
   SET_REPLICA,

src/query/plan/operator.cpp

@@ -2600,13 +2600,13 @@ namespace {
  * when there are */
 TypedValue DefaultAggregationOpValue(const Aggregate::Element &element, utils::MemoryResource *memory) {
   switch (element.op) {
-    case Aggregation::Op::COUNT:
-      return TypedValue(0, memory);
-    case Aggregation::Op::SUM:
     case Aggregation::Op::MIN:
     case Aggregation::Op::MAX:
     case Aggregation::Op::AVG:
       return TypedValue(memory);
+    case Aggregation::Op::COUNT:
+    case Aggregation::Op::SUM:
+      return TypedValue(0, memory);
     case Aggregation::Op::COLLECT_LIST:
       return TypedValue(TypedValue::TVector(memory));
     case Aggregation::Op::COLLECT_MAP:
@@ -2628,9 +2628,7 @@ class AggregateCursor : public Cursor {
       pulled_all_input_ = true;
       aggregation_it_ = aggregation_.begin();
 
-      // in case there is no input and no group_bys we need to return true
-      // just this once
-      if (aggregation_.empty() && self_.group_by_.empty()) {
+      if (aggregation_.empty()) {
         auto *pull_memory = context.evaluation_context.memory;
         // place default aggregation values on the frame
         for (const auto &elem : self_.aggregations_)
@@ -3697,7 +3695,7 @@ std::unordered_map<std::string, int64_t> CallProcedure::GetAndResetCounters() {
 
 namespace {
 
-void CallCustomProcedure(const std::string_view &fully_qualified_procedure_name, const mgp_proc &proc,
+void CallCustomProcedure(const std::string_view fully_qualified_procedure_name, const mgp_proc &proc,
                          const std::vector<Expression *> &args, mgp_graph &graph, ExpressionEvaluator *evaluator,
                          utils::MemoryResource *memory, std::optional<size_t> memory_limit, mgp_result *result) {
   static_assert(std::uses_allocator_v<mgp_value, utils::Allocator<mgp_value>>,

src/query/plan/rewrite/index_lookup.cpp

@@ -13,11 +13,12 @@
 
 #include "utils/flag_validation.hpp"
 
-DEFINE_VALIDATED_HIDDEN_int64(query_vertex_count_to_expand_existing, 10,
-                              "Maximum count of indexed vertices which provoke "
-                              "indexed lookup and then expand to existing, instead of "
-                              "a regular expand. Default is 10, to turn off use -1.",
-                              FLAG_IN_RANGE(-1, std::numeric_limits<std::int64_t>::max()));
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_int64(query_vertex_count_to_expand_existing, 10,
+                       "Maximum count of indexed vertices which provoke "
+                       "indexed lookup and then expand to existing, instead of "
+                       "a regular expand. Default is 10, to turn off use -1.",
+                       FLAG_IN_RANGE(-1, std::numeric_limits<std::int64_t>::max()));
 
 namespace memgraph::query::plan::impl {
 

src/query/plan/variable_start_planner.cpp

@@ -17,8 +17,9 @@
 #include "utils/flag_validation.hpp"
 #include "utils/logging.hpp"
 
-DEFINE_VALIDATED_HIDDEN_uint64(query_max_plans, 1000U, "Maximum number of generated plans for a query.",
-                               FLAG_IN_RANGE(1, std::numeric_limits<std::uint64_t>::max()));
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_VALIDATED_uint64(query_max_plans, 1000U, "Maximum number of generated plans for a query.",
+                        FLAG_IN_RANGE(1, std::numeric_limits<std::uint64_t>::max()));
 
 namespace memgraph::query::plan::impl {
 

src/query/procedure/mg_procedure_impl.cpp

@@ -2796,3 +2796,29 @@ mgp_error mgp_module_add_function(mgp_module *module, const char *name, mgp_func
       },
       result);
 }
+
+mgp_error mgp_log(const mgp_log_level log_level, const char *output) {
+  return WrapExceptions([=] {
+    switch (log_level) {
+      case mgp_log_level::MGP_LOG_LEVEL_TRACE:
+        spdlog::trace(output);
+        return;
+      case mgp_log_level::MGP_LOG_LEVEL_DEBUG:
+        spdlog::debug(output);
+        return;
+      case mgp_log_level::MGP_LOG_LEVEL_INFO:
+        spdlog::info(output);
+        return;
+      case mgp_log_level::MGP_LOG_LEVEL_WARN:
+        spdlog::warn(output);
+        return;
+      case mgp_log_level::MGP_LOG_LEVEL_ERROR:
+        spdlog::error(output);
+        return;
+      case mgp_log_level::MGP_LOG_LEVEL_CRITICAL:
+        spdlog::critical(output);
+        return;
+    }
+    throw std::invalid_argument{fmt::format("Invalid log level: {}", log_level)};
+  });
+}

src/query/procedure/module.cpp

@@ -1054,7 +1054,7 @@ std::unique_ptr<Module> LoadModuleFromFile(const std::filesystem::path &path) {
 
 }  // namespace
 
-bool ModuleRegistry::RegisterModule(const std::string_view &name, std::unique_ptr<Module> module) {
+bool ModuleRegistry::RegisterModule(const std::string_view name, std::unique_ptr<Module> module) {
   MG_ASSERT(!name.empty(), "Module name cannot be empty");
   MG_ASSERT(module, "Tried to register an invalid module");
   if (modules_.find(name) != modules_.end()) {
@@ -1163,7 +1163,7 @@ void ModuleRegistry::UnloadAndLoadModulesFromDirectories() {
   }
 }
 
-ModulePtr ModuleRegistry::GetModuleNamed(const std::string_view &name) const {
+ModulePtr ModuleRegistry::GetModuleNamed(const std::string_view name) const {
   std::shared_lock<utils::RWLock> guard(lock_);
   auto found_it = modules_.find(name);
   if (found_it == modules_.end()) return nullptr;

src/query/procedure/module.hpp

@@ -77,7 +77,7 @@ class ModuleRegistry final {
   mutable utils::RWLock lock_{utils::RWLock::Priority::WRITE};
   std::unique_ptr<utils::MemoryResource> shared_{std::make_unique<utils::ResourceWithOutOfMemoryException>()};
 
-  bool RegisterModule(const std::string_view &name, std::unique_ptr<Module> module);
+  bool RegisterModule(std::string_view name, std::unique_ptr<Module> module);
 
   void DoUnloadAllModules();
 
@@ -105,7 +105,7 @@ class ModuleRegistry final {
   ///
   /// Return true if the module was loaded or reloaded successfully, false
   /// otherwise.
-  bool LoadOrReloadModuleFromName(const std::string_view name);
+  bool LoadOrReloadModuleFromName(std::string_view name);
 
   /// Atomically unload all modules and then load all possible modules from the
   /// set directories.
@@ -115,7 +115,7 @@ class ModuleRegistry final {
 
   /// Find a module with given name or return nullptr.
   /// Takes a read lock.
-  ModulePtr GetModuleNamed(const std::string_view &name) const;
+  ModulePtr GetModuleNamed(std::string_view name) const;
 
   /// Remove all loaded (non-builtin) modules.
   /// Takes a write lock.
@@ -175,7 +175,7 @@ extern ModuleRegistry gModuleRegistry;
 /// inside this function. ModulePtr must be kept alive to make sure it won't be
 /// unloaded.
 std::optional<std::pair<procedure::ModulePtr, const mgp_proc *>> FindProcedure(
-    const ModuleRegistry &module_registry, const std::string_view fully_qualified_procedure_name,
+    const ModuleRegistry &module_registry, std::string_view fully_qualified_procedure_name,
     utils::MemoryResource *memory);
 
 /// Return the ModulePtr and `mgp_trans *` of the found transformation after resolving
@@ -183,7 +183,7 @@ std::optional<std::pair<procedure::ModulePtr, const mgp_proc *>> FindProcedure(
 /// inside this function. ModulePtr must be kept alive to make sure it won't be
 /// unloaded.
 std::optional<std::pair<procedure::ModulePtr, const mgp_trans *>> FindTransformation(
-    const ModuleRegistry &module_registry, const std::string_view fully_qualified_transformation_name,
+    const ModuleRegistry &module_registry, std::string_view fully_qualified_transformation_name,
     utils::MemoryResource *memory);
 
 /// Return the ModulePtr and `mgp_func *` of the found function after resolving
@@ -191,7 +191,7 @@ std::optional<std::pair<procedure::ModulePtr, const mgp_trans *>> FindTransforma
 /// std::nullopt is returned. `memory` is used for temporary allocations
 /// inside this function. ModulePtr must be kept alive to make sure it won't be unloaded.
 std::optional<std::pair<procedure::ModulePtr, const mgp_func *>> FindFunction(
-    const ModuleRegistry &module_registry, const std::string_view fully_qualified_function_name,
+    const ModuleRegistry &module_registry, std::string_view fully_qualified_function_name,
     utils::MemoryResource *memory);
 
 template <typename T>

src/query/procedure/py_module.cpp

@@ -2052,6 +2052,81 @@ PyObject *PyPathMakeWithStart(PyTypeObject *type, PyObject *vertex) {
   return py_path;
 }
 
+// clang-format off
+struct PyLogger {
+  PyObject_HEAD
+};
+// clang-format on
+
+PyObject *PyLoggerLog(PyLogger *self, PyObject *args, const mgp_log_level level) {
+  MG_ASSERT(self);
+  const char *out = nullptr;
+  if (!PyArg_ParseTuple(args, "s", &out)) {
+    return nullptr;
+  }
+
+  if (RaiseExceptionFromErrorCode(mgp_log(level, out))) {
+    return nullptr;
+  }
+
+  Py_RETURN_NONE;
+}
+
+PyObject *PyLoggerLogInfo(PyLogger *self, PyObject *args) {
+  return PyLoggerLog(self, args, mgp_log_level::MGP_LOG_LEVEL_INFO);
+}
+
+PyObject *PyLoggerLogWarning(PyLogger *self, PyObject *args) {
+  return PyLoggerLog(self, args, mgp_log_level::MGP_LOG_LEVEL_WARN);
+}
+
+PyObject *PyLoggerLogError(PyLogger *self, PyObject *args) {
+  return PyLoggerLog(self, args, mgp_log_level::MGP_LOG_LEVEL_ERROR);
+}
+
+PyObject *PyLoggerLogCritical(PyLogger *self, PyObject *args) {
+  return PyLoggerLog(self, args, mgp_log_level::MGP_LOG_LEVEL_CRITICAL);
+}
+
+PyObject *PyLoggerLogTrace(PyLogger *self, PyObject *args) {
+  return PyLoggerLog(self, args, mgp_log_level::MGP_LOG_LEVEL_TRACE);
+}
+
+PyObject *PyLoggerLogDebug(PyLogger *self, PyObject *args) {
+  return PyLoggerLog(self, args, mgp_log_level::MGP_LOG_LEVEL_DEBUG);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+static PyMethodDef PyLoggerMethods[] = {
+    {"__reduce__", reinterpret_cast<PyCFunction>(DisallowPickleAndCopy), METH_NOARGS, "__reduce__ is not supported"},
+    {"info", reinterpret_cast<PyCFunction>(PyLoggerLogInfo), METH_VARARGS,
+     "Logs a message with level INFO on this logger."},
+    {"warning", reinterpret_cast<PyCFunction>(PyLoggerLogWarning), METH_VARARGS,
+     "Logs a message with level WARNNING on this logger."},
+    {"error", reinterpret_cast<PyCFunction>(PyLoggerLogError), METH_VARARGS,
+     "Logs a message with level ERROR on this logger."},
+    {"critical", reinterpret_cast<PyCFunction>(PyLoggerLogCritical), METH_VARARGS,
+     "Logs a message with level CRITICAL on this logger."},
+    {"trace", reinterpret_cast<PyCFunction>(PyLoggerLogTrace), METH_VARARGS,
+     "Logs a message with level TRACE on this logger."},
+    {"debug", reinterpret_cast<PyCFunction>(PyLoggerLogDebug), METH_VARARGS,
+     "Logs a message with level DEBUG on this logger."},
+    {nullptr},
+};
+
+// clang-format off
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+static PyTypeObject PyLoggerType = {
+    PyVarObject_HEAD_INIT(nullptr, 0)
+    .tp_name = "_mgp.Logger",
+    .tp_basicsize = sizeof(PyLogger),
+    // NOLINTNEXTLINE(hicpp-signed-bitwise)
+    .tp_flags = Py_TPFLAGS_DEFAULT,
+    .tp_doc = "Logging API.",
+    .tp_methods = PyLoggerMethods,
+};
+// clang-format on
+
 struct PyMgpError {
   const char *name;
   PyObject *&exception;
@@ -2103,6 +2178,7 @@ PyObject *PyInitMgpModule() {
   if (!register_type(&PyCypherTypeType, "Type")) return nullptr;
   if (!register_type(&PyMessagesType, "Messages")) return nullptr;
   if (!register_type(&PyMessageType, "Message")) return nullptr;
+  if (!register_type(&PyLoggerType, "Logger")) return nullptr;
 
   std::array py_mgp_errors{
       PyMgpError{"_mgp.UnknownError", gMgpUnknownError, PyExc_RuntimeError, nullptr},
@@ -2169,8 +2245,14 @@ auto WithMgpModule(mgp_module *module_def, const TFun &fun) {
             "import a new module. Is some other thread also importing Python "
             "modules?");
   auto *py_query_module = MakePyQueryModule(module_def);
+
   MG_ASSERT(py_query_module);
   MG_ASSERT(py_mgp.SetAttr("_MODULE", py_query_module));
+
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-cstyle-cast)
+  auto *py_logger = reinterpret_cast<PyObject *>(PyObject_New(PyLogger, &PyLoggerType));
+  MG_ASSERT(py_mgp.SetAttr("_LOGGER", py_logger));
+
   auto ret = fun();
   auto maybe_exc = py::FetchError();
   MG_ASSERT(py_mgp.SetAttr("_MODULE", Py_None));

src/query/stream/streams.cpp

@@ -619,10 +619,10 @@ void Streams::Drop(const std::string &stream_name) {
   // no running Test function for this consumer, therefore it can be erased.
   std::visit([&](const auto &stream_data) { stream_data.stream_source->Lock(); }, it->second);
 
-  locked_streams->erase(it);
   if (!storage_.Delete(stream_name)) {
     throw StreamsException("Couldn't delete stream '{}' from persistent store!", stream_name);
   }
+  locked_streams->erase(it);
 
   // TODO(antaljanosbenjamin) Release the transformation
 }

src/query/stream/streams.hpp

@@ -188,7 +188,7 @@ class Streams final {
   void Persist(StreamStatus<TStream> &&status) {
     const std::string stream_name = status.name;
     if (!storage_.Put(stream_name, nlohmann::json(std::move(status)).dump())) {
-      throw StreamsException{"Couldn't persist steam data for stream '{}'", stream_name};
+      throw StreamsException{"Couldn't persist stream data for stream '{}'", stream_name};
     }
   }
 

src/query/trigger.cpp

@@ -153,10 +153,10 @@ std::vector<std::pair<Identifier, TriggerIdentifierTag>> GetPredefinedIdentifier
 Trigger::Trigger(std::string name, const std::string &query,
                  const std::map<std::string, storage::PropertyValue> &user_parameters,
                  const TriggerEventType event_type, utils::SkipList<QueryCacheEntry> *query_cache,
-                 DbAccessor *db_accessor, utils::SpinLock *antlr_lock, const InterpreterConfig::Query &query_config,
+                 DbAccessor *db_accessor, const InterpreterConfig::Query &query_config,
                  std::optional<std::string> owner, const query::AuthChecker *auth_checker)
     : name_{std::move(name)},
-      parsed_statements_{ParseQuery(query, user_parameters, query_cache, antlr_lock, query_config)},
+      parsed_statements_{ParseQuery(query, user_parameters, query_cache, query_config)},
       event_type_{event_type},
       owner_{std::move(owner)} {
   // We check immediately if the query is valid by trying to create a plan.
@@ -257,7 +257,7 @@ inline constexpr uint64_t kVersion{2};
 TriggerStore::TriggerStore(std::filesystem::path directory) : storage_{std::move(directory)} {}
 
 void TriggerStore::RestoreTriggers(utils::SkipList<QueryCacheEntry> *query_cache, DbAccessor *db_accessor,
-                                   utils::SpinLock *antlr_lock, const InterpreterConfig::Query &query_config,
+                                   const InterpreterConfig::Query &query_config,
                                    const query::AuthChecker *auth_checker) {
   MG_ASSERT(before_commit_triggers_.size() == 0 && after_commit_triggers_.size() == 0,
             "Cannot restore trigger when some triggers already exist!");
@@ -317,8 +317,8 @@ void TriggerStore::RestoreTriggers(utils::SkipList<QueryCacheEntry> *query_cache
 
     std::optional<Trigger> trigger;
     try {
-      trigger.emplace(trigger_name, statement, user_parameters, event_type, query_cache, db_accessor, antlr_lock,
-                      query_config, std::move(owner), auth_checker);
+      trigger.emplace(trigger_name, statement, user_parameters, event_type, query_cache, db_accessor, query_config,
+                      std::move(owner), auth_checker);
     } catch (const utils::BasicException &e) {
       spdlog::warn("Failed to create trigger '{}' because: {}", trigger_name, e.what());
       continue;
@@ -336,8 +336,8 @@ void TriggerStore::AddTrigger(std::string name, const std::string &query,
                               const std::map<std::string, storage::PropertyValue> &user_parameters,
                               TriggerEventType event_type, TriggerPhase phase,
                               utils::SkipList<QueryCacheEntry> *query_cache, DbAccessor *db_accessor,
-                              utils::SpinLock *antlr_lock, const InterpreterConfig::Query &query_config,
-                              std::optional<std::string> owner, const query::AuthChecker *auth_checker) {
+                              const InterpreterConfig::Query &query_config, std::optional<std::string> owner,
+                              const query::AuthChecker *auth_checker) {
   std::unique_lock store_guard{store_lock_};
   if (storage_.Get(name)) {
     throw utils::BasicException("Trigger with the same name already exists.");
@@ -345,8 +345,8 @@ void TriggerStore::AddTrigger(std::string name, const std::string &query,
 
   std::optional<Trigger> trigger;
   try {
-    trigger.emplace(std::move(name), query, user_parameters, event_type, query_cache, db_accessor, antlr_lock,
-                    query_config, std::move(owner), auth_checker);
+    trigger.emplace(std::move(name), query, user_parameters, event_type, query_cache, db_accessor, query_config,
+                    std::move(owner), auth_checker);
   } catch (const utils::BasicException &e) {
     const auto identifiers = GetPredefinedIdentifiers(event_type);
     std::stringstream identifier_names_stream;

src/query/trigger.hpp

@@ -34,7 +34,7 @@ namespace memgraph::query {
 struct Trigger {
   explicit Trigger(std::string name, const std::string &query,
                    const std::map<std::string, storage::PropertyValue> &user_parameters, TriggerEventType event_type,
-                   utils::SkipList<QueryCacheEntry> *query_cache, DbAccessor *db_accessor, utils::SpinLock *antlr_lock,
+                   utils::SkipList<QueryCacheEntry> *query_cache, DbAccessor *db_accessor,
                    const InterpreterConfig::Query &query_config, std::optional<std::string> owner,
                    const query::AuthChecker *auth_checker);
 
@@ -81,14 +81,13 @@ struct TriggerStore {
   explicit TriggerStore(std::filesystem::path directory);
 
   void RestoreTriggers(utils::SkipList<QueryCacheEntry> *query_cache, DbAccessor *db_accessor,
-                       utils::SpinLock *antlr_lock, const InterpreterConfig::Query &query_config,
-                       const query::AuthChecker *auth_checker);
+                       const InterpreterConfig::Query &query_config, const query::AuthChecker *auth_checker);
 
   void AddTrigger(std::string name, const std::string &query,
                   const std::map<std::string, storage::PropertyValue> &user_parameters, TriggerEventType event_type,
                   TriggerPhase phase, utils::SkipList<QueryCacheEntry> *query_cache, DbAccessor *db_accessor,
-                  utils::SpinLock *antlr_lock, const InterpreterConfig::Query &query_config,
-                  std::optional<std::string> owner, const query::AuthChecker *auth_checker);
+                  const InterpreterConfig::Query &query_config, std::optional<std::string> owner,
+                  const query::AuthChecker *auth_checker);
 
   void DropTrigger(const std::string &name);
 

src/query/typed_value.cpp

@@ -407,7 +407,7 @@ DEFINE_TYPED_VALUE_COPY_ASSIGNMENT(int, Int, int_v)
 DEFINE_TYPED_VALUE_COPY_ASSIGNMENT(bool, Bool, bool_v)
 DEFINE_TYPED_VALUE_COPY_ASSIGNMENT(int64_t, Int, int_v)
 DEFINE_TYPED_VALUE_COPY_ASSIGNMENT(double, Double, double_v)
-DEFINE_TYPED_VALUE_COPY_ASSIGNMENT(const std::string_view &, String, string_v)
+DEFINE_TYPED_VALUE_COPY_ASSIGNMENT(const std::string_view, String, string_v)
 DEFINE_TYPED_VALUE_COPY_ASSIGNMENT(const TypedValue::TVector &, List, list_v)
 
 TypedValue &TypedValue::operator=(const std::vector<TypedValue> &other) {

src/query/typed_value.hpp

@@ -185,7 +185,7 @@ class TypedValue {
     new (&string_v) TString(value, memory_);
   }
 
-  explicit TypedValue(const std::string_view &value, utils::MemoryResource *memory = utils::NewDeleteResource())
+  explicit TypedValue(const std::string_view value, utils::MemoryResource *memory = utils::NewDeleteResource())
       : memory_(memory), type_(Type::String) {
     new (&string_v) TString(value, memory_);
   }
@@ -420,7 +420,7 @@ class TypedValue {
   TypedValue &operator=(bool);
   TypedValue &operator=(int64_t);
   TypedValue &operator=(double);
-  TypedValue &operator=(const std::string_view &);
+  TypedValue &operator=(std::string_view);
   TypedValue &operator=(const TVector &);
   TypedValue &operator=(const std::vector<TypedValue> &);
   TypedValue &operator=(const TMap &);

src/slk/serialization.hpp

@@ -166,7 +166,7 @@ inline void Save(const char *obj, Builder *builder) {
   builder->Save(reinterpret_cast<const uint8_t *>(obj), size);
 }
 
-inline void Save(const std::string_view &obj, Builder *builder) {
+inline void Save(const std::string_view obj, Builder *builder) {
   uint64_t size = obj.size();
   Save(size, builder);
   builder->Save(reinterpret_cast<const uint8_t *>(obj.data()), size);

src/storage/v2/CMakeLists.txt

@@ -13,7 +13,6 @@ set(storage_v2_src_files
     storage.cpp)
 
 ##### Replication #####
-
 define_add_lcp(add_lcp_storage lcp_storage_cpp_files generated_lcp_storage_files)
 
 add_lcp_storage(replication/rpc.lcp SLK_SERIALIZE)
@@ -26,10 +25,10 @@ set(storage_v2_src_files
     replication/replication_server.cpp
     replication/serialization.cpp
     replication/slk.cpp
+    replication/replication_persistence_helper.cpp
     ${lcp_storage_cpp_files})
 
 #######################
-
 find_package(gflags REQUIRED)
 find_package(Threads REQUIRED)
 

src/storage/v2/config.hpp

@@ -49,7 +49,7 @@ struct Config {
     uint64_t wal_file_flush_every_n_tx{100000};
 
     bool snapshot_on_exit{false};
-
+    bool restore_replicas_on_startup{false};
   } durability;
 
   struct Transaction {

src/storage/v2/durability/paths.hpp

@@ -22,6 +22,7 @@ static const std::string kSnapshotDirectory{"snapshots"};
 static const std::string kWalDirectory{"wal"};
 static const std::string kBackupDirectory{".backup"};
 static const std::string kLockFile{".lock"};
+static const std::string kReplicationDirectory{"replication"};
 
 // This is the prefix used for Snapshot and WAL filenames. It is a timestamp
 // format that equals to: YYYYmmddHHMMSSffffff

src/storage/v2/durability/serialization.cpp

@@ -27,7 +27,7 @@ void WriteSize(Encoder *encoder, uint64_t size) {
 }
 }  // namespace
 
-void Encoder::Initialize(const std::filesystem::path &path, const std::string_view &magic, uint64_t version) {
+void Encoder::Initialize(const std::filesystem::path &path, const std::string_view magic, uint64_t version) {
   file_.Open(path, utils::OutputFile::Mode::OVERWRITE_EXISTING);
   Write(reinterpret_cast<const uint8_t *>(magic.data()), magic.size());
   auto version_encoded = utils::HostToLittleEndian(version);
@@ -73,7 +73,7 @@ void Encoder::WriteDouble(double value) {
   Write(reinterpret_cast<const uint8_t *>(&value_uint), sizeof(value_uint));
 }
 
-void Encoder::WriteString(const std::string_view &value) {
+void Encoder::WriteString(const std::string_view value) {
   WriteMarker(Marker::TYPE_STRING);
   WriteSize(this, value.size());
   Write(reinterpret_cast<const uint8_t *>(value.data()), value.size());

src/storage/v2/durability/serialization.hpp

@@ -34,14 +34,14 @@ class BaseEncoder {
   virtual void WriteBool(bool value) = 0;
   virtual void WriteUint(uint64_t value) = 0;
   virtual void WriteDouble(double value) = 0;
-  virtual void WriteString(const std::string_view &value) = 0;
+  virtual void WriteString(std::string_view value) = 0;
   virtual void WritePropertyValue(const PropertyValue &value) = 0;
 };
 
 /// Encoder that is used to generate a snapshot/WAL.
 class Encoder final : public BaseEncoder {
  public:
-  void Initialize(const std::filesystem::path &path, const std::string_view &magic, uint64_t version);
+  void Initialize(const std::filesystem::path &path, std::string_view magic, uint64_t version);
 
   void OpenExisting(const std::filesystem::path &path);
 
@@ -54,7 +54,7 @@ class Encoder final : public BaseEncoder {
   void WriteBool(bool value) override;
   void WriteUint(uint64_t value) override;
   void WriteDouble(double value) override;
-  void WriteString(const std::string_view &value) override;
+  void WriteString(std::string_view value) override;
   void WritePropertyValue(const PropertyValue &value) override;
 
   uint64_t GetPosition();

src/storage/v2/name_id_mapper.hpp

@@ -29,8 +29,8 @@ class NameIdMapper final {
     bool operator<(const MapNameToId &other) { return name < other.name; }
     bool operator==(const MapNameToId &other) { return name == other.name; }
 
-    bool operator<(const std::string_view &other) { return name < other; }
-    bool operator==(const std::string_view &other) { return name == other; }
+    bool operator<(const std::string_view other) const { return name < other; }
+    bool operator==(const std::string_view other) const { return name == other; }
   };
 
   struct MapIdToName {
@@ -46,7 +46,7 @@ class NameIdMapper final {
 
  public:
   /// @throw std::bad_alloc if unable to insert a new mapping
-  uint64_t NameToId(const std::string_view &name) {
+  uint64_t NameToId(const std::string_view name) {
     auto name_to_id_acc = name_to_id_.access();
     auto found = name_to_id_acc.find(name);
     uint64_t id;

src/storage/v2/replication/config.hpp

@@ -10,12 +10,13 @@
 // licenses/APL.txt.
 
 #pragma once
+
+#include <chrono>
 #include <optional>
 #include <string>
 
 namespace memgraph::storage::replication {
 struct ReplicationClientConfig {
-  std::optional<double> timeout;
   // The default delay between main checking/pinging replicas is 1s because
   // that seems like a reasonable timeframe in which main should notice a
   // replica is down.
@@ -24,6 +25,8 @@ struct ReplicationClientConfig {
   struct SSL {
     std::string key_file = "";
     std::string cert_file = "";
+
+    friend bool operator==(const SSL &, const SSL &) = default;
   };
 
   std::optional<SSL> ssl;

src/storage/v2/replication/enums.hpp

@@ -16,4 +16,6 @@ namespace memgraph::storage::replication {
 enum class ReplicationMode : std::uint8_t { SYNC, ASYNC };
 
 enum class ReplicaState : std::uint8_t { READY, REPLICATING, RECOVERY, INVALID };
+
+enum class RegistrationMode : std::uint8_t { MUST_BE_INSTANTLY_VALID, CAN_BE_INVALID };
 }  // namespace memgraph::storage::replication

src/storage/v2/replication/replication_client.cpp

@@ -43,11 +43,6 @@ Storage::ReplicationClient::ReplicationClient(std::string name, Storage *storage
   rpc_client_.emplace(endpoint, &*rpc_context_);
   TryInitializeClientSync();
 
-  if (config.timeout && replica_state_ != replication::ReplicaState::INVALID) {
-    timeout_.emplace(*config.timeout);
-    timeout_dispatcher_.emplace();
-  }
-
   // Help the user to get the most accurate replica state possible.
   if (config.replica_check_frequency > std::chrono::seconds(0)) {
     replica_checker_.Run("Replica Checker", config.replica_check_frequency, [&] { FrequentCheck(); });
@@ -227,58 +222,24 @@ void Storage::ReplicationClient::IfStreamingTransaction(const std::function<void
   }
 }
 
-void Storage::ReplicationClient::FinalizeTransactionReplication() {
+bool Storage::ReplicationClient::FinalizeTransactionReplication() {
   // We can only check the state because it guarantees to be only
   // valid during a single transaction replication (if the assumption
   // that this and other transaction replication functions can only be
   // called from a one thread stands)
   if (replica_state_ != replication::ReplicaState::REPLICATING) {
-    return;
+    return false;
   }
 
   if (mode_ == replication::ReplicationMode::ASYNC) {
-    thread_pool_.AddTask([this] { this->FinalizeTransactionReplicationInternal(); });
-  } else if (timeout_) {
-    MG_ASSERT(mode_ == replication::ReplicationMode::SYNC, "Only SYNC replica can have a timeout.");
-    MG_ASSERT(timeout_dispatcher_, "Timeout thread is missing");
-    timeout_dispatcher_->WaitForTaskToFinish();
-
-    timeout_dispatcher_->active = true;
-    thread_pool_.AddTask([&, this] {
-      this->FinalizeTransactionReplicationInternal();
-      std::unique_lock main_guard(timeout_dispatcher_->main_lock);
-      // TimerThread can finish waiting for timeout
-      timeout_dispatcher_->active = false;
-      // Notify the main thread
-      timeout_dispatcher_->main_cv.notify_one();
-    });
-
-    timeout_dispatcher_->StartTimeoutTask(*timeout_);
-
-    // Wait until one of the threads notifies us that they finished executing
-    // Both threads should first set the active flag to false
-    {
-      std::unique_lock main_guard(timeout_dispatcher_->main_lock);
-      timeout_dispatcher_->main_cv.wait(main_guard, [&] { return !timeout_dispatcher_->active.load(); });
-    }
-
-    // TODO (antonio2368): Document and/or polish SEMI-SYNC to ASYNC fallback.
-    if (replica_state_ == replication::ReplicaState::REPLICATING) {
-      mode_ = replication::ReplicationMode::ASYNC;
-      timeout_.reset();
-      // This can only happen if we timeouted so we are sure that
-      // Timeout task finished
-      // We need to delete timeout dispatcher AFTER the replication
-      // finished because it tries to acquire the timeout lock
-      // and acces the `active` variable`
-      thread_pool_.AddTask([this] { timeout_dispatcher_.reset(); });
-    }
+    thread_pool_.AddTask([this] { static_cast<void>(this->FinalizeTransactionReplicationInternal()); });
+    return true;
   } else {
-    FinalizeTransactionReplicationInternal();
+    return FinalizeTransactionReplicationInternal();
   }
 }
 
-void Storage::ReplicationClient::FinalizeTransactionReplicationInternal() {
+bool Storage::ReplicationClient::FinalizeTransactionReplicationInternal() {
   MG_ASSERT(replica_stream_, "Missing stream for transaction deltas");
   try {
     auto response = replica_stream_->Finalize();
@@ -289,6 +250,7 @@ void Storage::ReplicationClient::FinalizeTransactionReplicationInternal() {
       thread_pool_.AddTask([&, this] { this->RecoverReplica(response.current_commit_timestamp); });
     } else {
       replica_state_.store(replication::ReplicaState::READY);
+      return true;
     }
   } catch (const rpc::RpcFailedException &) {
     replica_stream_.reset();
@@ -298,6 +260,7 @@ void Storage::ReplicationClient::FinalizeTransactionReplicationInternal() {
     }
     HandleRpcFailure();
   }
+  return false;
 }
 
 void Storage::ReplicationClient::RecoverReplica(uint64_t replica_commit) {
@@ -537,30 +500,34 @@ std::vector<Storage::ReplicationClient::RecoveryStep> Storage::ReplicationClient
   return recovery_steps;
 }
 
-////// TimeoutDispatcher //////
-void Storage::ReplicationClient::TimeoutDispatcher::WaitForTaskToFinish() {
-  // Wait for the previous timeout task to finish
-  std::unique_lock main_guard(main_lock);
-  main_cv.wait(main_guard, [&] { return finished; });
-}
+Storage::TimestampInfo Storage::ReplicationClient::GetTimestampInfo() {
+  Storage::TimestampInfo info;
+  info.current_timestamp_of_replica = 0;
+  info.current_number_of_timestamp_behind_master = 0;
 
-void Storage::ReplicationClient::TimeoutDispatcher::StartTimeoutTask(const double timeout) {
-  timeout_pool.AddTask([timeout, this] {
-    finished = false;
-    using std::chrono::steady_clock;
-    const auto timeout_duration =
-        std::chrono::duration_cast<steady_clock::duration>(std::chrono::duration<double>(timeout));
-    const auto end_time = steady_clock::now() + timeout_duration;
-    while (active && (steady_clock::now() < end_time)) {
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+  try {
+    auto stream{rpc_client_->Stream<replication::TimestampRpc>()};
+    const auto response = stream.AwaitResponse();
+    const auto is_success = response.success;
+    if (!is_success) {
+      replica_state_.store(replication::ReplicaState::INVALID);
+      HandleRpcFailure();
     }
+    auto main_time_stamp = storage_->last_commit_timestamp_.load();
+    info.current_timestamp_of_replica = response.current_commit_timestamp;
+    info.current_number_of_timestamp_behind_master = response.current_commit_timestamp - main_time_stamp;
+  } catch (const rpc::RpcFailedException &) {
+    {
+      std::unique_lock client_guard(client_lock_);
+      replica_state_.store(replication::ReplicaState::INVALID);
+    }
+    HandleRpcFailure();  // mutex already unlocked, if the new enqueued task dispatches immediately it probably won't
+                         // block
+  }
 
-    std::unique_lock main_guard(main_lock);
-    finished = true;
-    active = false;
-    main_cv.notify_one();
-  });
+  return info;
 }
+
 ////// ReplicaStream //////
 Storage::ReplicationClient::ReplicaStream::ReplicaStream(ReplicationClient *self,
                                                          const uint64_t previous_commit_timestamp,

src/storage/v2/replication/replication_client.hpp

@@ -103,7 +103,8 @@ class Storage::ReplicationClient {
   // StartTransactionReplication, stream is created.
   void IfStreamingTransaction(const std::function<void(ReplicaStream &handler)> &callback);
 
-  void FinalizeTransactionReplication();
+  // Return whether the transaction could be finalized on the replication client or not.
+  [[nodiscard]] bool FinalizeTransactionReplication();
 
   // Transfer the snapshot file.
   // @param path Path of the snapshot file.
@@ -120,12 +121,12 @@ class Storage::ReplicationClient {
 
   auto Mode() const { return mode_; }
 
-  auto Timeout() const { return timeout_; }
-
   const auto &Endpoint() const { return rpc_client_->Endpoint(); }
 
+  Storage::TimestampInfo GetTimestampInfo();
+
  private:
-  void FinalizeTransactionReplicationInternal();
+  [[nodiscard]] bool FinalizeTransactionReplicationInternal();
 
   void RecoverReplica(uint64_t replica_commit);
 
@@ -156,30 +157,6 @@ class Storage::ReplicationClient {
   std::optional<ReplicaStream> replica_stream_;
   replication::ReplicationMode mode_{replication::ReplicationMode::SYNC};
 
-  // Dispatcher class for timeout tasks
-  struct TimeoutDispatcher {
-    explicit TimeoutDispatcher(){};
-
-    void WaitForTaskToFinish();
-
-    void StartTimeoutTask(double timeout);
-
-    // If the Timeout task should continue waiting
-    std::atomic<bool> active{false};
-
-    std::mutex main_lock;
-    std::condition_variable main_cv;
-
-   private:
-    // if the Timeout task finished executing
-    bool finished{true};
-
-    utils::ThreadPool timeout_pool{1};
-  };
-
-  std::optional<double> timeout_;
-  std::optional<TimeoutDispatcher> timeout_dispatcher_;
-
   utils::SpinLock client_lock_;
   // This thread pool is used for background tasks so we don't
   // block the main storage thread