Add support for Amazon Linux 2 and stop generating C++ using Lisp/LCP (#814)

.github/workflows/package_all.yaml

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

.gitignore

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

environment/os/amzn-2.sh

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

environment/toolchain/v4.sh

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

init

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

release/CMakeLists.txt

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

release/package/amzn-2/Dockerfile

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

release/package/docker-compose.yml

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

release/package/run.sh

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

src/CMakeLists.txt

@@ -1,7 +1,6 @@
 # CMake configuration for the main memgraph library and executable
 
 # add memgraph sub libraries, ordered by dependency
-add_subdirectory(lisp)
 add_subdirectory(utils)
 add_subdirectory(requests)
 add_subdirectory(io)

src/query/CMakeLists.txt

@@ -1,13 +1,7 @@
-define_add_lcp(add_lcp_query lcp_query_cpp_files generated_lcp_query_files)
-
-add_lcp_query(frontend/ast/ast.lcp)
-add_lcp_query(frontend/semantic/symbol.lcp)
-add_lcp_query(plan/operator.lcp)
-
-add_custom_target(generate_lcp_query DEPENDS ${generated_lcp_query_files})
-
 set(mg_query_sources
-    ${lcp_query_cpp_files}
+    frontend/ast/ast.cpp
+    frontend/semantic/symbol.cpp
+    plan/operator_type_info.cpp
     common.cpp
     cypher_query_interpreter.cpp
     dump.cpp
@@ -46,7 +40,6 @@ set(mg_query_sources
 find_package(Boost REQUIRED)
 
 add_library(mg-query STATIC ${mg_query_sources})
-add_dependencies(mg-query generate_lcp_query)
 target_include_directories(mg-query PUBLIC ${CMAKE_SOURCE_DIR}/include)
 target_link_libraries(mg-query dl cppitertools Boost::headers)
 target_link_libraries(mg-query mg-integrations-pulsar mg-integrations-kafka mg-storage-v2 mg-license mg-utils mg-kvstore mg-memory)

src/query/frontend/ast/ast.cpp

@@ -0,0 +1,263 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "query/frontend/ast/ast.hpp"
+#include "utils/typeinfo.hpp"
+
+namespace memgraph {
+
+constexpr utils::TypeInfo query::LabelIx::kType{utils::TypeId::AST_LABELIX, "LabelIx", nullptr};
+
+constexpr utils::TypeInfo query::PropertyIx::kType{utils::TypeId::AST_PROPERTYIX, "PropertyIx", nullptr};
+
+constexpr utils::TypeInfo query::EdgeTypeIx::kType{utils::TypeId::AST_EDGETYPEIX, "EdgeTypeIx", nullptr};
+
+constexpr utils::TypeInfo query::Tree::kType{utils::TypeId::AST_TREE, "Tree", nullptr};
+
+constexpr utils::TypeInfo query::Expression::kType{utils::TypeId::AST_EXPRESSION, "Expression", &query::Tree::kType};
+
+constexpr utils::TypeInfo query::Where::kType{utils::TypeId::AST_WHERE, "Where", &query::Tree::kType};
+
+constexpr utils::TypeInfo query::BinaryOperator::kType{utils::TypeId::AST_BINARY_OPERATOR, "BinaryOperator",
+                                                       &query::Expression::kType};
+
+constexpr utils::TypeInfo query::UnaryOperator::kType{utils::TypeId::AST_UNARY_OPERATOR, "UnaryOperator",
+                                                      &query::Expression::kType};
+
+constexpr utils::TypeInfo query::OrOperator::kType{utils::TypeId::AST_OR_OPERATOR, "OrOperator",
+                                                   &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::XorOperator::kType{utils::TypeId::AST_XOR_OPERATOR, "XorOperator",
+                                                    &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::AndOperator::kType{utils::TypeId::AST_AND_OPERATOR, "AndOperator",
+                                                    &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::AdditionOperator::kType{utils::TypeId::AST_ADDITION_OPERATOR, "AdditionOperator",
+                                                         &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::SubtractionOperator::kType{utils::TypeId::AST_SUBTRACTION_OPERATOR,
+                                                            "SubtractionOperator", &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::MultiplicationOperator::kType{utils::TypeId::AST_MULTIPLICATION_OPERATOR,
+                                                               "MultiplicationOperator", &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::DivisionOperator::kType{utils::TypeId::AST_DIVISION_OPERATOR, "DivisionOperator",
+                                                         &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::ModOperator::kType{utils::TypeId::AST_MOD_OPERATOR, "ModOperator",
+                                                    &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::NotEqualOperator::kType{utils::TypeId::AST_NOT_EQUAL_OPERATOR, "NotEqualOperator",
+                                                         &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::EqualOperator::kType{utils::TypeId::AST_EQUAL_OPERATOR, "EqualOperator",
+                                                      &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::LessOperator::kType{utils::TypeId::AST_LESS_OPERATOR, "LessOperator",
+                                                     &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::GreaterOperator::kType{utils::TypeId::AST_GREATER_OPERATOR, "GreaterOperator",
+                                                        &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::LessEqualOperator::kType{utils::TypeId::AST_LESS_EQUAL_OPERATOR, "LessEqualOperator",
+                                                          &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::GreaterEqualOperator::kType{utils::TypeId::AST_GREATER_EQUAL_OPERATOR,
+                                                             "GreaterEqualOperator", &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::InListOperator::kType{utils::TypeId::AST_IN_LIST_OPERATOR, "InListOperator",
+                                                       &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::SubscriptOperator::kType{utils::TypeId::AST_SUBSCRIPT_OPERATOR, "SubscriptOperator",
+                                                          &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::NotOperator::kType{utils::TypeId::AST_NOT_OPERATOR, "NotOperator",
+                                                    &query::UnaryOperator::kType};
+
+constexpr utils::TypeInfo query::UnaryPlusOperator::kType{utils::TypeId::AST_UNARY_PLUS_OPERATOR, "UnaryPlusOperator",
+                                                          &query::UnaryOperator::kType};
+
+constexpr utils::TypeInfo query::UnaryMinusOperator::kType{utils::TypeId::AST_UNARY_MINUS_OPERATOR,
+                                                           "UnaryMinusOperator", &query::UnaryOperator::kType};
+
+constexpr utils::TypeInfo query::IsNullOperator::kType{utils::TypeId::AST_IS_NULL_OPERATOR, "IsNullOperator",
+                                                       &query::UnaryOperator::kType};
+
+constexpr utils::TypeInfo query::Aggregation::kType{utils::TypeId::AST_AGGREGATION, "Aggregation",
+                                                    &query::BinaryOperator::kType};
+
+constexpr utils::TypeInfo query::ListSlicingOperator::kType{utils::TypeId::AST_LIST_SLICING_OPERATOR,
+                                                            "ListSlicingOperator", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::IfOperator::kType{utils::TypeId::AST_IF_OPERATOR, "IfOperator",
+                                                   &query::Expression::kType};
+
+constexpr utils::TypeInfo query::BaseLiteral::kType{utils::TypeId::AST_BASE_LITERAL, "BaseLiteral",
+                                                    &query::Expression::kType};
+
+constexpr utils::TypeInfo query::PrimitiveLiteral::kType{utils::TypeId::AST_PRIMITIVE_LITERAL, "PrimitiveLiteral",
+                                                         &query::BaseLiteral::kType};
+
+constexpr utils::TypeInfo query::ListLiteral::kType{utils::TypeId::AST_LIST_LITERAL, "ListLiteral",
+                                                    &query::BaseLiteral::kType};
+
+constexpr utils::TypeInfo query::MapLiteral::kType{utils::TypeId::AST_MAP_LITERAL, "MapLiteral",
+                                                   &query::BaseLiteral::kType};
+
+constexpr utils::TypeInfo query::Identifier::kType{utils::TypeId::AST_IDENTIFIER, "Identifier",
+                                                   &query::Expression::kType};
+
+constexpr utils::TypeInfo query::PropertyLookup::kType{utils::TypeId::AST_PROPERTY_LOOKUP, "PropertyLookup",
+                                                       &query::Expression::kType};
+
+constexpr utils::TypeInfo query::LabelsTest::kType{utils::TypeId::AST_LABELS_TEST, "LabelsTest",
+                                                   &query::Expression::kType};
+
+constexpr utils::TypeInfo query::Function::kType{utils::TypeId::AST_FUNCTION, "Function", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::Reduce::kType{utils::TypeId::AST_REDUCE, "Reduce", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::Coalesce::kType{utils::TypeId::AST_COALESCE, "Coalesce", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::Extract::kType{utils::TypeId::AST_EXTRACT, "Extract", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::All::kType{utils::TypeId::AST_ALL, "All", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::Single::kType{utils::TypeId::AST_SINGLE, "Single", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::Any::kType{utils::TypeId::AST_ANY, "Any", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::None::kType{utils::TypeId::AST_NONE, "None", &query::Expression::kType};
+
+constexpr utils::TypeInfo query::ParameterLookup::kType{utils::TypeId::AST_PARAMETER_LOOKUP, "ParameterLookup",
+                                                        &query::Expression::kType};
+
+constexpr utils::TypeInfo query::RegexMatch::kType{utils::TypeId::AST_REGEX_MATCH, "RegexMatch",
+                                                   &query::Expression::kType};
+
+constexpr utils::TypeInfo query::NamedExpression::kType{utils::TypeId::AST_NAMED_EXPRESSION, "NamedExpression",
+                                                        &query::Tree::kType};
+
+constexpr utils::TypeInfo query::PatternAtom::kType{utils::TypeId::AST_PATTERN_ATOM, "PatternAtom",
+                                                    &query::Tree::kType};
+
+constexpr utils::TypeInfo query::NodeAtom::kType{utils::TypeId::AST_NODE_ATOM, "NodeAtom", &query::PatternAtom::kType};
+
+constexpr utils::TypeInfo query::EdgeAtom::Lambda::kType{utils::TypeId::AST_EDGE_ATOM_LAMBDA, "Lambda", nullptr};
+
+constexpr utils::TypeInfo query::EdgeAtom::kType{utils::TypeId::AST_EDGE_ATOM, "EdgeAtom", &query::PatternAtom::kType};
+
+constexpr utils::TypeInfo query::Pattern::kType{utils::TypeId::AST_PATTERN, "Pattern", &query::Tree::kType};
+
+constexpr utils::TypeInfo query::Clause::kType{utils::TypeId::AST_CLAUSE, "Clause", &query::Tree::kType};
+
+constexpr utils::TypeInfo query::SingleQuery::kType{utils::TypeId::AST_SINGLE_QUERY, "SingleQuery",
+                                                    &query::Tree::kType};
+
+constexpr utils::TypeInfo query::CypherUnion::kType{utils::TypeId::AST_CYPHER_UNION, "CypherUnion",
+                                                    &query::Tree::kType};
+
+constexpr utils::TypeInfo query::Query::kType{utils::TypeId::AST_QUERY, "Query", &query::Tree::kType};
+
+constexpr utils::TypeInfo query::CypherQuery::kType{utils::TypeId::AST_CYPHER_QUERY, "CypherQuery",
+                                                    &query::Query::kType};
+
+constexpr utils::TypeInfo query::ExplainQuery::kType{utils::TypeId::AST_EXPLAIN_QUERY, "ExplainQuery",
+                                                     &query::Query::kType};
+
+constexpr utils::TypeInfo query::ProfileQuery::kType{utils::TypeId::AST_PROFILE_QUERY, "ProfileQuery",
+                                                     &query::Query::kType};
+
+constexpr utils::TypeInfo query::IndexQuery::kType{utils::TypeId::AST_INDEX_QUERY, "IndexQuery", &query::Query::kType};
+
+constexpr utils::TypeInfo query::Create::kType{utils::TypeId::AST_CREATE, "Create", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::CallProcedure::kType{utils::TypeId::AST_CALL_PROCEDURE, "CallProcedure",
+                                                      &query::Clause::kType};
+
+constexpr utils::TypeInfo query::Match::kType{utils::TypeId::AST_MATCH, "Match", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::SortItem::kType{utils::TypeId::AST_SORT_ITEM, "SortItem", nullptr};
+
+constexpr utils::TypeInfo query::ReturnBody::kType{utils::TypeId::AST_RETURN_BODY, "ReturnBody", nullptr};
+
+constexpr utils::TypeInfo query::Return::kType{utils::TypeId::AST_RETURN, "Return", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::With::kType{utils::TypeId::AST_WITH, "With", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::Delete::kType{utils::TypeId::AST_DELETE, "Delete", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::SetProperty::kType{utils::TypeId::AST_SET_PROPERTY, "SetProperty",
+                                                    &query::Clause::kType};
+
+constexpr utils::TypeInfo query::SetProperties::kType{utils::TypeId::AST_SET_PROPERTIES, "SetProperties",
+                                                      &query::Clause::kType};
+
+constexpr utils::TypeInfo query::SetLabels::kType{utils::TypeId::AST_SET_LABELS, "SetLabels", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::RemoveProperty::kType{utils::TypeId::AST_REMOVE_PROPERTY, "RemoveProperty",
+                                                       &query::Clause::kType};
+
+constexpr utils::TypeInfo query::RemoveLabels::kType{utils::TypeId::AST_REMOVE_LABELS, "RemoveLabels",
+                                                     &query::Clause::kType};
+
+constexpr utils::TypeInfo query::Merge::kType{utils::TypeId::AST_MERGE, "Merge", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::Unwind::kType{utils::TypeId::AST_UNWIND, "Unwind", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::AuthQuery::kType{utils::TypeId::AST_AUTH_QUERY, "AuthQuery", &query::Query::kType};
+
+constexpr utils::TypeInfo query::InfoQuery::kType{utils::TypeId::AST_INFO_QUERY, "InfoQuery", &query::Query::kType};
+
+constexpr utils::TypeInfo query::Constraint::kType{utils::TypeId::AST_CONSTRAINT, "Constraint", nullptr};
+
+constexpr utils::TypeInfo query::ConstraintQuery::kType{utils::TypeId::AST_CONSTRAINT_QUERY, "ConstraintQuery",
+                                                        &query::Query::kType};
+
+constexpr utils::TypeInfo query::DumpQuery::kType{utils::TypeId::AST_DUMP_QUERY, "DumpQuery", &query::Query::kType};
+
+constexpr utils::TypeInfo query::ReplicationQuery::kType{utils::TypeId::AST_REPLICATION_QUERY, "ReplicationQuery",
+                                                         &query::Query::kType};
+
+constexpr utils::TypeInfo query::LockPathQuery::kType{utils::TypeId::AST_LOCK_PATH_QUERY, "LockPathQuery",
+                                                      &query::Query::kType};
+
+constexpr utils::TypeInfo query::LoadCsv::kType{utils::TypeId::AST_LOAD_CSV, "LoadCsv", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::FreeMemoryQuery::kType{utils::TypeId::AST_FREE_MEMORY_QUERY, "FreeMemoryQuery",
+                                                        &query::Query::kType};
+
+constexpr utils::TypeInfo query::TriggerQuery::kType{utils::TypeId::AST_TRIGGER_QUERY, "TriggerQuery",
+                                                     &query::Query::kType};
+
+constexpr utils::TypeInfo query::IsolationLevelQuery::kType{utils::TypeId::AST_ISOLATION_LEVEL_QUERY,
+                                                            "IsolationLevelQuery", &query::Query::kType};
+
+constexpr utils::TypeInfo query::CreateSnapshotQuery::kType{utils::TypeId::AST_CREATE_SNAPSHOT_QUERY,
+                                                            "CreateSnapshotQuery", &query::Query::kType};
+
+constexpr utils::TypeInfo query::StreamQuery::kType{utils::TypeId::AST_STREAM_QUERY, "StreamQuery",
+                                                    &query::Query::kType};
+
+constexpr utils::TypeInfo query::SettingQuery::kType{utils::TypeId::AST_SETTING_QUERY, "SettingQuery",
+                                                     &query::Query::kType};
+
+constexpr utils::TypeInfo query::VersionQuery::kType{utils::TypeId::AST_VERSION_QUERY, "VersionQuery",
+                                                     &query::Query::kType};
+
+constexpr utils::TypeInfo query::Foreach::kType{utils::TypeId::AST_FOREACH, "Foreach", &query::Clause::kType};
+
+constexpr utils::TypeInfo query::ShowConfigQuery::kType{utils::TypeId::AST_SHOW_CONFIG_QUERY, "ShowConfigQuery",
+                                                        &query::Query::kType};
+
+constexpr utils::TypeInfo query::Exists::kType{utils::TypeId::AST_EXISTS, "Exists", &query::Expression::kType};
+}  // namespace memgraph

src/query/frontend/semantic/symbol.cpp

@@ -0,0 +1,18 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "query/frontend/semantic/symbol.hpp"
+#include "utils/typeinfo.hpp"
+
+namespace memgraph {
+
+constexpr utils::TypeInfo query::Symbol::kType{utils::TypeId::SYMBOL, "Symbol", nullptr};
+}  // namespace memgraph

src/query/frontend/semantic/symbol.hpp

@@ -0,0 +1,75 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include <string>
+
+#include "utils/typeinfo.hpp"
+
+namespace memgraph {
+
+namespace query {
+
+class Symbol {
+ public:
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  enum class Type { ANY, VERTEX, EDGE, PATH, NUMBER, EDGE_LIST };
+
+  // TODO: Generate enum to string conversion from LCP. Note, that this is
+  // displayed to the end user, so we may want to have a pretty name of each
+  // value.
+  static std::string TypeToString(Type type) {
+    const char *enum_string[] = {"Any", "Vertex", "Edge", "Path", "Number", "EdgeList"};
+    return enum_string[static_cast<int>(type)];
+  }
+
+  Symbol() {}
+  Symbol(const std::string &name, int position, bool user_declared, Type type = Type::ANY, int token_position = -1)
+      : name_(name), position_(position), user_declared_(user_declared), type_(type), token_position_(token_position) {}
+
+  bool operator==(const Symbol &other) const {
+    return position_ == other.position_ && name_ == other.name_ && type_ == other.type_;
+  }
+  bool operator!=(const Symbol &other) const { return !operator==(other); }
+
+  // TODO: Remove these since members are public
+  const auto &name() const { return name_; }
+  int position() const { return position_; }
+  Type type() const { return type_; }
+  bool user_declared() const { return user_declared_; }
+  int token_position() const { return token_position_; }
+
+  std::string name_;
+  int64_t position_;
+  bool user_declared_{true};
+  memgraph::query::Symbol::Type type_{Type::ANY};
+  int64_t token_position_{-1};
+};
+
+}  // namespace query
+}  // namespace memgraph
+namespace std {
+
+template <>
+struct hash<memgraph::query::Symbol> {
+  size_t operator()(const memgraph::query::Symbol &symbol) const {
+    size_t prime = 265443599u;
+    size_t hash = std::hash<int>{}(symbol.position());
+    hash ^= prime * std::hash<std::string>{}(symbol.name());
+    hash ^= prime * std::hash<int>{}(static_cast<int>(symbol.type()));
+    return hash;
+  }
+};
+
+}  // namespace std

src/query/plan/operator_type_info.cpp

@@ -0,0 +1,148 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include <cstdint>
+
+#include "query/plan/operator.hpp"
+
+namespace memgraph {
+
+constexpr utils::TypeInfo query::plan::LogicalOperator::kType{utils::TypeId::LOGICAL_OPERATOR, "LogicalOperator",
+                                                              nullptr};
+
+constexpr utils::TypeInfo query::plan::Once::kType{utils::TypeId::ONCE, "Once", &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::NodeCreationInfo::kType{utils::TypeId::NODE_CREATION_INFO, "NodeCreationInfo",
+                                                               nullptr};
+
+constexpr utils::TypeInfo query::plan::CreateNode::kType{utils::TypeId::CREATE_NODE, "CreateNode",
+                                                         &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::EdgeCreationInfo::kType{utils::TypeId::EDGE_CREATION_INFO, "EdgeCreationInfo",
+                                                               nullptr};
+
+constexpr utils::TypeInfo query::plan::CreateExpand::kType{utils::TypeId::CREATE_EXPAND, "CreateExpand",
+                                                           &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::ScanAll::kType{utils::TypeId::SCAN_ALL, "ScanAll",
+                                                      &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::ScanAllByLabel::kType{utils::TypeId::SCAN_ALL_BY_LABEL, "ScanAllByLabel",
+                                                             &query::plan::ScanAll::kType};
+
+constexpr utils::TypeInfo query::plan::ScanAllByLabelPropertyRange::kType{
+    utils::TypeId::SCAN_ALL_BY_LABEL_PROPERTY_RANGE, "ScanAllByLabelPropertyRange", &query::plan::ScanAll::kType};
+
+constexpr utils::TypeInfo query::plan::ScanAllByLabelPropertyValue::kType{
+    utils::TypeId::SCAN_ALL_BY_LABEL_PROPERTY_VALUE, "ScanAllByLabelPropertyValue", &query::plan::ScanAll::kType};
+
+constexpr utils::TypeInfo query::plan::ScanAllByLabelProperty::kType{
+    utils::TypeId::SCAN_ALL_BY_LABEL_PROPERTY, "ScanAllByLabelProperty", &query::plan::ScanAll::kType};
+
+constexpr utils::TypeInfo query::plan::ScanAllById::kType{utils::TypeId::SCAN_ALL_BY_ID, "ScanAllById",
+                                                          &query::plan::ScanAll::kType};
+
+constexpr utils::TypeInfo query::plan::ExpandCommon::kType{utils::TypeId::EXPAND_COMMON, "ExpandCommon", nullptr};
+
+constexpr utils::TypeInfo query::plan::Expand::kType{utils::TypeId::EXPAND, "Expand",
+                                                     &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::ExpansionLambda::kType{utils::TypeId::EXPANSION_LAMBDA, "ExpansionLambda",
+                                                              nullptr};
+
+constexpr utils::TypeInfo query::plan::ExpandVariable::kType{utils::TypeId::EXPAND_VARIABLE, "ExpandVariable",
+                                                             &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::ConstructNamedPath::kType{
+    utils::TypeId::CONSTRUCT_NAMED_PATH, "ConstructNamedPath", &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Filter::kType{utils::TypeId::FILTER, "Filter",
+                                                     &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Produce::kType{utils::TypeId::PRODUCE, "Produce",
+                                                      &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Delete::kType{utils::TypeId::DELETE, "Delete",
+                                                     &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::SetProperty::kType{utils::TypeId::SET_PROPERTY, "SetProperty",
+                                                          &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::SetProperties::kType{utils::TypeId::SET_PROPERTIES, "SetProperties",
+                                                            &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::SetLabels::kType{utils::TypeId::SET_LABELS, "SetLabels",
+                                                        &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::RemoveProperty::kType{utils::TypeId::REMOVE_PROPERTY, "RemoveProperty",
+                                                             &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::RemoveLabels::kType{utils::TypeId::REMOVE_LABELS, "RemoveLabels",
+                                                           &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::EdgeUniquenessFilter::kType{
+    utils::TypeId::EDGE_UNIQUENESS_FILTER, "EdgeUniquenessFilter", &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::EmptyResult::kType{utils::TypeId::EMPTY_RESULT, "EmptyResult",
+                                                          &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Accumulate::kType{utils::TypeId::ACCUMULATE, "Accumulate",
+                                                         &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Aggregate::Element::kType{utils::TypeId::AGGREGATE_ELEMENT, "Element", nullptr};
+
+constexpr utils::TypeInfo query::plan::Aggregate::kType{utils::TypeId::AGGREGATE, "Aggregate",
+                                                        &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Skip::kType{utils::TypeId::SKIP, "Skip", &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::EvaluatePatternFilter::kType{
+    utils::TypeId::EVALUATE_PATTERN_FILTER, "EvaluatePatternFilter", &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Limit::kType{utils::TypeId::LIMIT, "Limit",
+                                                    &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::OrderBy::kType{utils::TypeId::ORDERBY, "OrderBy",
+                                                      &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Merge::kType{utils::TypeId::MERGE, "Merge",
+                                                    &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Optional::kType{utils::TypeId::OPTIONAL, "Optional",
+                                                       &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Unwind::kType{utils::TypeId::UNWIND, "Unwind",
+                                                     &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Distinct::kType{utils::TypeId::DISTINCT, "Distinct",
+                                                       &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Union::kType{utils::TypeId::UNION, "Union",
+                                                    &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Cartesian::kType{utils::TypeId::CARTESIAN, "Cartesian",
+                                                        &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::OutputTable::kType{utils::TypeId::OUTPUT_TABLE, "OutputTable",
+                                                          &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::OutputTableStream::kType{utils::TypeId::OUTPUT_TABLE_STREAM, "OutputTableStream",
+                                                                &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::CallProcedure::kType{utils::TypeId::CALL_PROCEDURE, "CallProcedure",
+                                                            &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::LoadCsv::kType{utils::TypeId::LOAD_CSV, "LoadCsv",
+                                                      &query::plan::LogicalOperator::kType};
+
+constexpr utils::TypeInfo query::plan::Foreach::kType{utils::TypeId::FOREACH, "Foreach",
+                                                      &query::plan::LogicalOperator::kType};
+}  // namespace memgraph

src/rpc/client.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -23,6 +23,7 @@
 #include "slk/streams.hpp"
 #include "utils/logging.hpp"
 #include "utils/on_scope_exit.hpp"
+#include "utils/typeinfo.hpp"
 
 namespace memgraph::rpc {
 
@@ -84,11 +85,11 @@ class Client {
       slk::Reader res_reader(self_->client_->GetData(), response_data_size);
       utils::OnScopeExit res_cleanup([&, response_data_size] { self_->client_->ShiftData(response_data_size); });
 
-      uint64_t res_id = 0;
+      utils::TypeId res_id{utils::TypeId::UNKNOWN};
       slk::Load(&res_id, &res_reader);
 
       // Check the response ID.
-      if (res_id != res_type.id) {
+      if (res_id != res_type.id && res_id != utils::TypeId::UNKNOWN) {
         spdlog::error("Message response was of unexpected type");
         self_->client_ = std::nullopt;
         throw RpcFailedException(self_->endpoint_);

src/rpc/protocol.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -16,6 +16,7 @@
 #include "slk/serialization.hpp"
 #include "slk/streams.hpp"
 #include "utils/on_scope_exit.hpp"
+#include "utils/typeinfo.hpp"
 
 namespace memgraph::rpc {
 
@@ -41,7 +42,7 @@ void Session::Execute() {
       [&](const uint8_t *data, size_t size, bool have_more) { output_stream_->Write(data, size, have_more); });
 
   // Load the request ID.
-  uint64_t req_id = 0;
+  utils::TypeId req_id{utils::TypeId::UNKNOWN};
   slk::Load(&req_id, &req_reader);
 
   // Access to `callbacks_` and `extended_callbacks_` is done here without

src/rpc/server.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -86,8 +86,8 @@ class Server {
   };
 
   std::mutex lock_;
-  std::map<uint64_t, RpcCallback> callbacks_;
+  std::map<utils::TypeId, RpcCallback> callbacks_;
-  std::map<uint64_t, RpcExtendedCallback> extended_callbacks_;
+  std::map<utils::TypeId, RpcExtendedCallback> extended_callbacks_;
 
   communication::Server<Session, Server> server_;
 };

src/slk/serialization.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -29,8 +29,10 @@
 
 #include "slk/streams.hpp"
 #include "utils/cast.hpp"
+#include "utils/concepts.hpp"
 #include "utils/endian.hpp"
 #include "utils/exceptions.hpp"
+#include "utils/typeinfo.hpp"
 
 // The namespace name stands for SaveLoadKit. It should be not mistaken for the
 // Mercedes car model line.
@@ -308,6 +310,10 @@ inline void Save(const std::optional<T> &obj, Builder *builder) {
   }
 }
 
+inline void Save(const utils::TypeId &obj, Builder *builder) {
+  Save(static_cast<std::underlying_type_t<utils::TypeId>>(obj), builder);
+}
+
 template <typename T>
 inline void Load(std::optional<T> *obj, Reader *reader) {
   bool exists = false;
@@ -471,4 +477,12 @@ inline void Load(std::optional<T> *obj, Reader *reader, std::function<void(T *,
     *obj = std::nullopt;
   }
 }
+
+inline void Load(utils::TypeId *obj, Reader *reader) {
+  using enum_type = std::underlying_type_t<utils::TypeId>;
+  enum_type obj_encoded;
+  slk::Load(&obj_encoded, reader);
+  *obj = utils::TypeId(utils::MemcpyCast<enum_type>(obj_encoded));
+}
+
 }  // namespace memgraph::slk

src/storage/v2/CMakeLists.txt

@@ -12,12 +12,6 @@ set(storage_v2_src_files
     vertex_accessor.cpp
     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)
-
-add_custom_target(generate_lcp_storage DEPENDS ${generated_lcp_storage_files})
 
 set(storage_v2_src_files
     ${storage_v2_src_files}
@@ -26,7 +20,7 @@ set(storage_v2_src_files
     replication/serialization.cpp
     replication/slk.cpp
     replication/replication_persistence_helper.cpp
-    ${lcp_storage_cpp_files})
+    replication/rpc.cpp)
 
 #######################
 find_package(gflags REQUIRED)
@@ -35,5 +29,4 @@ find_package(Threads REQUIRED)
 add_library(mg-storage-v2 STATIC ${storage_v2_src_files})
 target_link_libraries(mg-storage-v2 Threads::Threads mg-utils gflags)
 
-add_dependencies(mg-storage-v2 generate_lcp_storage)
 target_link_libraries(mg-storage-v2 mg-rpc mg-slk)

src/storage/v2/replication/.gitignore

@@ -1,2 +0,0 @@
-# autogenerated files
-rpc.hpp

src/storage/v2/replication/rpc.cpp

@@ -0,0 +1,263 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#include "storage/v2/replication/rpc.hpp"
+#include "utils/typeinfo.hpp"
+
+namespace memgraph {
+
+namespace storage {
+
+namespace replication {
+
+void AppendDeltasReq::Save(const AppendDeltasReq &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self, builder);
+}
+void AppendDeltasReq::Load(AppendDeltasReq *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
+void AppendDeltasRes::Save(const AppendDeltasRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self, builder);
+}
+void AppendDeltasRes::Load(AppendDeltasRes *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
+void HeartbeatReq::Save(const HeartbeatReq &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self, builder);
+}
+void HeartbeatReq::Load(HeartbeatReq *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
+void HeartbeatRes::Save(const HeartbeatRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self, builder);
+}
+void HeartbeatRes::Load(HeartbeatRes *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
+void FrequentHeartbeatReq::Save(const FrequentHeartbeatReq &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self, builder);
+}
+void FrequentHeartbeatReq::Load(FrequentHeartbeatReq *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(self, reader);
+}
+void FrequentHeartbeatRes::Save(const FrequentHeartbeatRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self, builder);
+}
+void FrequentHeartbeatRes::Load(FrequentHeartbeatRes *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(self, reader);
+}
+void SnapshotReq::Save(const SnapshotReq &self, memgraph::slk::Builder *builder) { memgraph::slk::Save(self, builder); }
+void SnapshotReq::Load(SnapshotReq *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
+void SnapshotRes::Save(const SnapshotRes &self, memgraph::slk::Builder *builder) { memgraph::slk::Save(self, builder); }
+void SnapshotRes::Load(SnapshotRes *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
+void WalFilesReq::Save(const WalFilesReq &self, memgraph::slk::Builder *builder) { memgraph::slk::Save(self, builder); }
+void WalFilesReq::Load(WalFilesReq *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
+void WalFilesRes::Save(const WalFilesRes &self, memgraph::slk::Builder *builder) { memgraph::slk::Save(self, builder); }
+void WalFilesRes::Load(WalFilesRes *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
+void CurrentWalReq::Save(const CurrentWalReq &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self, builder);
+}
+void CurrentWalReq::Load(CurrentWalReq *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
+void CurrentWalRes::Save(const CurrentWalRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self, builder);
+}
+void CurrentWalRes::Load(CurrentWalRes *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
+void TimestampReq::Save(const TimestampReq &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self, builder);
+}
+void TimestampReq::Load(TimestampReq *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
+void TimestampRes::Save(const TimestampRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self, builder);
+}
+void TimestampRes::Load(TimestampRes *self, memgraph::slk::Reader *reader) { memgraph::slk::Load(self, reader); }
+
+}  // namespace replication
+}  // namespace storage
+
+constexpr utils::TypeInfo storage::replication::AppendDeltasReq::kType{utils::TypeId::REP_APPEND_DELTAS_REQ,
+                                                                       "AppendDeltasReq", nullptr};
+
+constexpr utils::TypeInfo storage::replication::AppendDeltasRes::kType{utils::TypeId::REP_APPEND_DELTAS_RES,
+                                                                       "AppendDeltasRes", nullptr};
+
+constexpr utils::TypeInfo storage::replication::HeartbeatReq::kType{utils::TypeId::REP_HEARTBEAT_REQ, "HeartbeatReq",
+                                                                    nullptr};
+
+constexpr utils::TypeInfo storage::replication::HeartbeatRes::kType{utils::TypeId::REP_HEARTBEAT_RES, "HeartbeatRes",
+                                                                    nullptr};
+
+constexpr utils::TypeInfo storage::replication::FrequentHeartbeatReq::kType{utils::TypeId::REP_FREQUENT_HEARTBEAT_REQ,
+                                                                            "FrequentHeartbeatReq", nullptr};
+
+constexpr utils::TypeInfo storage::replication::FrequentHeartbeatRes::kType{utils::TypeId::REP_FREQUENT_HEARTBEAT_RES,
+                                                                            "FrequentHeartbeatRes", nullptr};
+
+constexpr utils::TypeInfo storage::replication::SnapshotReq::kType{utils::TypeId::REP_SNAPSHOT_REQ, "SnapshotReq",
+                                                                   nullptr};
+
+constexpr utils::TypeInfo storage::replication::SnapshotRes::kType{utils::TypeId::REP_SNAPSHOT_RES, "SnapshotRes",
+                                                                   nullptr};
+
+constexpr utils::TypeInfo storage::replication::WalFilesReq::kType{utils::TypeId::REP_WALFILES_REQ, "WalFilesReq",
+                                                                   nullptr};
+
+constexpr utils::TypeInfo storage::replication::WalFilesRes::kType{utils::TypeId::REP_WALFILES_RES, "WalFilesRes",
+                                                                   nullptr};
+
+constexpr utils::TypeInfo storage::replication::CurrentWalReq::kType{utils::TypeId::REP_CURRENT_WAL_REQ,
+                                                                     "CurrentWalReq", nullptr};
+
+constexpr utils::TypeInfo storage::replication::CurrentWalRes::kType{utils::TypeId::REP_CURRENT_WAL_RES,
+                                                                     "CurrentWalRes", nullptr};
+
+constexpr utils::TypeInfo storage::replication::TimestampReq::kType{utils::TypeId::REP_TIMESTAMP_REQ, "TimestampReq",
+                                                                    nullptr};
+
+constexpr utils::TypeInfo storage::replication::TimestampRes::kType{utils::TypeId::REP_TIMESTAMP_RES, "TimestampRes",
+                                                                    nullptr};
+
+// Autogenerated SLK serialization code
+namespace slk {
+// Serialize code for TimestampRes
+
+void Save(const memgraph::storage::replication::TimestampRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self.success, builder);
+  memgraph::slk::Save(self.current_commit_timestamp, builder);
+}
+
+void Load(memgraph::storage::replication::TimestampRes *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(&self->success, reader);
+  memgraph::slk::Load(&self->current_commit_timestamp, reader);
+}
+
+// Serialize code for TimestampReq
+
+void Save(const memgraph::storage::replication::TimestampReq &self, memgraph::slk::Builder *builder) {}
+
+void Load(memgraph::storage::replication::TimestampReq *self, memgraph::slk::Reader *reader) {}
+
+// Serialize code for CurrentWalRes
+
+void Save(const memgraph::storage::replication::CurrentWalRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self.success, builder);
+  memgraph::slk::Save(self.current_commit_timestamp, builder);
+}
+
+void Load(memgraph::storage::replication::CurrentWalRes *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(&self->success, reader);
+  memgraph::slk::Load(&self->current_commit_timestamp, reader);
+}
+
+// Serialize code for CurrentWalReq
+
+void Save(const memgraph::storage::replication::CurrentWalReq &self, memgraph::slk::Builder *builder) {}
+
+void Load(memgraph::storage::replication::CurrentWalReq *self, memgraph::slk::Reader *reader) {}
+
+// Serialize code for WalFilesRes
+
+void Save(const memgraph::storage::replication::WalFilesRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self.success, builder);
+  memgraph::slk::Save(self.current_commit_timestamp, builder);
+}
+
+void Load(memgraph::storage::replication::WalFilesRes *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(&self->success, reader);
+  memgraph::slk::Load(&self->current_commit_timestamp, reader);
+}
+
+// Serialize code for WalFilesReq
+
+void Save(const memgraph::storage::replication::WalFilesReq &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self.file_number, builder);
+}
+
+void Load(memgraph::storage::replication::WalFilesReq *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(&self->file_number, reader);
+}
+
+// Serialize code for SnapshotRes
+
+void Save(const memgraph::storage::replication::SnapshotRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self.success, builder);
+  memgraph::slk::Save(self.current_commit_timestamp, builder);
+}
+
+void Load(memgraph::storage::replication::SnapshotRes *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(&self->success, reader);
+  memgraph::slk::Load(&self->current_commit_timestamp, reader);
+}
+
+// Serialize code for SnapshotReq
+
+void Save(const memgraph::storage::replication::SnapshotReq &self, memgraph::slk::Builder *builder) {}
+
+void Load(memgraph::storage::replication::SnapshotReq *self, memgraph::slk::Reader *reader) {}
+
+// Serialize code for FrequentHeartbeatRes
+
+void Save(const memgraph::storage::replication::FrequentHeartbeatRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self.success, builder);
+}
+
+void Load(memgraph::storage::replication::FrequentHeartbeatRes *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(&self->success, reader);
+}
+
+// Serialize code for FrequentHeartbeatReq
+
+void Save(const memgraph::storage::replication::FrequentHeartbeatReq &self, memgraph::slk::Builder *builder) {}
+
+void Load(memgraph::storage::replication::FrequentHeartbeatReq *self, memgraph::slk::Reader *reader) {}
+
+// Serialize code for HeartbeatRes
+
+void Save(const memgraph::storage::replication::HeartbeatRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self.success, builder);
+  memgraph::slk::Save(self.current_commit_timestamp, builder);
+  memgraph::slk::Save(self.epoch_id, builder);
+}
+
+void Load(memgraph::storage::replication::HeartbeatRes *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(&self->success, reader);
+  memgraph::slk::Load(&self->current_commit_timestamp, reader);
+  memgraph::slk::Load(&self->epoch_id, reader);
+}
+
+// Serialize code for HeartbeatReq
+
+void Save(const memgraph::storage::replication::HeartbeatReq &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self.main_commit_timestamp, builder);
+  memgraph::slk::Save(self.epoch_id, builder);
+}
+
+void Load(memgraph::storage::replication::HeartbeatReq *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(&self->main_commit_timestamp, reader);
+  memgraph::slk::Load(&self->epoch_id, reader);
+}
+
+// Serialize code for AppendDeltasRes
+
+void Save(const memgraph::storage::replication::AppendDeltasRes &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self.success, builder);
+  memgraph::slk::Save(self.current_commit_timestamp, builder);
+}
+
+void Load(memgraph::storage::replication::AppendDeltasRes *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(&self->success, reader);
+  memgraph::slk::Load(&self->current_commit_timestamp, reader);
+}
+
+// Serialize code for AppendDeltasReq
+
+void Save(const memgraph::storage::replication::AppendDeltasReq &self, memgraph::slk::Builder *builder) {
+  memgraph::slk::Save(self.previous_commit_timestamp, builder);
+  memgraph::slk::Save(self.seq_num, builder);
+}
+
+void Load(memgraph::storage::replication::AppendDeltasReq *self, memgraph::slk::Reader *reader) {
+  memgraph::slk::Load(&self->previous_commit_timestamp, reader);
+  memgraph::slk::Load(&self->seq_num, reader);
+}
+}  // namespace slk
+}  // namespace memgraph

src/storage/v2/replication/rpc.hpp

@@ -0,0 +1,278 @@
+// Copyright 2023 Memgraph Ltd.
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
+// License, and you may not use this file except in compliance with the Business Source License.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+#pragma once
+
+#include <cstdint>
+#include <cstring>
+#include <string>
+
+#include "rpc/messages.hpp"
+#include "slk/serialization.hpp"
+#include "slk/streams.hpp"
+
+namespace memgraph {
+
+namespace storage {
+
+namespace replication {
+
+struct AppendDeltasReq {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(AppendDeltasReq *self, memgraph::slk::Reader *reader);
+  static void Save(const AppendDeltasReq &self, memgraph::slk::Builder *builder);
+  AppendDeltasReq() {}
+  AppendDeltasReq(uint64_t previous_commit_timestamp, uint64_t seq_num)
+      : previous_commit_timestamp(previous_commit_timestamp), seq_num(seq_num) {}
+
+  uint64_t previous_commit_timestamp;
+  uint64_t seq_num;
+};
+
+struct AppendDeltasRes {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(AppendDeltasRes *self, memgraph::slk::Reader *reader);
+  static void Save(const AppendDeltasRes &self, memgraph::slk::Builder *builder);
+  AppendDeltasRes() {}
+  AppendDeltasRes(bool success, uint64_t current_commit_timestamp)
+      : success(success), current_commit_timestamp(current_commit_timestamp) {}
+
+  bool success;
+  uint64_t current_commit_timestamp;
+};
+
+using AppendDeltasRpc = rpc::RequestResponse<AppendDeltasReq, AppendDeltasRes>;
+
+struct HeartbeatReq {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(HeartbeatReq *self, memgraph::slk::Reader *reader);
+  static void Save(const HeartbeatReq &self, memgraph::slk::Builder *builder);
+  HeartbeatReq() {}
+  HeartbeatReq(uint64_t main_commit_timestamp, std::string epoch_id)
+      : main_commit_timestamp(main_commit_timestamp), epoch_id(epoch_id) {}
+
+  uint64_t main_commit_timestamp;
+  std::string epoch_id;
+};
+
+struct HeartbeatRes {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(HeartbeatRes *self, memgraph::slk::Reader *reader);
+  static void Save(const HeartbeatRes &self, memgraph::slk::Builder *builder);
+  HeartbeatRes() {}
+  HeartbeatRes(bool success, uint64_t current_commit_timestamp, std::string epoch_id)
+      : success(success), current_commit_timestamp(current_commit_timestamp), epoch_id(epoch_id) {}
+
+  bool success;
+  uint64_t current_commit_timestamp;
+  std::string epoch_id;
+};
+
+using HeartbeatRpc = rpc::RequestResponse<HeartbeatReq, HeartbeatRes>;
+
+struct FrequentHeartbeatReq {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(FrequentHeartbeatReq *self, memgraph::slk::Reader *reader);
+  static void Save(const FrequentHeartbeatReq &self, memgraph::slk::Builder *builder);
+  FrequentHeartbeatReq() {}
+};
+
+struct FrequentHeartbeatRes {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(FrequentHeartbeatRes *self, memgraph::slk::Reader *reader);
+  static void Save(const FrequentHeartbeatRes &self, memgraph::slk::Builder *builder);
+  FrequentHeartbeatRes() {}
+  explicit FrequentHeartbeatRes(bool success) : success(success) {}
+
+  bool success;
+};
+
+using FrequentHeartbeatRpc = rpc::RequestResponse<FrequentHeartbeatReq, FrequentHeartbeatRes>;
+
+struct SnapshotReq {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(SnapshotReq *self, memgraph::slk::Reader *reader);
+  static void Save(const SnapshotReq &self, memgraph::slk::Builder *builder);
+  SnapshotReq() {}
+};
+
+struct SnapshotRes {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(SnapshotRes *self, memgraph::slk::Reader *reader);
+  static void Save(const SnapshotRes &self, memgraph::slk::Builder *builder);
+  SnapshotRes() {}
+  SnapshotRes(bool success, uint64_t current_commit_timestamp)
+      : success(success), current_commit_timestamp(current_commit_timestamp) {}
+
+  bool success;
+  uint64_t current_commit_timestamp;
+};
+
+using SnapshotRpc = rpc::RequestResponse<SnapshotReq, SnapshotRes>;
+
+struct WalFilesReq {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(WalFilesReq *self, memgraph::slk::Reader *reader);
+  static void Save(const WalFilesReq &self, memgraph::slk::Builder *builder);
+  WalFilesReq() {}
+  explicit WalFilesReq(uint64_t file_number) : file_number(file_number) {}
+
+  uint64_t file_number;
+};
+
+struct WalFilesRes {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(WalFilesRes *self, memgraph::slk::Reader *reader);
+  static void Save(const WalFilesRes &self, memgraph::slk::Builder *builder);
+  WalFilesRes() {}
+  WalFilesRes(bool success, uint64_t current_commit_timestamp)
+      : success(success), current_commit_timestamp(current_commit_timestamp) {}
+
+  bool success;
+  uint64_t current_commit_timestamp;
+};
+
+using WalFilesRpc = rpc::RequestResponse<WalFilesReq, WalFilesRes>;
+
+struct CurrentWalReq {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(CurrentWalReq *self, memgraph::slk::Reader *reader);
+  static void Save(const CurrentWalReq &self, memgraph::slk::Builder *builder);
+  CurrentWalReq() {}
+};
+
+struct CurrentWalRes {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(CurrentWalRes *self, memgraph::slk::Reader *reader);
+  static void Save(const CurrentWalRes &self, memgraph::slk::Builder *builder);
+  CurrentWalRes() {}
+  CurrentWalRes(bool success, uint64_t current_commit_timestamp)
+      : success(success), current_commit_timestamp(current_commit_timestamp) {}
+
+  bool success;
+  uint64_t current_commit_timestamp;
+};
+
+using CurrentWalRpc = rpc::RequestResponse<CurrentWalReq, CurrentWalRes>;
+
+struct TimestampReq {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(TimestampReq *self, memgraph::slk::Reader *reader);
+  static void Save(const TimestampReq &self, memgraph::slk::Builder *builder);
+  TimestampReq() {}
+};
+
+struct TimestampRes {
+  static const utils::TypeInfo kType;
+  static const utils::TypeInfo &GetTypeInfo() { return kType; }
+
+  static void Load(TimestampRes *self, memgraph::slk::Reader *reader);
+  static void Save(const TimestampRes &self, memgraph::slk::Builder *builder);
+  TimestampRes() {}
+  TimestampRes(bool success, uint64_t current_commit_timestamp)
+      : success(success), current_commit_timestamp(current_commit_timestamp) {}
+
+  bool success;
+  uint64_t current_commit_timestamp;
+};
+
+using TimestampRpc = rpc::RequestResponse<TimestampReq, TimestampRes>;
+}  // namespace replication
+}  // namespace storage
+}  // namespace memgraph
+
+// SLK serialization declarations
+#include "slk/serialization.hpp"
+namespace memgraph::slk {
+
+void Save(const memgraph::storage::replication::TimestampRes &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::TimestampRes *self, memgraph::slk::Reader *reader);
+
+void Save(const memgraph::storage::replication::TimestampReq &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::TimestampReq *self, memgraph::slk::Reader *reader);
+
+void Save(const memgraph::storage::replication::CurrentWalRes &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::CurrentWalRes *self, memgraph::slk::Reader *reader);
+
+void Save(const memgraph::storage::replication::CurrentWalReq &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::CurrentWalReq *self, memgraph::slk::Reader *reader);
+
+void Save(const memgraph::storage::replication::WalFilesRes &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::WalFilesRes *self, memgraph::slk::Reader *reader);
+
+void Save(const memgraph::storage::replication::WalFilesReq &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::WalFilesReq *self, memgraph::slk::Reader *reader);
+
+void Save(const memgraph::storage::replication::SnapshotRes &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::SnapshotRes *self, memgraph::slk::Reader *reader);
+
+void Save(const memgraph::storage::replication::SnapshotReq &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::SnapshotReq *self, memgraph::slk::Reader *reader);
+
+void Save(const memgraph::storage::replication::FrequentHeartbeatRes &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::FrequentHeartbeatRes *self, memgraph::slk::Reader *reader);
+
+void Save(const memgraph::storage::replication::FrequentHeartbeatReq &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::FrequentHeartbeatReq *self, memgraph::slk::Reader *reader);
+
+void Save(const memgraph::storage::replication::HeartbeatRes &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::HeartbeatRes *self, memgraph::slk::Reader *reader);
+
+void Save(const memgraph::storage::replication::HeartbeatReq &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::HeartbeatReq *self, memgraph::slk::Reader *reader);
+
+void Save(const memgraph::storage::replication::AppendDeltasRes &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::AppendDeltasRes *self, memgraph::slk::Reader *reader);
+
+void Save(const memgraph::storage::replication::AppendDeltasReq &self, memgraph::slk::Builder *builder);
+
+void Load(memgraph::storage::replication::AppendDeltasReq *self, memgraph::slk::Reader *reader);
+
+}  // namespace memgraph::slk

src/utils/typeinfo.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -16,6 +16,172 @@
 
 namespace memgraph::utils {
 
+enum class TypeId : uint64_t {
+  // Operators
+  UNKNOWN,
+  LOGICAL_OPERATOR,
+  ONCE,
+  NODE_CREATION_INFO,
+  CREATE_NODE,
+  EDGE_CREATION_INFO,
+  CREATE_EXPAND,
+  SCAN_ALL,
+  SCAN_ALL_BY_LABEL,
+  SCAN_ALL_BY_LABEL_PROPERTY_RANGE,
+  SCAN_ALL_BY_LABEL_PROPERTY_VALUE,
+  SCAN_ALL_BY_LABEL_PROPERTY,
+  SCAN_ALL_BY_ID,
+  EXPAND_COMMON,
+  EXPAND,
+  EXPANSION_LAMBDA,
+  EXPAND_VARIABLE,
+  CONSTRUCT_NAMED_PATH,
+  FILTER,
+  PRODUCE,
+  DELETE,
+  SET_PROPERTY,
+  SET_PROPERTIES,
+  SET_LABELS,
+  REMOVE_PROPERTY,
+  REMOVE_LABELS,
+  EDGE_UNIQUENESS_FILTER,
+  EMPTY_RESULT,
+  ACCUMULATE,
+  AGGREGATE,
+  AGGREGATE_ELEMENT,
+  SKIP,
+  EVALUATE_PATTERN_FILTER,
+  LIMIT,
+  ORDERBY,
+  MERGE,
+  OPTIONAL,
+  UNWIND,
+  DISTINCT,
+  UNION,
+  CARTESIAN,
+  OUTPUT_TABLE,
+  OUTPUT_TABLE_STREAM,
+  CALL_PROCEDURE,
+  LOAD_CSV,
+  FOREACH,
+
+  // Replication
+  REP_APPEND_DELTAS_REQ,
+  REP_APPEND_DELTAS_RES,
+  REP_HEARTBEAT_REQ,
+  REP_HEARTBEAT_RES,
+  REP_FREQUENT_HEARTBEAT_REQ,
+  REP_FREQUENT_HEARTBEAT_RES,
+  REP_SNAPSHOT_REQ,
+  REP_SNAPSHOT_RES,
+  REP_WALFILES_REQ,
+  REP_WALFILES_RES,
+  REP_CURRENT_WAL_REQ,
+  REP_CURRENT_WAL_RES,
+  REP_TIMESTAMP_REQ,
+  REP_TIMESTAMP_RES,
+
+  // AST
+  AST_LABELIX,
+  AST_PROPERTYIX,
+  AST_EDGETYPEIX,
+  AST_TREE,
+  AST_EXPRESSION,
+  AST_WHERE,
+  AST_BINARY_OPERATOR,
+  AST_UNARY_OPERATOR,
+  AST_OR_OPERATOR,
+  AST_XOR_OPERATOR,
+  AST_AND_OPERATOR,
+  AST_ADDITION_OPERATOR,
+  AST_SUBTRACTION_OPERATOR,
+  AST_MULTIPLICATION_OPERATOR,
+  AST_DIVISION_OPERATOR,
+  AST_MOD_OPERATOR,
+  AST_NOT_EQUAL_OPERATOR,
+  AST_EQUAL_OPERATOR,
+  AST_LESS_OPERATOR,
+  AST_GREATER_OPERATOR,
+  AST_LESS_EQUAL_OPERATOR,
+  AST_GREATER_EQUAL_OPERATOR,
+  AST_IN_LIST_OPERATOR,
+  AST_SUBSCRIPT_OPERATOR,
+  AST_NOT_OPERATOR,
+  AST_UNARY_PLUS_OPERATOR,
+  AST_UNARY_MINUS_OPERATOR,
+  AST_IS_NULL_OPERATOR,
+  AST_AGGREGATION,
+  AST_LIST_SLICING_OPERATOR,
+  AST_IF_OPERATOR,
+  AST_BASE_LITERAL,
+  AST_PRIMITIVE_LITERAL,
+  AST_LIST_LITERAL,
+  AST_MAP_LITERAL,
+  AST_IDENTIFIER,
+  AST_PROPERTY_LOOKUP,
+  AST_LABELS_TEST,
+  AST_FUNCTION,
+  AST_REDUCE,
+  AST_COALESCE,
+  AST_EXTRACT,
+  AST_ALL,
+  AST_SINGLE,
+  AST_ANY,
+  AST_NONE,
+  AST_PARAMETER_LOOKUP,
+  AST_REGEX_MATCH,
+  AST_NAMED_EXPRESSION,
+  AST_PATTERN_ATOM,
+  AST_NODE_ATOM,
+  AST_EDGE_ATOM_LAMBDA,
+  AST_EDGE_ATOM,
+  AST_PATTERN,
+  AST_CLAUSE,
+  AST_SINGLE_QUERY,
+  AST_CYPHER_UNION,
+  AST_QUERY,
+  AST_CYPHER_QUERY,
+  AST_EXPLAIN_QUERY,
+  AST_PROFILE_QUERY,
+  AST_INDEX_QUERY,
+  AST_CREATE,
+  AST_CALL_PROCEDURE,
+  AST_MATCH,
+  AST_SORT_ITEM,
+  AST_RETURN_BODY,
+  AST_RETURN,
+  AST_WITH,
+  AST_DELETE,
+  AST_SET_PROPERTY,
+  AST_SET_PROPERTIES,
+  AST_SET_LABELS,
+  AST_REMOVE_PROPERTY,
+  AST_REMOVE_LABELS,
+  AST_MERGE,
+  AST_UNWIND,
+  AST_AUTH_QUERY,
+  AST_INFO_QUERY,
+  AST_CONSTRAINT,
+  AST_CONSTRAINT_QUERY,
+  AST_DUMP_QUERY,
+  AST_REPLICATION_QUERY,
+  AST_LOCK_PATH_QUERY,
+  AST_LOAD_CSV,
+  AST_FREE_MEMORY_QUERY,
+  AST_TRIGGER_QUERY,
+  AST_ISOLATION_LEVEL_QUERY,
+  AST_CREATE_SNAPSHOT_QUERY,
+  AST_STREAM_QUERY,
+  AST_SETTING_QUERY,
+  AST_VERSION_QUERY,
+  AST_FOREACH,
+  AST_SHOW_CONFIG_QUERY,
+  AST_EXISTS,
+
+  // Symbol
+  SYMBOL,
+};
+
 /// Type information on a C++ type.
 ///
 /// You should embed this structure as a static constant member `kType` and make
@@ -24,7 +190,7 @@ namespace memgraph::utils {
 /// runtime type.
 struct TypeInfo {
   /// Unique ID for the type.
-  uint64_t id;
+  TypeId id;
   /// Pretty name of the type.
   const char *name;
   /// `TypeInfo *` for superclass of this type.

tests/benchmark/rpc.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -25,7 +25,7 @@ struct EchoMessage {
   static const memgraph::utils::TypeInfo kType;
 
   EchoMessage() {}  // Needed for serialization.
-  EchoMessage(const std::string &data) : data(data) {}
+  explicit EchoMessage(const std::string &data) : data(data) {}
 
   static void Load(EchoMessage *obj, memgraph::slk::Reader *reader);
   static void Save(const EchoMessage &obj, memgraph::slk::Builder *builder);
@@ -41,7 +41,7 @@ void Load(EchoMessage *echo, Reader *reader) { Load(&echo->data, reader); }
 void EchoMessage::Load(EchoMessage *obj, memgraph::slk::Reader *reader) { memgraph::slk::Load(obj, reader); }
 void EchoMessage::Save(const EchoMessage &obj, memgraph::slk::Builder *builder) { memgraph::slk::Save(obj, builder); }
 
-const memgraph::utils::TypeInfo EchoMessage::kType{2, "EchoMessage"};
+const memgraph::utils::TypeInfo EchoMessage::kType{memgraph::utils::TypeId::UNKNOWN, "EchoMessage"};
 
 using Echo = memgraph::rpc::RequestResponse<EchoMessage, EchoMessage>;
 

tests/unit/CMakeLists.txt

@@ -360,15 +360,6 @@ if(MG_ENTERPRISE)
   target_link_libraries(${test_prefix}rpc mg-rpc)
 endif()
 
-# Test LCP
-add_custom_command(
-  OUTPUT test_lcp
-  DEPENDS ${lcp_src_files} lcp test_lcp.lisp
-  COMMAND sbcl --script ${CMAKE_CURRENT_SOURCE_DIR}/test_lcp.lisp)
-add_custom_target(test_lcp ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/test_lcp)
-add_test(test_lcp ${CMAKE_CURRENT_BINARY_DIR}/test_lcp)
-add_dependencies(memgraph__unit test_lcp)
-
 # Test websocket
 find_package(Boost REQUIRED)
 

tests/unit/rpc_messages.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -28,7 +28,7 @@ struct SumReq {
   int y;
 };
 
-const memgraph::utils::TypeInfo SumReq::kType{0, "SumReq"};
+const memgraph::utils::TypeInfo SumReq::kType{memgraph::utils::TypeId::UNKNOWN, "SumReq"};
 
 struct SumRes {
   static const memgraph::utils::TypeInfo kType;
@@ -42,7 +42,7 @@ struct SumRes {
   int sum;
 };
 
-const memgraph::utils::TypeInfo SumRes::kType{1, "SumRes"};
+const memgraph::utils::TypeInfo SumRes::kType{memgraph::utils::TypeId::UNKNOWN, "SumRes"};
 
 namespace memgraph::slk {
 void Save(const SumReq &sum, Builder *builder);
@@ -66,7 +66,7 @@ struct EchoMessage {
   std::string data;
 };
 
-const memgraph::utils::TypeInfo EchoMessage::kType{2, "EchoMessage"};
+const memgraph::utils::TypeInfo EchoMessage::kType{memgraph::utils::TypeId::UNKNOWN, "EchoMessage"};
 
 namespace memgraph::slk {
 void Save(const EchoMessage &echo, Builder *builder);