Check-in initial RsmEngine class

Co-authored-by: János Benjamin Antal <antaljanosbenjamin@users.noreply.github.com>

.clang-tidy

@@ -6,6 +6,7 @@ Checks: '*,
          -altera-unroll-loops,
          -android-*,
          -cert-err58-cpp,
+         -cert-str34-c,
          -cppcoreguidelines-avoid-c-arrays,
          -cppcoreguidelines-avoid-goto,
          -cppcoreguidelines-avoid-magic-numbers,
@@ -49,6 +50,7 @@ Checks: '*,
          -misc-non-private-member-variables-in-classes,
          -modernize-avoid-c-arrays,
          -modernize-concat-nested-namespaces,
+         -modernize-loop-convert,
          -modernize-pass-by-value,
          -modernize-use-equals-default,
          -modernize-use-nodiscard,

.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

@@ -70,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.
@@ -110,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
@@ -156,7 +171,7 @@ jobs:
 
           # Run leftover CTest tests (all except unit and benchmark tests).
           cd build
-          ctest -E "(memgraph__unit|memgraph__benchmark)" --output-on-failure
+          ctest -E "(memgraph__unit|memgraph__benchmark|memgraph__simulation)" --output-on-failure
 
       - name: Run drivers tests
         run: |
@@ -247,6 +262,15 @@ jobs:
           cd build
           ctest -R memgraph__unit --output-on-failure -j$THREADS
 
+      - name: Run simulation tests
+        run: |
+          # Activate toolchain.
+          source /opt/toolchain-v4/activate
+
+          # Run unit tests.
+          cd build
+          ctest -R memgraph__simulation --output-on-failure -j$THREADS
+
       - name: Run e2e tests
         run: |
           # TODO(gitbuda): Setup mgclient and pymgclient properly.

.gitignore

@@ -23,6 +23,7 @@ cmake-build-*
 cmake/DownloadProject/
 dist/
 src/query/frontend/opencypher/generated/
+src/query/v2/frontend/opencypher/generated/
 tags
 ve/
 ve3/
@@ -50,15 +51,21 @@ 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/v2/frontend/ast/ast.hpp
 src/query/frontend/ast/ast.hpp
 src/query/distributed/frontend/ast/ast_serialization.hpp
+src/query/v2/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/v2/frontend/semantic/symbol.hpp
 src/query/distributed/frontend/semantic/symbol_serialization.hpp
+src/query/v2/distributed/frontend/semantic/symbol_serialization.hpp
 src/query/distributed/plan/ops.hpp
+src/query/v2/distributed/plan/ops.hpp
 src/query/plan/operator.hpp
+src/query/v2/plan/operator.hpp
 src/raft/log_entry.hpp
 src/raft/raft_rpc_messages.hpp
 src/raft/snapshot_metadata.hpp

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
 

src/CMakeLists.txt

@@ -5,16 +5,20 @@ add_subdirectory(lisp)
 add_subdirectory(utils)
 add_subdirectory(requests)
 add_subdirectory(io)
+add_subdirectory(io/simulator)
 add_subdirectory(kvstore)
 add_subdirectory(telemetry)
 add_subdirectory(communication)
 add_subdirectory(memory)
 add_subdirectory(storage/v2)
+add_subdirectory(storage/v3)
 add_subdirectory(integrations)
 add_subdirectory(query)
+add_subdirectory(query/v2)
 add_subdirectory(slk)
 add_subdirectory(rpc)
 add_subdirectory(auth)
+add_subdirectory(coordinator)
 
 if (MG_ENTERPRISE)
   add_subdirectory(audit)

src/auth/models.cpp

@@ -37,7 +37,7 @@ const std::vector<Permission> kPermissionsAll = {
     Permission::CONSTRAINT, Permission::DUMP,      Permission::AUTH,        Permission::REPLICATION,
     Permission::DURABILITY, Permission::READ_FILE, Permission::FREE_MEMORY, Permission::TRIGGER,
     Permission::CONFIG,     Permission::STREAM,    Permission::MODULE_READ, Permission::MODULE_WRITE,
-    Permission::WEBSOCKET};
+    Permission::WEBSOCKET,  Permission::SCHEMA};
 }  // namespace
 
 std::string PermissionToString(Permission permission) {
@@ -84,6 +84,8 @@ std::string PermissionToString(Permission permission) {
       return "MODULE_WRITE";
     case Permission::WEBSOCKET:
       return "WEBSOCKET";
+    case Permission::SCHEMA:
+      return "SCHEMA";
   }
 }
 

src/auth/models.hpp

@@ -38,7 +38,8 @@ enum class Permission : uint64_t {
   STREAM       = 1U << 17U,
   MODULE_READ  = 1U << 18U,
   MODULE_WRITE = 1U << 19U,
-  WEBSOCKET    = 1U << 20U
+  WEBSOCKET    = 1U << 20U,
+  SCHEMA       = 1U << 21U
 };
 // clang-format on
 

src/common/types.hpp

@@ -0,0 +1,19 @@
+// 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.
+
+#pragma once
+
+#include <cstdint>
+
+namespace memgraph::common {
+enum class SchemaType : uint8_t { BOOL, INT, STRING, DATE, LOCALTIME, LOCALDATETIME, DURATION };
+
+}  // namespace memgraph::common

src/communication/bolt/v1/value.hpp

@@ -167,7 +167,6 @@ class Value {
   Value(const Edge &value) : type_(Type::Edge) { new (&edge_v) Edge(value); }
   Value(const UnboundedEdge &value) : type_(Type::UnboundedEdge) { new (&unbounded_edge_v) UnboundedEdge(value); }
   Value(const Path &value) : type_(Type::Path) { new (&path_v) Path(value); }
-
   Value(const utils::Date &date) : type_(Type::Date) { new (&date_v) utils::Date(date); }
   Value(const utils::LocalTime &time) : type_(Type::LocalTime) { new (&local_time_v) utils::LocalTime(time); }
   Value(const utils::LocalDateTime &date_time) : type_(Type::LocalDateTime) {

src/coordinator/CMakeLists.txt

@@ -0,0 +1,10 @@
+set(coordinator_src_files
+    coordinator.hpp
+    shard_map.hpp
+    hybrid_logical_clock.hpp)
+
+find_package(fmt REQUIRED)
+find_package(Threads REQUIRED)
+
+add_library(mg-coordinator STATIC ${coordinator_src_files})
+target_link_libraries(mg-coordinator stdc++fs Threads::Threads fmt::fmt mg-utils)

src/coordinator/coordinator.hpp

@@ -0,0 +1,243 @@
+// 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.
+
+#pragma once
+
+#include <unordered_set>
+
+#include "coordinator/hybrid_logical_clock.hpp"
+#include "coordinator/shard_map.hpp"
+#include "io/simulator/simulator.hpp"
+#include "io/time.hpp"
+#include "io/transport.hpp"
+
+namespace memgraph::coordinator {
+
+using Address = memgraph::io::Address;
+using SimT = memgraph::io::simulator::SimulatorTransport;
+
+struct HlcRequest {
+  Hlc last_shard_map_version;
+};
+
+struct HlcResponse {
+  Hlc new_hlc;
+  std::optional<ShardMap> fresher_shard_map;
+};
+
+struct GetShardMapRequest {
+  // No state
+};
+
+struct GetShardMapResponse {
+  ShardMap shard_map;
+};
+
+struct AllocateHlcBatchRequest {
+  Hlc low;
+  Hlc high;
+};
+
+struct AllocateHlcBatchResponse {
+  bool success;
+  Hlc low;
+  Hlc high;
+};
+
+struct AllocateEdgeIdBatchRequest {
+  size_t batch_size;
+};
+
+struct AllocateEdgeIdBatchResponse {
+  uint64_t low;
+  uint64_t high;
+};
+
+struct SplitShardRequest {
+  Hlc previous_shard_map_version;
+  Label label;
+  CompoundKey split_key;
+};
+
+struct SplitShardResponse {
+  bool success;
+};
+
+struct RegisterStorageEngineRequest {
+  Address address;
+};
+
+struct RegisterStorageEngineResponse {
+  bool success;
+};
+
+struct DeregisterStorageEngineRequest {
+  Address address;
+};
+
+struct DeregisterStorageEngineResponse {
+  bool success;
+};
+
+struct InitializeLabelRequest {
+  std::string label_name;
+  Hlc last_shard_map_version;
+};
+
+struct InitializeLabelResponse {
+  bool success;
+  std::optional<ShardMap> fresher_shard_map;
+};
+
+using WriteRequests =
+    std::variant<AllocateHlcBatchRequest, AllocateEdgeIdBatchRequest, SplitShardRequest, RegisterStorageEngineRequest,
+                 DeregisterStorageEngineRequest, InitializeLabelRequest>;
+using WriteResponses =
+    std::variant<AllocateHlcBatchResponse, AllocateEdgeIdBatchResponse, SplitShardResponse,
+                 RegisterStorageEngineResponse, DeregisterStorageEngineResponse, InitializeLabelResponse>;
+
+using ReadRequests = std::variant<HlcRequest, GetShardMapRequest>;
+using ReadResponses = std::variant<HlcResponse, GetShardMapResponse>;
+
+class Coordinator {
+  ShardMap shard_map_;
+  /// The highest reserved timestamp / highest allocated timestamp
+  /// is a way for minimizing communication involved in query engines
+  /// reserving Hlc's for their transaction processing.
+  /// Periodically, the coordinator will allocate a batch of timestamps
+  /// and this will need to go over consensus. From that point forward,
+  /// each timestamp in that batch can be given out to "readers" who issue
+  /// HlcRequest without blocking on consensus first. But if
+  /// highest_allocated_timestamp_ approaches highest_reserved_timestamp_,
+  /// it is time to allocate another batch, so that we can keep guaranteeing
+  /// forward progress.
+  /// Any time a coordinator becomes a new leader, it will need to issue
+  /// a new AllocateHlcBatchRequest to create a pool of IDs to allocate.
+  uint64_t highest_allocated_timestamp_;
+  uint64_t highest_reserved_timestamp_;
+
+  /// Query engines need to periodically request batches of unique edge IDs.
+  uint64_t highest_allocated_edge_id_;
+
+  /// Increment our
+  ReadResponses HandleRead(HlcRequest &&hlc_request) {
+    HlcResponse res{};
+
+    auto hlc_shard_map = shard_map_.GetHlc();
+
+    MG_ASSERT(!(hlc_request.last_shard_map_version.logical_id > hlc_shard_map.logical_id));
+
+    res.new_hlc = shard_map_.IncrementShardMapVersion();
+
+    // res.fresher_shard_map = hlc_request.last_shard_map_version.logical_id < hlc_shard_map.logical_id
+    //                             ? std::make_optional(shard_map_)
+    //                             : std::nullopt;
+
+    // Allways return fresher shard_map for now.
+    res.fresher_shard_map = std::make_optional(shard_map_);
+
+    return res;
+  }
+
+  ReadResponses HandleRead(GetShardMapRequest &&get_shard_map_request) {
+    GetShardMapResponse res;
+    res.shard_map = shard_map_;
+    return res;
+  }
+
+  WriteResponses ApplyWrite(AllocateHlcBatchRequest &&ahr) {
+    AllocateHlcBatchResponse res{};
+
+    return res;
+  }
+
+  WriteResponses ApplyWrite(AllocateEdgeIdBatchRequest &&ahr) {
+    AllocateEdgeIdBatchResponse res{};
+
+    uint64_t low = highest_allocated_edge_id_;
+
+    highest_allocated_edge_id_ += ahr.batch_size;
+
+    uint64_t high = highest_allocated_edge_id_;
+
+    res.low = low;
+    res.high = high;
+
+    return res;
+  }
+
+  /// This splits the shard immediately beneath the provided
+  /// split key, keeping the assigned peers identical for now,
+  /// but letting them be gradually migrated over time.
+  WriteResponses ApplyWrite(SplitShardRequest &&split_shard_request) {
+    SplitShardResponse res{};
+
+    if (split_shard_request.previous_shard_map_version != shard_map_.shard_map_version) {
+      res.success = false;
+    } else {
+      res.success = shard_map_.SplitShard(split_shard_request.previous_shard_map_version, split_shard_request.label,
+                                          split_shard_request.split_key);
+    }
+
+    return res;
+  }
+
+  /// This adds the provided storage engine to the standby storage engine pool,
+  /// which can be used to rebalance storage over time.
+  WriteResponses ApplyWrite(RegisterStorageEngineRequest &&register_storage_engine_request) {
+    RegisterStorageEngineResponse res{};
+    // TODO
+
+    return res;
+  }
+
+  /// This begins the process of draining the provided storage engine from all raft
+  /// clusters that it might be participating in.
+  WriteResponses ApplyWrite(DeregisterStorageEngineRequest &&register_storage_engine_request) {
+    DeregisterStorageEngineResponse res{};
+    // TODO
+    // const Address &address = register_storage_engine_request.address;
+    // storage_engine_pool_.erase(address);
+    // res.success = true;
+
+    return res;
+  }
+
+  WriteResponses ApplyWrite(InitializeLabelRequest &&initialize_label_request) {
+    InitializeLabelResponse res{};
+
+    bool success = shard_map_.InitializeNewLabel(initialize_label_request.label_name,
+                                                 initialize_label_request.last_shard_map_version);
+
+    if (success) {
+      res.fresher_shard_map = shard_map_;
+      res.success = false;
+    } else {
+      res.fresher_shard_map = std::nullopt;
+      res.success = true;
+    }
+
+    return res;
+  }
+
+ public:
+  explicit Coordinator(ShardMap sm) : shard_map_{(sm)} {}
+
+  ReadResponses Read(ReadRequests requests) {
+    return std::visit([&](auto &&requests) { return HandleRead(std::move(requests)); }, std::move(requests));
+  }
+
+  WriteResponses Apply(WriteRequests requests) {
+    return std::visit([&](auto &&requests) { return ApplyWrite(std::move(requests)); }, std::move(requests));
+  }
+};
+
+}  // namespace memgraph::coordinator

src/coordinator/hybrid_logical_clock.hpp

@@ -0,0 +1,30 @@
+// 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.
+
+#pragma once
+
+#include "io/time.hpp"
+
+namespace memgraph::coordinator {
+
+using Time = memgraph::io::Time;
+
+/// Hybrid-logical clock
+struct Hlc {
+  uint64_t logical_id;
+  Time coordinator_wall_clock;
+
+  bool operator==(const Hlc &other) const {
+    return (logical_id == other.logical_id) && (coordinator_wall_clock == other.coordinator_wall_clock);
+  }
+};
+
+}  // namespace memgraph::coordinator

src/coordinator/shard_map.hpp

@@ -0,0 +1,135 @@
+// 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.
+
+#pragma once
+
+#include <map>
+#include <vector>
+
+#include "coordinator/hybrid_logical_clock.hpp"
+#include "io/address.hpp"
+#include "storage/v3/property_value.hpp"
+
+namespace memgraph::coordinator {
+
+enum class Status : uint8_t {
+  CONSENSUS_PARTICIPANT,
+  INITIALIZING,
+  // TODO(tyler) this will possibly have more states,
+  // depending on the reconfiguration protocol that we
+  // implement.
+};
+
+struct AddressAndStatus {
+  memgraph::io::Address address;
+  Status status;
+};
+
+using memgraph::io::Address;
+
+using CompoundKey = std::vector<memgraph::storage::v3::PropertyValue>;
+using Shard = std::vector<AddressAndStatus>;
+using Shards = std::map<CompoundKey, Shard>;
+
+// use string for intermachine communication and NameIdMapper within the machine
+using Label = std::string;
+
+struct ShardMap {
+  Hlc shard_map_version;
+  std::map<Label, Shards> shards;
+
+  // TODO(gabor) later we will want to update the wallclock time with
+  // the given Io<impl>'s time as well
+  Hlc IncrementShardMapVersion() noexcept {
+    ++shard_map_version.logical_id;
+    return shard_map_version;
+  }
+
+  Hlc GetHlc() const noexcept { return shard_map_version; }
+
+  bool SplitShard(Hlc previous_shard_map_version, Label label, CompoundKey key) {
+    if (CompareShardMapVersions(previous_shard_map_version, shard_map_version)) {
+      MG_ASSERT(shards.contains(label));
+      auto &shards_in_map = shards[label];
+      MG_ASSERT(!shards_in_map.contains(key));
+
+      // Finding the Shard that the new CompoundKey should map to.
+      Shard shard_to_map_to;
+      CompoundKey prev_key = ((*shards_in_map.begin()).first);
+
+      for (auto iter = std::next(shards_in_map.begin()); iter != shards_in_map.end(); ++iter) {
+        const auto &current_key = (*iter).first;
+        if (key > prev_key && key < current_key) {
+          shard_to_map_to = shards_in_map[prev_key];
+        }
+
+        prev_key = (*iter).first;
+      }
+
+      // Apply the split
+      shards_in_map[key] = shard_to_map_to;
+
+      return true;
+    }
+
+    return false;
+  }
+
+  bool InitializeNewLabel(std::string label_name, Hlc last_shard_map_version) {
+    if (shard_map_version != last_shard_map_version) {
+      return false;
+    }
+
+    if (shards.contains(label_name)) {
+      return false;
+    }
+
+    shards.emplace(label_name, Shards{});
+
+    IncrementShardMapVersion();
+
+    return true;
+  }
+
+  void AddServer(Address server_address) {
+    // Find a random place for the server to plug in
+  }
+
+  std::map<Label, Shards> &GetShards() noexcept { return shards; }
+
+  Shards GetShardsForRange(Label label, CompoundKey start, CompoundKey end);
+
+  Shard GetShardForKey(Label label, CompoundKey key) {
+    auto shard_for_label = shards.at(label);
+
+    auto max = (--shard_for_label.end())->first;
+
+    if (key > max) {
+      return shard_for_label[max];
+    }
+
+    for (auto it = shard_for_label.lower_bound(key);; --it) {
+      MG_ASSERT(it->first <= key);
+      return it->second;
+    }
+
+    MG_ASSERT(false, "failed to find shard with a key that is less than or equal to the provided key");
+  }
+
+ private:
+  // TODO(gabor) later we will want to update the wallclock time with
+  // the given Io<impl>'s time as well. This function should just be
+  // replaced with operator== since it is already overloaded for Hlc
+  // objects.
+  bool CompareShardMapVersions(Hlc one, Hlc two) { return one.logical_id == two.logical_id; }
+};
+
+}  // namespace memgraph::coordinator

src/glue/communication.cpp

@@ -127,10 +127,6 @@ storage::Result<Value> ToBoltValue(const query::TypedValue &value, const storage
       return Value(value.ValueLocalDateTime());
     case query::TypedValue::Type::Duration:
       return Value(value.ValueDuration());
-    case query::TypedValue::Type::Graph:
-      auto maybe_graph = ToBoltGraph(value.ValueGraph(), db, view);
-      if (maybe_graph.HasError()) return maybe_graph.GetError();
-      return Value(std::move(*maybe_graph));
   }
 }
 
@@ -187,30 +183,6 @@ storage::Result<communication::bolt::Path> ToBoltPath(const query::Path &path, c
   return communication::bolt::Path(vertices, edges);
 }
 
-storage::Result<std::map<std::string, Value>> ToBoltGraph(const query::Graph &graph, const storage::Storage &db,
-                                                          storage::View view) {
-  std::map<std::string, Value> map;
-  std::vector<Value> vertices;
-  vertices.reserve(graph.vertices().size());
-  for (const auto &v : graph.vertices()) {
-    auto maybe_vertex = ToBoltVertex(v, db, view);
-    if (maybe_vertex.HasError()) return maybe_vertex.GetError();
-    vertices.emplace_back(Value(std::move(*maybe_vertex)));
-  }
-  map.emplace(std::make_pair("nodes", Value(vertices)));
-
-  std::vector<Value> edges;
-  edges.reserve(graph.edges().size());
-  for (const auto &e : graph.edges()) {
-    auto maybe_edge = ToBoltEdge(e, db, view);
-    if (maybe_edge.HasError()) return maybe_edge.GetError();
-    edges.emplace_back(Value(std::move(*maybe_edge)));
-  }
-  map.emplace(std::make_pair("edges", Value(edges)));
-
-  return std::move(map);
-}
-
 storage::PropertyValue ToPropertyValue(const Value &value) {
   switch (value.type()) {
     case Value::Type::Null:

src/glue/communication.hpp

@@ -51,15 +51,6 @@ storage::Result<communication::bolt::Edge> ToBoltEdge(const storage::EdgeAccesso
 storage::Result<communication::bolt::Path> ToBoltPath(const query::Path &path, const storage::Storage &db,
                                                       storage::View view);
 
-/// @param query::Graph for converting to communication::bolt::Graph.
-/// @param storage::Storage for ToBoltVertex and ToBoltEdge.
-/// @param storage::View for ToBoltVertex and ToBoltEdge.
-///
-/// @throw std::bad_alloc
-storage::Result<std::map<std::string, communication::bolt::Value>> ToBoltGraph(const query::Graph &graph,
-                                                                               const storage::Storage &db,
-                                                                               storage::View view);
-
 /// @param query::TypedValue for converting to communication::bolt::Value.
 /// @param storage::Storage for ToBoltVertex and ToBoltEdge.
 /// @param storage::View for ToBoltVertex and ToBoltEdge.

src/glue/v2/auth.cpp

@@ -0,0 +1,64 @@
+// 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 "glue/v2/auth.hpp"
+
+namespace memgraph::glue::v2 {
+
+auth::Permission PrivilegeToPermission(query::v2::AuthQuery::Privilege privilege) {
+  switch (privilege) {
+    case query::v2::AuthQuery::Privilege::MATCH:
+      return auth::Permission::MATCH;
+    case query::v2::AuthQuery::Privilege::CREATE:
+      return auth::Permission::CREATE;
+    case query::v2::AuthQuery::Privilege::MERGE:
+      return auth::Permission::MERGE;
+    case query::v2::AuthQuery::Privilege::DELETE:
+      return auth::Permission::DELETE;
+    case query::v2::AuthQuery::Privilege::SET:
+      return auth::Permission::SET;
+    case query::v2::AuthQuery::Privilege::REMOVE:
+      return auth::Permission::REMOVE;
+    case query::v2::AuthQuery::Privilege::INDEX:
+      return auth::Permission::INDEX;
+    case query::v2::AuthQuery::Privilege::STATS:
+      return auth::Permission::STATS;
+    case query::v2::AuthQuery::Privilege::CONSTRAINT:
+      return auth::Permission::CONSTRAINT;
+    case query::v2::AuthQuery::Privilege::DUMP:
+      return auth::Permission::DUMP;
+    case query::v2::AuthQuery::Privilege::REPLICATION:
+      return auth::Permission::REPLICATION;
+    case query::v2::AuthQuery::Privilege::DURABILITY:
+      return auth::Permission::DURABILITY;
+    case query::v2::AuthQuery::Privilege::READ_FILE:
+      return auth::Permission::READ_FILE;
+    case query::v2::AuthQuery::Privilege::FREE_MEMORY:
+      return auth::Permission::FREE_MEMORY;
+    case query::v2::AuthQuery::Privilege::TRIGGER:
+      return auth::Permission::TRIGGER;
+    case query::v2::AuthQuery::Privilege::CONFIG:
+      return auth::Permission::CONFIG;
+    case query::v2::AuthQuery::Privilege::AUTH:
+      return auth::Permission::AUTH;
+    case query::v2::AuthQuery::Privilege::STREAM:
+      return auth::Permission::STREAM;
+    case query::v2::AuthQuery::Privilege::MODULE_READ:
+      return auth::Permission::MODULE_READ;
+    case query::v2::AuthQuery::Privilege::MODULE_WRITE:
+      return auth::Permission::MODULE_WRITE;
+    case query::v2::AuthQuery::Privilege::WEBSOCKET:
+      return auth::Permission::WEBSOCKET;
+    case query::v2::AuthQuery::Privilege::SCHEMA:
+      return auth::Permission::SCHEMA;
+  }
+}
+}  // namespace memgraph::glue::v2

src/glue/v2/auth.hpp

@@ -0,0 +1,23 @@
+// 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 "auth/models.hpp"
+#include "query/v2/frontend/ast/ast.hpp"
+
+namespace memgraph::glue::v2 {
+
+/**
+ * This function converts query::AuthQuery::Privilege to its corresponding
+ * auth::Permission.
+ */
+auth::Permission PrivilegeToPermission(query::v2::AuthQuery::Privilege privilege);
+
+}  // namespace memgraph::glue::v2

src/glue/v2/communication.cpp

@@ -0,0 +1,275 @@
+// 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 "glue/v2/communication.hpp"
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "storage/v3/edge_accessor.hpp"
+#include "storage/v3/storage.hpp"
+#include "storage/v3/vertex_accessor.hpp"
+#include "utils/temporal.hpp"
+
+using memgraph::communication::bolt::Value;
+
+namespace memgraph::glue::v2 {
+
+query::v2::TypedValue ToTypedValue(const Value &value) {
+  switch (value.type()) {
+    case Value::Type::Null:
+      return {};
+    case Value::Type::Bool:
+      return query::v2::TypedValue(value.ValueBool());
+    case Value::Type::Int:
+      return query::v2::TypedValue(value.ValueInt());
+    case Value::Type::Double:
+      return query::v2::TypedValue(value.ValueDouble());
+    case Value::Type::String:
+      return query::v2::TypedValue(value.ValueString());
+    case Value::Type::List: {
+      std::vector<query::v2::TypedValue> list;
+      list.reserve(value.ValueList().size());
+      for (const auto &v : value.ValueList()) list.push_back(ToTypedValue(v));
+      return query::v2::TypedValue(std::move(list));
+    }
+    case Value::Type::Map: {
+      std::map<std::string, query::v2::TypedValue> map;
+      for (const auto &kv : value.ValueMap()) map.emplace(kv.first, ToTypedValue(kv.second));
+      return query::v2::TypedValue(std::move(map));
+    }
+    case Value::Type::Vertex:
+    case Value::Type::Edge:
+    case Value::Type::UnboundedEdge:
+    case Value::Type::Path:
+      throw communication::bolt::ValueException("Unsupported conversion from Value to TypedValue");
+    case Value::Type::Date:
+      return query::v2::TypedValue(value.ValueDate());
+    case Value::Type::LocalTime:
+      return query::v2::TypedValue(value.ValueLocalTime());
+    case Value::Type::LocalDateTime:
+      return query::v2::TypedValue(value.ValueLocalDateTime());
+    case Value::Type::Duration:
+      return query::v2::TypedValue(value.ValueDuration());
+  }
+}
+
+storage::v3::Result<communication::bolt::Vertex> ToBoltVertex(const query::v2::VertexAccessor &vertex,
+                                                              const storage::v3::Storage &db, storage::v3::View view) {
+  return ToBoltVertex(vertex.impl_, db, view);
+}
+
+storage::v3::Result<communication::bolt::Edge> ToBoltEdge(const query::v2::EdgeAccessor &edge,
+                                                          const storage::v3::Storage &db, storage::v3::View view) {
+  return ToBoltEdge(edge.impl_, db, view);
+}
+
+storage::v3::Result<Value> ToBoltValue(const query::v2::TypedValue &value, const storage::v3::Storage &db,
+                                       storage::v3::View view) {
+  switch (value.type()) {
+    case query::v2::TypedValue::Type::Null:
+      return Value();
+    case query::v2::TypedValue::Type::Bool:
+      return Value(value.ValueBool());
+    case query::v2::TypedValue::Type::Int:
+      return Value(value.ValueInt());
+    case query::v2::TypedValue::Type::Double:
+      return Value(value.ValueDouble());
+    case query::v2::TypedValue::Type::String:
+      return Value(std::string(value.ValueString()));
+    case query::v2::TypedValue::Type::List: {
+      std::vector<Value> values;
+      values.reserve(value.ValueList().size());
+      for (const auto &v : value.ValueList()) {
+        auto maybe_value = ToBoltValue(v, db, view);
+        if (maybe_value.HasError()) return maybe_value.GetError();
+        values.emplace_back(std::move(*maybe_value));
+      }
+      return Value(std::move(values));
+    }
+    case query::v2::TypedValue::Type::Map: {
+      std::map<std::string, Value> map;
+      for (const auto &kv : value.ValueMap()) {
+        auto maybe_value = ToBoltValue(kv.second, db, view);
+        if (maybe_value.HasError()) return maybe_value.GetError();
+        map.emplace(kv.first, std::move(*maybe_value));
+      }
+      return Value(std::move(map));
+    }
+    case query::v2::TypedValue::Type::Vertex: {
+      auto maybe_vertex = ToBoltVertex(value.ValueVertex(), db, view);
+      if (maybe_vertex.HasError()) return maybe_vertex.GetError();
+      return Value(std::move(*maybe_vertex));
+    }
+    case query::v2::TypedValue::Type::Edge: {
+      auto maybe_edge = ToBoltEdge(value.ValueEdge(), db, view);
+      if (maybe_edge.HasError()) return maybe_edge.GetError();
+      return Value(std::move(*maybe_edge));
+    }
+    case query::v2::TypedValue::Type::Path: {
+      auto maybe_path = ToBoltPath(value.ValuePath(), db, view);
+      if (maybe_path.HasError()) return maybe_path.GetError();
+      return Value(std::move(*maybe_path));
+    }
+    case query::v2::TypedValue::Type::Date:
+      return Value(value.ValueDate());
+    case query::v2::TypedValue::Type::LocalTime:
+      return Value(value.ValueLocalTime());
+    case query::v2::TypedValue::Type::LocalDateTime:
+      return Value(value.ValueLocalDateTime());
+    case query::v2::TypedValue::Type::Duration:
+      return Value(value.ValueDuration());
+  }
+}
+
+storage::v3::Result<communication::bolt::Vertex> ToBoltVertex(const storage::v3::VertexAccessor &vertex,
+                                                              const storage::v3::Storage &db, storage::v3::View view) {
+  auto id = communication::bolt::Id::FromUint(vertex.Gid().AsUint());
+  auto maybe_labels = vertex.Labels(view);
+  if (maybe_labels.HasError()) return maybe_labels.GetError();
+  std::vector<std::string> labels;
+  labels.reserve(maybe_labels->size());
+  for (const auto &label : *maybe_labels) {
+    labels.push_back(db.LabelToName(label));
+  }
+  auto maybe_properties = vertex.Properties(view);
+  if (maybe_properties.HasError()) return maybe_properties.GetError();
+  std::map<std::string, Value> properties;
+  for (const auto &prop : *maybe_properties) {
+    properties[db.PropertyToName(prop.first)] = ToBoltValue(prop.second);
+  }
+  return communication::bolt::Vertex{id, labels, properties};
+}
+
+storage::v3::Result<communication::bolt::Edge> ToBoltEdge(const storage::v3::EdgeAccessor &edge,
+                                                          const storage::v3::Storage &db, storage::v3::View view) {
+  auto id = communication::bolt::Id::FromUint(edge.Gid().AsUint());
+  auto from = communication::bolt::Id::FromUint(edge.FromVertex().Gid().AsUint());
+  auto to = communication::bolt::Id::FromUint(edge.ToVertex().Gid().AsUint());
+  const auto &type = db.EdgeTypeToName(edge.EdgeType());
+  auto maybe_properties = edge.Properties(view);
+  if (maybe_properties.HasError()) return maybe_properties.GetError();
+  std::map<std::string, Value> properties;
+  for (const auto &prop : *maybe_properties) {
+    properties[db.PropertyToName(prop.first)] = ToBoltValue(prop.second);
+  }
+  return communication::bolt::Edge{id, from, to, type, properties};
+}
+
+storage::v3::Result<communication::bolt::Path> ToBoltPath(const query::v2::Path &path, const storage::v3::Storage &db,
+                                                          storage::v3::View view) {
+  std::vector<communication::bolt::Vertex> vertices;
+  vertices.reserve(path.vertices().size());
+  for (const auto &v : path.vertices()) {
+    auto maybe_vertex = ToBoltVertex(v, db, view);
+    if (maybe_vertex.HasError()) return maybe_vertex.GetError();
+    vertices.emplace_back(std::move(*maybe_vertex));
+  }
+  std::vector<communication::bolt::Edge> edges;
+  edges.reserve(path.edges().size());
+  for (const auto &e : path.edges()) {
+    auto maybe_edge = ToBoltEdge(e, db, view);
+    if (maybe_edge.HasError()) return maybe_edge.GetError();
+    edges.emplace_back(std::move(*maybe_edge));
+  }
+  return communication::bolt::Path(vertices, edges);
+}
+
+storage::v3::PropertyValue ToPropertyValue(const Value &value) {
+  switch (value.type()) {
+    case Value::Type::Null:
+      return {};
+    case Value::Type::Bool:
+      return storage::v3::PropertyValue(value.ValueBool());
+    case Value::Type::Int:
+      return storage::v3::PropertyValue(value.ValueInt());
+    case Value::Type::Double:
+      return storage::v3::PropertyValue(value.ValueDouble());
+    case Value::Type::String:
+      return storage::v3::PropertyValue(value.ValueString());
+    case Value::Type::List: {
+      std::vector<storage::v3::PropertyValue> vec;
+      vec.reserve(value.ValueList().size());
+      for (const auto &value : value.ValueList()) vec.emplace_back(ToPropertyValue(value));
+      return storage::v3::PropertyValue(std::move(vec));
+    }
+    case Value::Type::Map: {
+      std::map<std::string, storage::v3::PropertyValue> map;
+      for (const auto &kv : value.ValueMap()) map.emplace(kv.first, ToPropertyValue(kv.second));
+      return storage::v3::PropertyValue(std::move(map));
+    }
+    case Value::Type::Vertex:
+    case Value::Type::Edge:
+    case Value::Type::UnboundedEdge:
+    case Value::Type::Path:
+      throw communication::bolt::ValueException("Unsupported conversion from Value to PropertyValue");
+    case Value::Type::Date:
+      return storage::v3::PropertyValue(
+          storage::v3::TemporalData(storage::v3::TemporalType::Date, value.ValueDate().MicrosecondsSinceEpoch()));
+    case Value::Type::LocalTime:
+      return storage::v3::PropertyValue(storage::v3::TemporalData(storage::v3::TemporalType::LocalTime,
+                                                                  value.ValueLocalTime().MicrosecondsSinceEpoch()));
+    case Value::Type::LocalDateTime:
+      return storage::v3::PropertyValue(storage::v3::TemporalData(storage::v3::TemporalType::LocalDateTime,
+                                                                  value.ValueLocalDateTime().MicrosecondsSinceEpoch()));
+    case Value::Type::Duration:
+      return storage::v3::PropertyValue(
+          storage::v3::TemporalData(storage::v3::TemporalType::Duration, value.ValueDuration().microseconds));
+  }
+}
+
+Value ToBoltValue(const storage::v3::PropertyValue &value) {
+  switch (value.type()) {
+    case storage::v3::PropertyValue::Type::Null:
+      return {};
+    case storage::v3::PropertyValue::Type::Bool:
+      return {value.ValueBool()};
+    case storage::v3::PropertyValue::Type::Int:
+      return {value.ValueInt()};
+      break;
+    case storage::v3::PropertyValue::Type::Double:
+      return {value.ValueDouble()};
+    case storage::v3::PropertyValue::Type::String:
+      return {value.ValueString()};
+    case storage::v3::PropertyValue::Type::List: {
+      const auto &values = value.ValueList();
+      std::vector<Value> vec;
+      vec.reserve(values.size());
+      for (const auto &v : values) {
+        vec.push_back(ToBoltValue(v));
+      }
+      return {std::move(vec)};
+    }
+    case storage::v3::PropertyValue::Type::Map: {
+      const auto &map = value.ValueMap();
+      std::map<std::string, Value> dv_map;
+      for (const auto &kv : map) {
+        dv_map.emplace(kv.first, ToBoltValue(kv.second));
+      }
+      return {std::move(dv_map)};
+    }
+    case storage::v3::PropertyValue::Type::TemporalData:
+      const auto &type = value.ValueTemporalData();
+      switch (type.type) {
+        case storage::v3::TemporalType::Date:
+          return {utils::Date(type.microseconds)};
+        case storage::v3::TemporalType::LocalTime:
+          return {utils::LocalTime(type.microseconds)};
+        case storage::v3::TemporalType::LocalDateTime:
+          return {utils::LocalDateTime(type.microseconds)};
+        case storage::v3::TemporalType::Duration:
+          return {utils::Duration(type.microseconds)};
+      }
+  }
+}
+
+}  // namespace memgraph::glue::v2

src/glue/v2/communication.hpp

@@ -0,0 +1,68 @@
+// 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.
+
+/// @file Conversion functions between Value and other memgraph types.
+#pragma once
+
+#include "communication/bolt/v1/value.hpp"
+#include "query/v2/typed_value.hpp"
+#include "storage/v3/property_value.hpp"
+#include "storage/v3/result.hpp"
+#include "storage/v3/view.hpp"
+
+namespace memgraph::storage::v3 {
+class EdgeAccessor;
+class Storage;
+class VertexAccessor;
+}  // namespace memgraph::storage::v3
+
+namespace memgraph::glue::v2 {
+
+/// @param storage::v3::VertexAccessor for converting to
+///        communication::bolt::Vertex.
+/// @param storage::v3::Storage for getting label and property names.
+/// @param storage::v3::View for deciding which vertex attributes are visible.
+///
+/// @throw std::bad_alloc
+storage::v3::Result<communication::bolt::Vertex> ToBoltVertex(const storage::v3::VertexAccessor &vertex,
+                                                              const storage::v3::Storage &db, storage::v3::View view);
+
+/// @param storage::v3::EdgeAccessor for converting to communication::bolt::Edge.
+/// @param storage::v3::Storage for getting edge type and property names.
+/// @param storage::v3::View for deciding which edge attributes are visible.
+///
+/// @throw std::bad_alloc
+storage::v3::Result<communication::bolt::Edge> ToBoltEdge(const storage::v3::EdgeAccessor &edge,
+                                                          const storage::v3::Storage &db, storage::v3::View view);
+
+/// @param query::v2::Path for converting to communication::bolt::Path.
+/// @param storage::v3::Storage for ToBoltVertex and ToBoltEdge.
+/// @param storage::v3::View for ToBoltVertex and ToBoltEdge.
+///
+/// @throw std::bad_alloc
+storage::v3::Result<communication::bolt::Path> ToBoltPath(const query::v2::Path &path, const storage::v3::Storage &db,
+                                                          storage::v3::View view);
+
+/// @param query::v2::TypedValue for converting to communication::bolt::Value.
+/// @param storage::v3::Storage for ToBoltVertex and ToBoltEdge.
+/// @param storage::v3::View for ToBoltVertex and ToBoltEdge.
+///
+/// @throw std::bad_alloc
+storage::v3::Result<communication::bolt::Value> ToBoltValue(const query::v2::TypedValue &value,
+                                                            const storage::v3::Storage &db, storage::v3::View view);
+
+query::v2::TypedValue ToTypedValue(const communication::bolt::Value &value);
+
+communication::bolt::Value ToBoltValue(const storage::v3::PropertyValue &value);
+
+storage::v3::PropertyValue ToPropertyValue(const communication::bolt::Value &value);
+
+}  // namespace memgraph::glue::v2

src/io/address.hpp

@@ -0,0 +1,60 @@
+// 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.
+
+#pragma once
+
+#include <compare>
+
+#include <fmt/format.h>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+namespace memgraph::io {
+struct Address {
+  // It's important for all participants to have a
+  // unique identifier - IP and port alone are not
+  // enough, and may change over the lifecycle of
+  // the nodes. Particularly storage nodes may change
+  // their IP addresses over time, and the system
+  // should gracefully update its information
+  // about them.
+  boost::uuids::uuid unique_id;
+  boost::asio::ip::address last_known_ip;
+  uint16_t last_known_port;
+
+  static Address TestAddress(uint16_t port) {
+    Address ret;
+    ret.last_known_port = port;
+    return ret;
+  }
+
+  friend bool operator==(const Address &lhs, const Address &rhs) = default;
+
+  /// unique_id is most dominant for ordering, then last_known_ip, then last_known_port
+  friend bool operator<(const Address &lhs, const Address &rhs) {
+    if (lhs.unique_id != rhs.unique_id) {
+      return lhs.unique_id < rhs.unique_id;
+    }
+
+    if (lhs.last_known_ip != rhs.last_known_ip) {
+      return lhs.last_known_ip < rhs.last_known_ip;
+    }
+
+    return lhs.last_known_port < rhs.last_known_port;
+  }
+
+  std::string ToString() const {
+    return fmt::format("Address {{ unique_id: {}, last_known_ip: {}, last_known_port: {} }}",
+                       boost::uuids::to_string(unique_id), last_known_ip.to_string(), last_known_port);
+  }
+};
+};  // namespace memgraph::io

src/io/errors.hpp

@@ -0,0 +1,26 @@
+// 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.
+
+#pragma once
+
+namespace memgraph::io {
+// Signifies that a retriable operation was unable to
+// complete after a configured number of retries.
+struct RetriesExhausted {};
+
+// Signifies that a request was unable to receive a response
+// within some configured timeout duration. It is important
+// to remember that in distributed systems, a timeout does
+// not signify that a request was not received or processed.
+// It may be the case that the request was fully processed
+// but that the response was not received.
+struct TimedOut {};
+};  // namespace memgraph::io

src/io/future.hpp

@@ -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.
+
+#pragma once
+
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <thread>
+#include <utility>
+
+#include "io/errors.hpp"
+#include "utils/logging.hpp"
+
+namespace memgraph::io {
+
+// Shared is in an anonymous namespace, and the only way to
+// construct a Promise or Future is to pass a Shared in. This
+// ensures that Promises and Futures can only be constructed
+// in this translation unit.
+namespace details {
+template <typename T>
+class Shared {
+  mutable std::condition_variable cv_;
+  mutable std::mutex mu_;
+  std::optional<T> item_;
+  bool consumed_ = false;
+  bool waiting_ = false;
+  std::function<bool()> simulator_notifier_ = nullptr;
+
+ public:
+  explicit Shared(std::function<bool()> simulator_notifier) : simulator_notifier_(simulator_notifier) {}
+  Shared() = default;
+  Shared(Shared &&) = delete;
+  Shared &operator=(Shared &&) = delete;
+  Shared(const Shared &) = delete;
+  Shared &operator=(const Shared &) = delete;
+  ~Shared() = default;
+
+  /// Takes the item out of our optional item_ and returns it.
+  T Take() {
+    MG_ASSERT(item_, "Take called without item_ being present");
+    MG_ASSERT(!consumed_, "Take called on already-consumed Future");
+
+    T ret = std::move(item_).value();
+    item_.reset();
+
+    consumed_ = true;
+
+    return ret;
+  }
+
+  T Wait() {
+    std::unique_lock<std::mutex> lock(mu_);
+    waiting_ = true;
+
+    while (!item_) {
+      bool simulator_progressed = false;
+      if (simulator_notifier_) [[unlikely]] {
+        // We can't hold our own lock while notifying
+        // the simulator because notifying the simulator
+        // involves acquiring the simulator's mutex
+        // to guarantee that our notification linearizes
+        // with the simulator's condition variable.
+        // However, the simulator may acquire our
+        // mutex to check if we are being awaited,
+        // while determining system quiescence,
+        // so we have to get out of its way to avoid
+        // a cyclical deadlock.
+        lock.unlock();
+        simulator_progressed = std::invoke(simulator_notifier_);
+        lock.lock();
+        if (item_) {
+          // item may have been filled while we
+          // had dropped our mutex while notifying
+          // the simulator of our waiting_ status.
+          break;
+        }
+      }
+      if (!simulator_progressed) [[likely]] {
+        cv_.wait(lock);
+      }
+      MG_ASSERT(!consumed_, "Future consumed twice!");
+    }
+
+    waiting_ = false;
+
+    return Take();
+  }
+
+  bool IsReady() const {
+    std::unique_lock<std::mutex> lock(mu_);
+    return item_;
+  }
+
+  std::optional<T> TryGet() {
+    std::unique_lock<std::mutex> lock(mu_);
+
+    if (item_) {
+      return Take();
+    }
+
+    return std::nullopt;
+  }
+
+  void Fill(T item) {
+    {
+      std::unique_lock<std::mutex> lock(mu_);
+
+      MG_ASSERT(!consumed_, "Promise filled after it was already consumed!");
+      MG_ASSERT(!item_, "Promise filled twice!");
+
+      item_ = item;
+    }  // lock released before condition variable notification
+
+    cv_.notify_all();
+  }
+
+  bool IsAwaited() const {
+    std::unique_lock<std::mutex> lock(mu_);
+    return waiting_;
+  }
+};
+}  // namespace details
+
+template <typename T>
+class Future {
+  bool consumed_or_moved_ = false;
+  std::shared_ptr<details::Shared<T>> shared_;
+
+ public:
+  explicit Future(std::shared_ptr<details::Shared<T>> shared) : shared_(shared) {}
+
+  Future() = delete;
+  Future(Future &&old) noexcept {
+    MG_ASSERT(!old.consumed_or_moved_, "Future moved from after already being moved from or consumed.");
+    shared_ = std::move(old.shared_);
+    consumed_or_moved_ = old.consumed_or_moved_;
+    old.consumed_or_moved_ = true;
+  }
+
+  Future &operator=(Future &&old) noexcept {
+    MG_ASSERT(!old.consumed_or_moved_, "Future moved from after already being moved from or consumed.");
+    shared_ = std::move(old.shared_);
+    old.consumed_or_moved_ = true;
+  }
+
+  Future(const Future &) = delete;
+  Future &operator=(const Future &) = delete;
+  ~Future() = default;
+
+  /// Returns true if the Future is ready to
+  /// be consumed using TryGet or Wait (prefer Wait
+  /// if you know it's ready, because it doesn't
+  /// return an optional.
+  bool IsReady() {
+    MG_ASSERT(!consumed_or_moved_, "Called IsReady after Future already consumed!");
+    return shared_->IsReady();
+  }
+
+  /// Non-blocking method that returns the inner
+  /// item if it's already ready, or std::nullopt
+  /// if it is not ready yet.
+  std::optional<T> TryGet() {
+    MG_ASSERT(!consumed_or_moved_, "Called TryGet after Future already consumed!");
+    std::optional<T> ret = shared_->TryGet();
+    if (ret) {
+      consumed_or_moved_ = true;
+    }
+    return ret;
+  }
+
+  /// Block on the corresponding promise to be filled,
+  /// returning the inner item when ready.
+  T Wait() && {
+    MG_ASSERT(!consumed_or_moved_, "Future should only be consumed with Wait once!");
+    T ret = shared_->Wait();
+    consumed_or_moved_ = true;
+    return ret;
+  }
+
+  /// Marks this Future as canceled.
+  void Cancel() {
+    MG_ASSERT(!consumed_or_moved_, "Future::Cancel called on a future that was already moved or consumed!");
+    consumed_or_moved_ = true;
+  }
+};
+
+template <typename T>
+class Promise {
+  std::shared_ptr<details::Shared<T>> shared_;
+  bool filled_or_moved_ = false;
+
+ public:
+  explicit Promise(std::shared_ptr<details::Shared<T>> shared) : shared_(shared) {}
+
+  Promise() = delete;
+  Promise(Promise &&old) noexcept {
+    MG_ASSERT(!old.filled_or_moved_, "Promise moved from after already being moved from or filled.");
+    shared_ = std::move(old.shared_);
+    old.filled_or_moved_ = true;
+  }
+
+  Promise &operator=(Promise &&old) noexcept {
+    MG_ASSERT(!old.filled_or_moved_, "Promise moved from after already being moved from or filled.");
+    shared_ = std::move(old.shared_);
+    old.filled_or_moved_ = true;
+  }
+  Promise(const Promise &) = delete;
+  Promise &operator=(const Promise &) = delete;
+
+  ~Promise() { MG_ASSERT(filled_or_moved_, "Promise destroyed before its associated Future was filled!"); }
+
+  // Fill the expected item into the Future.
+  void Fill(T item) {
+    MG_ASSERT(!filled_or_moved_, "Promise::Fill called on a promise that is already filled or moved!");
+    shared_->Fill(item);
+    filled_or_moved_ = true;
+  }
+
+  bool IsAwaited() { return shared_->IsAwaited(); }
+
+  /// Moves this Promise into a unique_ptr.
+  std::unique_ptr<Promise<T>> ToUnique() && {
+    std::unique_ptr<Promise<T>> up = std::make_unique<Promise<T>>(std::move(shared_));
+
+    filled_or_moved_ = true;
+
+    return up;
+  }
+};
+
+template <typename T>
+std::pair<Future<T>, Promise<T>> FuturePromisePair() {
+  std::shared_ptr<details::Shared<T>> shared = std::make_shared<details::Shared<T>>();
+
+  Future<T> future = Future<T>(shared);
+  Promise<T> promise = Promise<T>(shared);
+
+  return std::make_pair(std::move(future), std::move(promise));
+}
+
+template <typename T>
+std::pair<Future<T>, Promise<T>> FuturePromisePairWithNotifier(std::function<bool()> simulator_notifier) {
+  std::shared_ptr<details::Shared<T>> shared = std::make_shared<details::Shared<T>>(simulator_notifier);
+
+  Future<T> future = Future<T>(shared);
+  Promise<T> promise = Promise<T>(shared);
+
+  return std::make_pair(std::move(future), std::move(promise));
+}
+
+};  // namespace memgraph::io

src/io/rsm/coordinator_rsm.hpp

@@ -0,0 +1,25 @@
+// 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.
+
+#pragma once
+
+#include "coordinator/coordinator.hpp"
+#include "io/rsm/raft.hpp"
+
+namespace memgraph::io::rsm {
+
+// TODO(tyler) don't
+using namespace memgraph::coordinator;
+
+template <typename IoImpl>
+using CoordinatorRsm = io::rsm::Raft<IoImpl, Coordinator, WriteRequests, WriteResponses, ReadRequests, ReadResponses>;
+
+}  // namespace memgraph::io::rsm

src/io/rsm/raft.hpp

@@ -0,0 +1,845 @@
+// 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.
+
+// TODO(tyler) buffer out-of-order Append buffers on the Followers to reassemble more quickly
+// TODO(tyler) handle granular batch sizes based on simple flow control
+
+#pragma once
+
+#include <deque>
+#include <iostream>
+#include <map>
+#include <set>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "io/simulator/simulator.hpp"
+#include "io/transport.hpp"
+
+namespace memgraph::io::rsm {
+
+using memgraph::io::Address;
+using memgraph::io::Duration;
+using memgraph::io::Io;
+using memgraph::io::ResponseFuture;
+using memgraph::io::ResponseResult;
+using memgraph::io::Time;
+
+using Term = uint64_t;
+using LogIndex = uint64_t;
+using RequestId = uint64_t;
+
+template <typename WriteOperation>
+struct WriteRequest {
+  WriteOperation operation;
+};
+
+/// WriteResponse is returned to a client after
+/// their WriteRequest was entered in to the raft
+/// log and it reached consensus.
+///
+/// WriteReturn is the result of applying the WriteRequest to
+/// ReplicatedState, and if the ReplicatedState::write
+/// method is deterministic, all replicas will
+/// have the same ReplicatedState after applying
+/// the submitted WriteRequest.
+template <typename WriteReturn>
+struct WriteResponse {
+  bool success;
+  WriteReturn write_return;
+  std::optional<Address> retry_leader;
+};
+
+template <typename ReadOperation>
+struct ReadRequest {
+  ReadOperation operation;
+};
+
+template <typename ReadReturn>
+struct ReadResponse {
+  bool success;
+  ReadReturn read_return;
+  std::optional<Address> retry_leader;
+};
+
+/// AppendRequest is a raft-level message that the Leader
+/// periodically broadcasts to all Follower peers. This
+/// serves three main roles:
+/// 1. acts as a heartbeat from the Leader to the Follower
+/// 2. replicates new data that the Leader has received to the Follower
+/// 3. informs Follower peers when the commit index has increased,
+///    signalling that it is now safe to apply log items to the
+///    replicated state machine
+template <typename WriteRequest>
+struct AppendRequest {
+  Term term = 0;
+  LogIndex last_log_index;
+  Term last_log_term;
+  std::vector<std::pair<Term, WriteRequest>> entries;
+  LogIndex leader_commit;
+};
+
+struct AppendResponse {
+  bool success;
+  Term term;
+  Term last_log_term;
+  // a small optimization over the raft paper, tells
+  // the leader the offset that we are interested in
+  // to send log offsets from for us. This will only
+  // be useful at the beginning of a leader's term.
+  LogIndex last_log_index;
+};
+
+struct VoteRequest {
+  Term term = 0;
+  LogIndex last_log_index;
+  Term last_log_term;
+};
+
+struct VoteResponse {
+  Term term = 0;
+  LogIndex committed_log_size;
+  bool vote_granted = false;
+};
+
+template <typename WriteRequest>
+struct CommonState {
+  Term term = 0;
+  std::vector<std::pair<Term, WriteRequest>> log;
+  LogIndex committed_log_size = 0;
+  LogIndex applied_size = 0;
+};
+
+struct FollowerTracker {
+  LogIndex next_index = 0;
+  LogIndex confirmed_contiguous_index = 0;
+};
+
+struct PendingClientRequest {
+  RequestId request_id;
+  Address address;
+  Time received_at;
+};
+
+struct Leader {
+  std::map<Address, FollowerTracker> followers;
+  std::unordered_map<LogIndex, PendingClientRequest> pending_client_requests;
+  Time last_broadcast = Time::min();
+
+  std::string ToString() { return "\tLeader   \t"; }
+};
+
+struct Candidate {
+  std::map<Address, LogIndex> successful_votes;
+  Time election_began = Time::min();
+  std::set<Address> outstanding_votes;
+
+  std::string ToString() { return "\tCandidate\t"; }
+};
+
+struct Follower {
+  Time last_received_append_entries_timestamp;
+  Address leader_address;
+
+  std::string ToString() { return "\tFollower \t"; }
+};
+
+using Role = std::variant<Candidate, Leader, Follower>;
+
+/*
+
+all ReplicatedState classes should have an Apply method
+that returns our WriteResponseValue after consensus, and
+a Read method that returns our ReadResponseValue without
+requiring consensus.
+
+ReadResponse Read(ReadOperation);
+WriteResponseValue ReplicatedState::Apply(WriteRequest);
+
+For example:
+If the state is uint64_t, and WriteRequest is `struct PlusOne {};`,
+and WriteResponseValue is also uint64_t (the new value), then
+each call to state.Apply(PlusOne{}) will return the new value
+after incrementing it. 0, 1, 2, 3... and this will be sent back
+to the client that requested the mutation.
+
+In practice, these mutations will usually be predicated on some
+previous value, so that they are idempotent, functioning similarly
+to a CAS operation.
+*/
+template <typename WriteOperation, typename ReadOperation, typename ReplicatedState, typename WriteResponseValue,
+          typename ReadResponseValue>
+concept Rsm = requires(ReplicatedState state, WriteOperation w, ReadOperation r) {
+  { state.Read(r) } -> std::same_as<ReadResponseValue>;
+  { state.Apply(w) } -> std::same_as<WriteResponseValue>;
+};
+
+/// Parameter           Purpose
+/// --------------------------
+/// IoImpl              the concrete Io provider - SimulatorTransport, ThriftTransport, etc...
+/// ReplicatedState     the high-level data structure that is managed by the raft-backed replicated state machine
+/// WriteOperation      the individual operation type that is applied to the ReplicatedState in identical order
+///                     across each replica
+/// WriteResponseValue  the return value of calling ReplicatedState::Apply(WriteOperation), which is executed in
+///                     identical order across all replicas after an WriteOperation reaches consensus.
+/// ReadOperation       the type of operations that do not require consensus before executing directly
+///                     on a const ReplicatedState &
+/// ReadResponseValue   the return value of calling ReplicatedState::Read(ReadOperation), which is executed directly
+///                     without going through consensus first
+template <typename IoImpl, typename ReplicatedState, typename WriteOperation, typename WriteResponseValue,
+          typename ReadOperation, typename ReadResponseValue>
+requires Rsm<WriteOperation, ReadOperation, ReplicatedState, WriteResponseValue, ReadResponseValue>
+class Raft {
+  CommonState<WriteOperation> state_;
+  Role role_ = Candidate{};
+  Io<IoImpl> io_;
+  std::vector<Address> peers_;
+  ReplicatedState replicated_state_;
+
+ public:
+  Raft(Io<IoImpl> &&io, std::vector<Address> peers, ReplicatedState &&replicated_state)
+      : io_(std::move(io)), peers_(peers), replicated_state_(std::move(replicated_state)) {}
+
+  void Run() {
+    Time last_cron = io_.Now();
+
+    while (!io_.ShouldShutDown()) {
+      const auto now = io_.Now();
+      const Duration random_cron_interval = RandomTimeout(1000, 2000);
+      if (now - last_cron > random_cron_interval) {
+        Cron();
+        last_cron = now;
+      }
+
+      Duration receive_timeout = RandomTimeout(10000, 50000);
+
+      auto request_result =
+          io_.template ReceiveWithTimeout<ReadRequest<ReadOperation>, AppendRequest<WriteOperation>, AppendResponse,
+                                          WriteRequest<WriteOperation>, VoteRequest, VoteResponse>(receive_timeout);
+      if (request_result.HasError()) {
+        continue;
+      }
+
+      auto request = std::move(request_result.GetValue());
+
+      Handle(std::move(request.message), request.request_id, request.from_address);
+    }
+  }
+
+ private:
+  // Raft paper - 5.3
+  // When the entry has been safely replicated, the leader applies the
+  // entry to its state machine and returns the result of that
+  // execution to the client.
+  //
+  // "Safely replicated" is defined as being known to be present
+  // on at least a majority of all peers (inclusive of the Leader).
+  void BumpCommitIndexAndReplyToClients(Leader &leader) {
+    auto indices = std::vector<LogIndex>{};
+
+    // We include our own log size in the calculation of the log
+    // index that is present on at least a majority of all peers.
+    indices.push_back(state_.log.size());
+
+    for (const auto &[addr, f] : leader.followers) {
+      indices.push_back(f.confirmed_contiguous_index);
+      Log("at port ", addr.last_known_port, " has confirmed contiguous index of: ", f.confirmed_contiguous_index);
+    }
+
+    // reverse sort from highest to lowest (using std::ranges::greater)
+    std::ranges::sort(indices, std::ranges::greater());
+
+    // This is a particularly correctness-critical calculation because it
+    // determines which index we will consider to be the committed index.
+    //
+    // If the following indexes are recorded for clusters of different sizes,
+    // these are the expected indexes that are considered to have reached
+    // consensus:
+    // state           | expected value | (indices.size() / 2)
+    // [1]              1                 (1 / 2) => 0
+    // [2, 1]           1                 (2 / 2) => 1
+    // [3, 2, 1]        2                 (3 / 2) => 1
+    // [4, 3, 2, 1]     2                 (4 / 2) => 2
+    // [5, 4, 3, 2, 1]  3                 (5 / 2) => 2
+    size_t index_present_on_majority = indices.size() / 2;
+    LogIndex new_committed_log_size = indices[index_present_on_majority];
+
+    // We never go backwards in history.
+    MG_ASSERT(state_.committed_log_size <= new_committed_log_size);
+
+    state_.committed_log_size = new_committed_log_size;
+
+    // For each index between the old index and the new one (inclusive),
+    // Apply that log's WriteOperation to our replicated_state_,
+    // and use the specific return value of the ReplicatedState::Apply
+    // method (WriteResponseValue) to respond to the requester.
+    for (; state_.applied_size < state_.committed_log_size; state_.applied_size++) {
+      const LogIndex apply_index = state_.applied_size;
+      const auto &write_request = state_.log[apply_index].second;
+      WriteResponseValue write_return = replicated_state_.Apply(write_request);
+
+      if (leader.pending_client_requests.contains(apply_index)) {
+        PendingClientRequest client_request = std::move(leader.pending_client_requests.at(apply_index));
+
+        WriteResponse<WriteResponseValue> resp;
+        resp.success = true;
+        resp.write_return = std::move(write_return);
+
+        io_.Send(client_request.address, client_request.request_id, std::move(resp));
+        leader.pending_client_requests.erase(apply_index);
+      }
+    }
+
+    Log("committed_log_size is now ", state_.committed_log_size);
+  }
+
+  // Raft paper - 5.1
+  // AppendEntries RPCs are initiated by leaders to replicate log entries and to provide a form of heartbeat
+  void BroadcastAppendEntries(std::map<Address, FollowerTracker> &followers) {
+    for (auto &[address, follower] : followers) {
+      const LogIndex index = follower.confirmed_contiguous_index;
+
+      std::vector<std::pair<Term, WriteOperation>> entries;
+
+      if (state_.log.size() > index) {
+        entries.insert(entries.begin(), state_.log.begin() + index, state_.log.end());
+      }
+
+      const Term previous_term_from_index = PreviousTermFromIndex(index);
+
+      Log("sending ", entries.size(), " entries to Follower ", address.last_known_port,
+          " which are above its known index of ", index);
+
+      AppendRequest<WriteOperation> ar{
+          .term = state_.term,
+          .last_log_index = index,
+          .last_log_term = previous_term_from_index,
+          .entries = entries,
+          .leader_commit = state_.committed_log_size,
+      };
+
+      // request_id not necessary to set because it's not a Future-backed Request.
+      static constexpr RequestId request_id = 0;
+
+      io_.Send(address, request_id, ar);
+    }
+  }
+
+  // Raft paper - 5.2
+  // Raft uses randomized election timeouts to ensure that split votes are rare and that they are resolved quickly
+  Duration RandomTimeout(Duration min, Duration max) {
+    std::uniform_int_distribution time_distrib(min.count(), max.count());
+
+    auto rand_micros = io_.Rand(time_distrib);
+
+    return std::chrono::microseconds{rand_micros};
+  }
+
+  Duration RandomTimeout(int min_micros, int max_micros) {
+    std::uniform_int_distribution time_distrib(min_micros, max_micros);
+
+    int rand_micros = io_.Rand(time_distrib);
+
+    return std::chrono::microseconds{rand_micros};
+  }
+
+  Term PreviousTermFromIndex(LogIndex index) const {
+    if (index == 0 || state_.log.size() + 1 <= index) {
+      return 0;
+    }
+
+    const auto &[term, data] = state_.log.at(index - 1);
+    return term;
+  }
+
+  LogIndex CommittedLogIndex() { return state_.committed_log_size; }
+
+  Term CommittedLogTerm() {
+    MG_ASSERT(state_.log.size() >= state_.committed_log_size);
+    if (state_.log.empty() || state_.committed_log_size == 0) {
+      return 0;
+    }
+
+    auto &[term, data] = state_.log.at(state_.committed_log_size - 1);
+    return term;
+  }
+
+  LogIndex LastLogIndex() { return state_.log.size(); }
+
+  Term LastLogTerm() const {
+    if (state_.log.empty()) {
+      return 0;
+    }
+
+    const auto &[term, data] = state_.log.back();
+    return term;
+  }
+
+  template <typename... Ts>
+  void Log(Ts &&...args) {
+    const Time now = io_.Now();
+    auto micros = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
+
+    const Term term = state_.term;
+
+    std::ostringstream out;
+
+    out << '\t' << (int)micros << "\t" << term << "\t" << io_.GetAddress().last_known_port;
+
+    std::string role_string = std::visit([&](auto &&role) { return role.ToString(); }, role_);
+
+    out << role_string;
+
+    (out << ... << args);
+
+    spdlog::debug(out.str());
+  }
+
+  /////////////////////////////////////////////////////////////
+  /// Raft-related Cron methods
+  ///
+  /// Cron + std::visit is how events are dispatched
+  /// to certain code based on Raft role.
+  ///
+  /// Cron(role) takes as the first argument a reference to its
+  /// role, and as the second argument, the message that has
+  /// been received.
+  /////////////////////////////////////////////////////////////
+
+  /// Periodic protocol maintenance.
+  void Cron() {
+    // dispatch periodic logic based on our role to a specific Cron method.
+    std::optional<Role> new_role = std::visit([&](auto &&role) { return Cron(role); }, role_);
+
+    if (new_role) {
+      role_ = std::move(new_role).value();
+    }
+  }
+
+  // Raft paper - 5.2
+  // Candidates keep sending Vote to peers until:
+  // 1. receiving Append with a higher term (become Follower)
+  // 2. receiving Vote with a higher term (become a Follower)
+  // 3. receiving a quorum of responses to our last batch of Vote (become a Leader)
+  std::optional<Role> Cron(Candidate &candidate) {
+    const auto now = io_.Now();
+    const Duration election_timeout = RandomTimeout(100000, 200000);
+    const auto election_timeout_us = std::chrono::duration_cast<std::chrono::milliseconds>(election_timeout).count();
+
+    if (now - candidate.election_began > election_timeout) {
+      state_.term++;
+      Log("becoming Candidate for term ", state_.term, " after leader timeout of ", election_timeout_us,
+          " elapsed since last election attempt");
+
+      const VoteRequest request{
+          .term = state_.term,
+          .last_log_index = LastLogIndex(),
+          .last_log_term = LastLogTerm(),
+      };
+
+      auto outstanding_votes = std::set<Address>();
+
+      for (const auto &peer : peers_) {
+        // request_id not necessary to set because it's not a Future-backed Request.
+        static constexpr auto request_id = 0;
+        io_.template Send<VoteRequest>(peer, request_id, request);
+        outstanding_votes.insert(peer);
+      }
+
+      return Candidate{
+          .successful_votes = std::map<Address, LogIndex>(),
+          .election_began = now,
+          .outstanding_votes = outstanding_votes,
+      };
+    }
+    return std::nullopt;
+  }
+
+  // Raft paper - 5.2
+  // Followers become candidates if we haven't heard from the leader
+  // after a randomized timeout.
+  std::optional<Role> Cron(Follower &follower) {
+    const auto now = io_.Now();
+    const auto time_since_last_append_entries = now - follower.last_received_append_entries_timestamp;
+    Duration election_timeout = RandomTimeout(100000, 200000);
+
+    // randomized follower timeout with a range of 100-150ms.
+    if (time_since_last_append_entries > election_timeout) {
+      // become a Candidate if we haven't heard from the Leader after this timeout
+      return Candidate{};
+    }
+
+    return std::nullopt;
+  }
+
+  // Leaders (re)send AppendRequest to followers.
+  std::optional<Role> Cron(Leader &leader) {
+    const Time now = io_.Now();
+    const Duration broadcast_timeout = RandomTimeout(40000, 60000);
+
+    if (now - leader.last_broadcast > broadcast_timeout) {
+      BroadcastAppendEntries(leader.followers);
+      leader.last_broadcast = now;
+    }
+
+    return std::nullopt;
+  }
+
+  /////////////////////////////////////////////////////////////
+  /// Raft-related Handle methods
+  ///
+  /// Handle + std::visit is how events are dispatched
+  /// to certain code based on Raft role.
+  ///
+  /// Handle(role, message, ...)
+  /// takes as the first argument a reference
+  /// to its role, and as the second argument, the
+  /// message that has been received.
+  /////////////////////////////////////////////////////////////
+
+  void Handle(std::variant<ReadRequest<ReadOperation>, AppendRequest<WriteOperation>, AppendResponse,
+                           WriteRequest<WriteOperation>, VoteRequest, VoteResponse> &&message_variant,
+              RequestId request_id, Address from_address) {
+    // dispatch the message to a handler based on our role,
+    // which can be specified in the Handle first argument,
+    // or it can be `auto` if it's a handler for several roles
+    // or messages.
+    std::optional<Role> new_role =
+        std::visit([&](auto &&msg, auto &&role) { return Handle(role, std::move(msg), request_id, from_address); },
+                   std::move(message_variant), role_);
+
+    // TODO(tyler) (M3) maybe replace std::visit with get_if for explicit prioritized matching, [[likely]] etc...
+    if (new_role) {
+      role_ = std::move(new_role).value();
+    }
+  }
+
+  // all roles can receive Vote and possibly become a follower
+  template <typename AllRoles>
+  std::optional<Role> Handle(AllRoles &, VoteRequest &&req, RequestId request_id, Address from_address) {
+    Log("received Vote from ", from_address.last_known_port, " with term ", req.term);
+    const bool last_log_term_dominates = req.last_log_term >= LastLogTerm();
+    const bool term_dominates = req.term > state_.term;
+    const bool last_log_index_dominates = req.last_log_index >= LastLogIndex();
+    const bool new_leader = last_log_term_dominates && term_dominates && last_log_index_dominates;
+
+    if (new_leader) {
+      MG_ASSERT(req.term > state_.term);
+      MG_ASSERT(std::max(req.term, state_.term) == req.term);
+    }
+
+    const VoteResponse res{
+        .term = std::max(req.term, state_.term),
+        .committed_log_size = state_.committed_log_size,
+        .vote_granted = new_leader,
+    };
+
+    io_.Send(from_address, request_id, res);
+
+    if (new_leader) {
+      // become a follower
+      state_.term = req.term;
+      return Follower{
+          .last_received_append_entries_timestamp = io_.Now(),
+          .leader_address = from_address,
+      };
+    } else if (term_dominates) {
+      Log("received a vote from an inferior candidate. Becoming Candidate");
+      state_.term = std::max(state_.term, req.term) + 1;
+      return Candidate{};
+    }
+
+    return std::nullopt;
+  }
+
+  std::optional<Role> Handle(Candidate &candidate, VoteResponse &&res, RequestId, Address from_address) {
+    Log("received VoteResponse");
+
+    if (!res.vote_granted || res.term != state_.term) {
+      Log("received unsuccessful VoteResponse from term ", res.term, " when our candidacy term is ", state_.term);
+      // we received a delayed VoteResponse from the past, which has to do with an election that is
+      // no longer valid. We can simply drop this.
+      return std::nullopt;
+    }
+
+    MG_ASSERT(candidate.outstanding_votes.contains(from_address),
+              "Received unexpected VoteResponse from server not present in Candidate's outstanding_votes!");
+    candidate.outstanding_votes.erase(from_address);
+
+    MG_ASSERT(!candidate.successful_votes.contains(from_address),
+              "Received unexpected VoteResponse from server already in Candidate's successful_votes!");
+    candidate.successful_votes.insert({from_address, res.committed_log_size});
+
+    if (candidate.successful_votes.size() >= candidate.outstanding_votes.size()) {
+      std::map<Address, FollowerTracker> followers{};
+
+      for (const auto &[address, committed_log_size] : candidate.successful_votes) {
+        FollowerTracker follower{
+            .next_index = committed_log_size,
+            .confirmed_contiguous_index = committed_log_size,
+        };
+        followers.insert({address, follower});
+      }
+      for (const auto &address : candidate.outstanding_votes) {
+        FollowerTracker follower{
+            .next_index = state_.log.size(),
+            .confirmed_contiguous_index = 0,
+        };
+        followers.insert({address, follower});
+      }
+
+      Log("becoming Leader at term ", state_.term);
+
+      BroadcastAppendEntries(followers);
+
+      return Leader{
+          .followers = std::move(followers),
+          .pending_client_requests = std::unordered_map<LogIndex, PendingClientRequest>(),
+      };
+    }
+
+    return std::nullopt;
+  }
+
+  template <typename AllRoles>
+  std::optional<Role> Handle(AllRoles &, VoteResponse &&, RequestId, Address) {
+    Log("non-Candidate received VoteResponse");
+    return std::nullopt;
+  }
+
+  template <typename AllRoles>
+  std::optional<Role> Handle(AllRoles &role, AppendRequest<WriteOperation> &&req, RequestId request_id,
+                             Address from_address) {
+    AppendResponse res{
+        .success = false,
+        .term = state_.term,
+        .last_log_term = CommittedLogTerm(),
+        .last_log_index = CommittedLogIndex(),
+    };
+
+    if constexpr (std::is_same<AllRoles, Leader>()) {
+      MG_ASSERT(req.term != state_.term, "Multiple leaders are acting under the term ", req.term);
+    }
+
+    const bool is_candidate = std::is_same<AllRoles, Candidate>();
+    const bool is_failed_competitor = is_candidate && req.term == state_.term;
+    const Time now = io_.Now();
+
+    // Raft paper - 5.2
+    // While waiting for votes, a candidate may receive an
+    // AppendEntries RPC from another server claiming to be leader. If
+    // the leader’s term (included in its RPC) is at least as large as
+    // the candidate’s current term, then the candidate recognizes the
+    // leader as legitimate and returns to follower state.
+    if (req.term > state_.term || is_failed_competitor) {
+      // become follower of this leader, reply with our log status
+      state_.term = req.term;
+
+      io_.Send(from_address, request_id, res);
+
+      Log("becoming Follower of Leader ", from_address.last_known_port, " at term ", req.term);
+      return Follower{
+          .last_received_append_entries_timestamp = now,
+          .leader_address = from_address,
+      };
+    } else if (req.term < state_.term) {
+      // nack this request from an old leader
+      io_.Send(from_address, request_id, res);
+
+      return std::nullopt;
+    }
+
+    // at this point, we're dealing with our own leader
+    if constexpr (std::is_same<AllRoles, Follower>()) {
+      // small specialization for when we're already a Follower
+      MG_ASSERT(role.leader_address == from_address, "Multiple Leaders are acting under the same term number!");
+      role.last_received_append_entries_timestamp = now;
+    } else {
+      Log("Somehow entered Follower-specific logic as a non-Follower");
+      MG_ASSERT(false, "Somehow entered Follower-specific logic as a non-Follower");
+    }
+
+    res.last_log_term = LastLogTerm();
+    res.last_log_index = LastLogIndex();
+
+    Log("returning last_log_index of ", res.last_log_index);
+
+    // Handle steady-state conditions.
+    if (req.last_log_index != LastLogIndex()) {
+      Log("req.last_log_index is above our last applied log index");
+    } else if (req.last_log_term != LastLogTerm()) {
+      Log("req.last_log_term differs from our leader term at that slot, expected: ", LastLogTerm(), " but got ",
+          req.last_log_term);
+    } else {
+      // happy path - Apply log
+      Log("applying batch of entries to log of size ", req.entries.size());
+
+      MG_ASSERT(req.last_log_index >= state_.committed_log_size,
+                "Applied history from Leader which goes back in time from our commit_index");
+
+      // possibly chop-off stuff that was replaced by
+      // things with different terms (we got data that
+      // hasn't reached consensus yet, which is normal)
+      state_.log.resize(req.last_log_index);
+
+      state_.log.insert(state_.log.end(), req.entries.begin(), req.entries.end());
+
+      MG_ASSERT(req.leader_commit >= state_.committed_log_size);
+      state_.committed_log_size = std::min(req.leader_commit, LastLogIndex());
+
+      for (; state_.applied_size < state_.committed_log_size; state_.applied_size++) {
+        const auto &write_request = state_.log[state_.applied_size].second;
+        replicated_state_.Apply(write_request);
+      }
+
+      res.success = true;
+    }
+
+    io_.Send(from_address, request_id, res);
+
+    return std::nullopt;
+  }
+
+  std::optional<Role> Handle(Leader &leader, AppendResponse &&res, RequestId, Address from_address) {
+    if (res.term != state_.term) {
+    } else if (!leader.followers.contains(from_address)) {
+      Log("received AppendResponse from unknown Follower");
+      MG_ASSERT(false, "received AppendResponse from unknown Follower");
+    } else {
+      if (res.success) {
+        Log("got successful AppendResponse from ", from_address.last_known_port, " with last_log_index of ",
+            res.last_log_index);
+      } else {
+        Log("got unsuccessful AppendResponse from ", from_address.last_known_port, " with last_log_index of ",
+            res.last_log_index);
+      }
+      FollowerTracker &follower = leader.followers.at(from_address);
+      follower.next_index = std::max(follower.next_index, res.last_log_index);
+      follower.confirmed_contiguous_index = std::max(follower.confirmed_contiguous_index, res.last_log_index);
+
+      BumpCommitIndexAndReplyToClients(leader);
+    }
+    return std::nullopt;
+  }
+
+  template <typename AllRoles>
+  std::optional<Role> Handle(AllRoles &, AppendResponse &&, RequestId, Address) {
+    // we used to be the leader, and are getting old delayed responses
+    return std::nullopt;
+  }
+
+  /////////////////////////////////////////////////////////////
+  /// RSM-related handle methods
+  /////////////////////////////////////////////////////////////
+
+  // Leaders are able to immediately respond to the requester (with a ReadResponseValue) applied to the ReplicatedState
+  std::optional<Role> Handle(Leader &, ReadRequest<ReadOperation> &&req, RequestId request_id, Address from_address) {
+    Log("handling ReadOperation");
+    ReadOperation read_operation = req.operation;
+
+    ReadResponseValue read_return = replicated_state_.Read(read_operation);
+
+    ReadResponse<ReadResponseValue> resp{
+        .success = true,
+        .read_return = std::move(read_return),
+        .retry_leader = std::nullopt,
+    };
+
+    io_.Send(from_address, request_id, resp);
+
+    return std::nullopt;
+  }
+
+  // Candidates should respond with a failure, similar to the Candidate + WriteRequest failure below
+  std::optional<Role> Handle(Candidate &, ReadRequest<ReadOperation> &&, RequestId request_id, Address from_address) {
+    Log("received ReadOperation - not redirecting because no Leader is known");
+    auto res = ReadResponse<ReadResponseValue>{};
+
+    res.success = false;
+
+    Cron();
+
+    io_.Send(from_address, request_id, res);
+
+    return std::nullopt;
+  }
+
+  // Followers should respond with a redirection, similar to the Follower + WriteRequest response below
+  std::optional<Role> Handle(Follower &follower, ReadRequest<ReadOperation> &&, RequestId request_id,
+                             Address from_address) {
+    auto res = ReadResponse<ReadResponseValue>{};
+
+    res.success = false;
+    Log("redirecting client to known Leader with port ", follower.leader_address.last_known_port);
+    res.retry_leader = follower.leader_address;
+
+    io_.Send(from_address, request_id, res);
+
+    return std::nullopt;
+  }
+
+  // Raft paper - 8
+  // When a client first starts up, it connects to a randomly chosen
+  // server. If the client’s first choice is not the leader, that
+  // server will reject the client’s request and supply information
+  // about the most recent leader it has heard from.
+  std::optional<Role> Handle(Follower &follower, WriteRequest<WriteOperation> &&, RequestId request_id,
+                             Address from_address) {
+    auto res = WriteResponse<WriteResponseValue>{};
+
+    res.success = false;
+    Log("redirecting client to known Leader with port ", follower.leader_address.last_known_port);
+    res.retry_leader = follower.leader_address;
+
+    io_.Send(from_address, request_id, res);
+
+    return std::nullopt;
+  }
+
+  std::optional<Role> Handle(Candidate &, WriteRequest<WriteOperation> &&, RequestId request_id, Address from_address) {
+    Log("received WriteRequest - not redirecting because no Leader is known");
+    auto res = WriteResponse<WriteResponseValue>{};
+
+    res.success = false;
+
+    Cron();
+
+    io_.Send(from_address, request_id, res);
+
+    return std::nullopt;
+  }
+
+  // only leaders actually handle replication requests from clients
+  std::optional<Role> Handle(Leader &leader, WriteRequest<WriteOperation> &&req, RequestId request_id,
+                             Address from_address) {
+    Log("handling WriteRequest");
+
+    // we are the leader. add item to log and send Append to peers
+    state_.log.emplace_back(std::pair(state_.term, std::move(req.operation)));
+
+    LogIndex log_index = state_.log.size() - 1;
+
+    PendingClientRequest pcr{
+        .request_id = request_id,
+        .address = from_address,
+        .received_at = io_.Now(),
+    };
+
+    leader.pending_client_requests.emplace(log_index, pcr);
+
+    BroadcastAppendEntries(leader.followers);
+
+    return std::nullopt;
+  }
+};
+
+};  // namespace memgraph::io::rsm

src/io/rsm/rsm_client.hpp

@@ -0,0 +1,137 @@
+// 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 <iostream>
+#include <optional>
+#include <vector>
+
+#include "io/address.hpp"
+#include "io/rsm/raft.hpp"
+#include "utils/result.hpp"
+
+namespace memgraph::io::rsm {
+
+using memgraph::io::Address;
+using memgraph::io::Duration;
+using memgraph::io::ResponseEnvelope;
+using memgraph::io::ResponseFuture;
+using memgraph::io::ResponseResult;
+using memgraph::io::Time;
+using memgraph::io::TimedOut;
+using memgraph::io::rsm::ReadRequest;
+using memgraph::io::rsm::ReadResponse;
+using memgraph::io::rsm::WriteRequest;
+using memgraph::io::rsm::WriteResponse;
+using memgraph::utils::BasicResult;
+
+template <typename IoImpl, typename WriteRequestT, typename WriteResponseT, typename ReadRequestT,
+          typename ReadResponseT>
+class RsmClient {
+  using ServerPool = std::vector<Address>;
+
+  IoImpl io_;
+  Address leader_;
+
+  std::mt19937 cli_rng_{0};
+  ServerPool server_addrs_;
+
+  template <typename ResponseT>
+  void PossiblyRedirectLeader(const ResponseT &response) {
+    if (response.retry_leader) {
+      MG_ASSERT(!response.success, "retry_leader should never be set for successful responses");
+      leader_ = response.retry_leader.value();
+      spdlog::debug("client redirected to leader server {}", leader_.ToString());
+    } else if (!response.success) {
+      std::uniform_int_distribution<size_t> addr_distrib(0, (server_addrs_.size() - 1));
+      size_t addr_index = addr_distrib(cli_rng_);
+      leader_ = server_addrs_[addr_index];
+
+      spdlog::debug(
+          "client NOT redirected to leader server despite our success failing to be processed (it probably was sent to "
+          "a RSM Candidate) trying a random one at index {} with address {}",
+          addr_index, leader_.ToString());
+    }
+  }
+
+ public:
+  RsmClient(IoImpl io, Address leader, ServerPool server_addrs)
+      : io_{io}, leader_{leader}, server_addrs_{server_addrs} {}
+
+  RsmClient() = delete;
+
+  BasicResult<TimedOut, WriteResponseT> SendWriteRequest(WriteRequestT req) {
+    WriteRequest<WriteRequestT> client_req;
+    client_req.operation = req;
+
+    const Duration overall_timeout = io_.GetDefaultTimeout();
+    const Time before = io_.Now();
+
+    do {
+      spdlog::debug("client sending WriteRequest to Leader {}", leader_.ToString());
+      ResponseFuture<WriteResponse<WriteResponseT>> response_future =
+          io_.template Request<WriteRequest<WriteRequestT>, WriteResponse<WriteResponseT>>(leader_, client_req);
+      ResponseResult<WriteResponse<WriteResponseT>> response_result = std::move(response_future).Wait();
+
+      if (response_result.HasError()) {
+        spdlog::debug("client timed out while trying to communicate with leader server {}", leader_.ToString());
+        // continue;
+        return response_result.GetError();
+      }
+
+      ResponseEnvelope<WriteResponse<WriteResponseT>> &&response_envelope = std::move(response_result.GetValue());
+      WriteResponse<WriteResponseT> &&write_response = std::move(response_envelope.message);
+
+      if (write_response.success) {
+        return std::move(write_response.write_return);
+      }
+
+      PossiblyRedirectLeader(write_response);
+    } while (io_.Now() < before + overall_timeout);
+
+    return TimedOut{};
+  }
+
+  BasicResult<TimedOut, ReadResponseT> SendReadRequest(ReadRequestT req) {
+    ReadRequest<ReadRequestT> read_req;
+    read_req.operation = req;
+
+    const Duration overall_timeout = io_.GetDefaultTimeout();
+    const Time before = io_.Now();
+
+    do {
+      spdlog::debug("client sending ReadRequest to Leader {}", leader_.ToString());
+
+      ResponseFuture<ReadResponse<ReadResponseT>> get_response_future =
+          io_.template Request<ReadRequest<ReadRequestT>, ReadResponse<ReadResponseT>>(leader_, read_req);
+
+      // receive response
+      ResponseResult<ReadResponse<ReadResponseT>> get_response_result = std::move(get_response_future).Wait();
+
+      if (get_response_result.HasError()) {
+        spdlog::debug("client timed out while trying to communicate with leader server {}", leader_.ToString());
+        return get_response_result.GetError();
+      }
+
+      ResponseEnvelope<ReadResponse<ReadResponseT>> &&get_response_envelope = std::move(get_response_result.GetValue());
+      ReadResponse<ReadResponseT> &&read_get_response = std::move(get_response_envelope.message);
+
+      if (read_get_response.success) {
+        return std::move(read_get_response.read_return);
+      }
+
+      PossiblyRedirectLeader(read_get_response);
+    } while (io_.Now() < before + overall_timeout);
+
+    return TimedOut{};
+  }
+};
+
+}  // namespace memgraph::io::rsm

src/io/rsm/shard_rsm.hpp

@@ -0,0 +1,165 @@
+// 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.
+
+#pragma once
+
+/// The StorageRsm is a simple in-memory raft-backed kv store that can be used for simple testing
+/// and implementation of some query engine logic before storage engines are fully implemented.
+///
+/// To implement multiple read and write commands, change the StorageRead* and StorageWrite* requests
+/// and responses to a std::variant of the different options, and route them to specific handlers in
+/// the StorageRsm's Read and Apply methods. Remember that Read is called immediately when the Raft
+/// leader receives the request, and does not replicate anything over Raft. Apply is called only
+/// AFTER the StorageWriteRequest is replicated to a majority of Raft peers, and the result of calling
+/// StorageRsm::Apply(StorageWriteRequest) is returned to the client that submitted the request.
+
+#include <deque>
+#include <iostream>
+#include <map>
+#include <optional>
+#include <set>
+#include <thread>
+#include <vector>
+
+#include "coordinator/hybrid_logical_clock.hpp"
+#include "io/address.hpp"
+#include "io/rsm/raft.hpp"
+#include "io/simulator/simulator.hpp"
+#include "io/simulator/simulator_transport.hpp"
+#include "storage/v2/property_value.hpp"
+#include "utils/logging.hpp"
+
+using memgraph::coordinator::Hlc;
+using memgraph::io::Address;
+using memgraph::io::Io;
+using memgraph::io::ResponseEnvelope;
+using memgraph::io::ResponseFuture;
+using memgraph::io::ResponseResult;
+using memgraph::io::rsm::Raft;
+using memgraph::io::rsm::ReadRequest;
+using memgraph::io::rsm::ReadResponse;
+using memgraph::io::rsm::WriteRequest;
+using memgraph::io::rsm::WriteResponse;
+using memgraph::io::simulator::Simulator;
+using memgraph::io::simulator::SimulatorConfig;
+using memgraph::io::simulator::SimulatorStats;
+using memgraph::io::simulator::SimulatorTransport;
+using memgraph::storage::PropertyValue;
+
+namespace memgraph::io::rsm {
+
+using ShardRsmKey = std::vector<PropertyValue>;
+
+struct StorageWriteRequest {
+  ShardRsmKey key;
+  std::optional<int> value;
+};
+
+struct StorageWriteResponse {
+  bool shard_rsm_success;
+  std::optional<int> last_value;
+  // Only has a value if the given shard does not contain the requested key
+  std::optional<Hlc> latest_known_shard_map_version{std::nullopt};
+};
+
+struct StorageReadRequest {
+  ShardRsmKey key;
+};
+
+struct StorageReadResponse {
+  bool shard_rsm_success;
+  std::optional<int> value;
+  // Only has a value if the given shard does not contain the requested key
+  std::optional<Hlc> latest_known_shard_map_version{std::nullopt};
+};
+
+class StorageRsm {
+  std::map<ShardRsmKey, int> state_;
+  ShardRsmKey minimum_key_;
+  std::optional<ShardRsmKey> maximum_key_{std::nullopt};
+  Hlc shard_map_version_;
+
+  // The key is not located in this shard
+  bool IsKeyInRange(const ShardRsmKey &key) {
+    if (maximum_key_) [[likely]] {
+      return (key >= minimum_key_ && key <= maximum_key_);
+    }
+    return key >= minimum_key_;
+  }
+
+ public:
+  StorageReadResponse Read(StorageReadRequest request) {
+    StorageReadResponse ret;
+
+    if (!IsKeyInRange(request.key)) {
+      ret.latest_known_shard_map_version = shard_map_version_;
+      ret.shard_rsm_success = false;
+    } else if (state_.contains(request.key)) {
+      ret.value = state_[request.key];
+      ret.shard_rsm_success = true;
+    } else {
+      ret.shard_rsm_success = false;
+      ret.value = std::nullopt;
+    }
+    return ret;
+  }
+
+  StorageWriteResponse Apply(StorageWriteRequest request) {
+    StorageWriteResponse ret;
+
+    // Key is outside the prohibited range
+    if (!IsKeyInRange(request.key)) {
+      ret.latest_known_shard_map_version = shard_map_version_;
+      ret.shard_rsm_success = false;
+    }
+    // Key exist
+    else if (state_.contains(request.key)) {
+      auto &val = state_[request.key];
+
+      /*
+       *   Delete
+       */
+      if (!request.value) {
+        ret.shard_rsm_success = true;
+        ret.last_value = val;
+        state_.erase(state_.find(request.key));
+      }
+
+      /*
+       *   Update
+       */
+      // Does old_value match?
+      if (request.value == val) {
+        ret.last_value = val;
+        ret.shard_rsm_success = true;
+
+        val = request.value.value();
+
+      } else {
+        ret.last_value = val;
+        ret.shard_rsm_success = false;
+      }
+    }
+    /*
+     *   Create
+     */
+    else {
+      ret.last_value = std::nullopt;
+      ret.shard_rsm_success = true;
+
+      state_.emplace(request.key, std::move(request.value).value());
+    }
+
+    return ret;
+  }
+};
+
+}  // namespace memgraph::io::rsm

src/io/simulator/CMakeLists.txt

@@ -0,0 +1,8 @@
+set(io_simulator_sources
+    simulator_handle.cpp)
+
+find_package(fmt REQUIRED)
+find_package(Threads REQUIRED)
+
+add_library(mg-io-simulator STATIC ${io_simulator_sources})
+target_link_libraries(mg-io-simulator stdc++fs Threads::Threads fmt::fmt mg-utils)

src/io/simulator/message_conversion.hpp

@@ -0,0 +1,177 @@
+// 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.
+
+#pragma once
+
+#include "io/transport.hpp"
+
+namespace memgraph::io::simulator {
+
+using memgraph::io::Duration;
+using memgraph::io::Message;
+using memgraph::io::Time;
+
+struct OpaqueMessage {
+  Address from_address;
+  uint64_t request_id;
+  std::any message;
+
+  /// Recursively tries to match a specific type from the outer
+  /// variant's parameter pack against the type of the std::any,
+  /// and if it matches, make it concrete and return it. Otherwise,
+  /// move on and compare the any with the next type from the
+  /// parameter pack.
+  ///
+  /// Return is the full std::variant<Ts...> type that holds the
+  /// full parameter pack without interfering with recursive
+  /// narrowing expansion.
+  template <typename Return, Message Head, Message... Rest>
+  std::optional<Return> Unpack(std::any &&a) {
+    if (typeid(Head) == a.type()) {
+      Head concrete = std::any_cast<Head>(std::move(a));
+      return concrete;
+    }
+
+    if constexpr (sizeof...(Rest) > 0) {
+      return Unpack<Return, Rest...>(std::move(a));
+    } else {
+      return std::nullopt;
+    }
+  }
+
+  /// High level "user-facing" conversion function that lets
+  /// people interested in conversion only supply a single
+  /// parameter pack for the types that they want to compare
+  /// with the any and potentially include in the returned
+  /// variant.
+  template <Message... Ms>
+  requires(sizeof...(Ms) > 0) std::optional<std::variant<Ms...>> VariantFromAny(std::any &&a) {
+    return Unpack<std::variant<Ms...>, Ms...>(std::move(a));
+  }
+
+  template <Message... Ms>
+  requires(sizeof...(Ms) > 0) std::optional<RequestEnvelope<Ms...>> Take() && {
+    std::optional<std::variant<Ms...>> m_opt = VariantFromAny<Ms...>(std::move(message));
+
+    if (m_opt) {
+      return RequestEnvelope<Ms...>{
+          .message = std::move(*m_opt),
+          .request_id = request_id,
+          .from_address = from_address,
+      };
+    }
+
+    return std::nullopt;
+  }
+};
+
+class OpaquePromiseTraitBase {
+ public:
+  virtual const std::type_info *TypeInfo() const = 0;
+  virtual bool IsAwaited(void *ptr) const = 0;
+  virtual void Fill(void *ptr, OpaqueMessage &&) const = 0;
+  virtual void TimeOut(void *ptr) const = 0;
+
+  virtual ~OpaquePromiseTraitBase() = default;
+  OpaquePromiseTraitBase() = default;
+  OpaquePromiseTraitBase(const OpaquePromiseTraitBase &) = delete;
+  OpaquePromiseTraitBase &operator=(const OpaquePromiseTraitBase &) = delete;
+  OpaquePromiseTraitBase(OpaquePromiseTraitBase &&old) = delete;
+  OpaquePromiseTraitBase &operator=(OpaquePromiseTraitBase &&) = delete;
+};
+
+template <typename T>
+class OpaquePromiseTrait : public OpaquePromiseTraitBase {
+ public:
+  const std::type_info *TypeInfo() const override { return &typeid(T); };
+
+  bool IsAwaited(void *ptr) const override { return static_cast<ResponsePromise<T> *>(ptr)->IsAwaited(); };
+
+  void Fill(void *ptr, OpaqueMessage &&opaque_message) const override {
+    T message = std::any_cast<T>(std::move(opaque_message.message));
+    auto response_envelope = ResponseEnvelope<T>{.message = std::move(message),
+                                                 .request_id = opaque_message.request_id,
+                                                 .from_address = opaque_message.from_address};
+    auto promise = static_cast<ResponsePromise<T> *>(ptr);
+    auto unique_promise = std::unique_ptr<ResponsePromise<T>>(promise);
+    unique_promise->Fill(std::move(response_envelope));
+  };
+
+  void TimeOut(void *ptr) const override {
+    auto promise = static_cast<ResponsePromise<T> *>(ptr);
+    auto unique_promise = std::unique_ptr<ResponsePromise<T>>(promise);
+    ResponseResult<T> result = TimedOut{};
+    unique_promise->Fill(std::move(result));
+  }
+};
+
+class OpaquePromise {
+  void *ptr_;
+  std::unique_ptr<OpaquePromiseTraitBase> trait_;
+
+ public:
+  OpaquePromise(OpaquePromise &&old) noexcept : ptr_(old.ptr_), trait_(std::move(old.trait_)) {
+    MG_ASSERT(old.ptr_ != nullptr);
+    old.ptr_ = nullptr;
+  }
+
+  OpaquePromise &operator=(OpaquePromise &&old) noexcept {
+    MG_ASSERT(ptr_ == nullptr);
+    MG_ASSERT(old.ptr_ != nullptr);
+    MG_ASSERT(this != &old);
+    ptr_ = old.ptr_;
+    trait_ = std::move(old.trait_);
+    old.ptr_ = nullptr;
+    return *this;
+  }
+
+  OpaquePromise(const OpaquePromise &) = delete;
+  OpaquePromise &operator=(const OpaquePromise &) = delete;
+
+  template <typename T>
+  std::unique_ptr<ResponsePromise<T>> Take() && {
+    MG_ASSERT(typeid(T) == *trait_->TypeInfo());
+    MG_ASSERT(ptr_ != nullptr);
+
+    auto ptr = static_cast<ResponsePromise<T> *>(ptr_);
+
+    ptr_ = nullptr;
+
+    return std::unique_ptr<T>(ptr);
+  }
+
+  template <typename T>
+  explicit OpaquePromise(std::unique_ptr<ResponsePromise<T>> promise)
+      : ptr_(static_cast<void *>(promise.release())), trait_(std::make_unique<OpaquePromiseTrait<T>>()) {}
+
+  bool IsAwaited() {
+    MG_ASSERT(ptr_ != nullptr);
+    return trait_->IsAwaited(ptr_);
+  }
+
+  void TimeOut() {
+    MG_ASSERT(ptr_ != nullptr);
+    trait_->TimeOut(ptr_);
+    ptr_ = nullptr;
+  }
+
+  void Fill(OpaqueMessage &&opaque_message) {
+    MG_ASSERT(ptr_ != nullptr);
+    trait_->Fill(ptr_, std::move(opaque_message));
+    ptr_ = nullptr;
+  }
+
+  ~OpaquePromise() {
+    MG_ASSERT(ptr_ == nullptr, "OpaquePromise destroyed without being explicitly timed out or filled");
+  }
+};
+
+}  // namespace memgraph::io::simulator

src/io/simulator/simulator.hpp

@@ -0,0 +1,51 @@
+// 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.
+
+#pragma once
+
+#include <memory>
+#include <random>
+
+#include "io/address.hpp"
+#include "io/simulator/simulator_config.hpp"
+#include "io/simulator/simulator_handle.hpp"
+#include "io/simulator/simulator_transport.hpp"
+
+namespace memgraph::io::simulator {
+class Simulator {
+  std::mt19937 rng_;
+  std::shared_ptr<SimulatorHandle> simulator_handle_;
+  uint16_t auto_port_ = 0;
+
+ public:
+  explicit Simulator(SimulatorConfig config)
+      : rng_(std::mt19937{config.rng_seed}), simulator_handle_{std::make_shared<SimulatorHandle>(config)} {}
+
+  void ShutDown() { simulator_handle_->ShutDown(); }
+
+  Io<SimulatorTransport> RegisterNew() {
+    Address address = Address::TestAddress(auto_port_++);
+    return Register(address);
+  }
+
+  Io<SimulatorTransport> Register(Address address) {
+    std::uniform_int_distribution<uint64_t> seed_distrib;
+    uint64_t seed = seed_distrib(rng_);
+    return Io{SimulatorTransport{simulator_handle_, address, seed}, address};
+  }
+
+  void IncrementServerCountAndWaitForQuiescentState(Address address) {
+    simulator_handle_->IncrementServerCountAndWaitForQuiescentState(address);
+  }
+
+  SimulatorStats Stats() { return simulator_handle_->Stats(); }
+};
+};  // namespace memgraph::io::simulator

src/io/simulator/simulator_config.hpp

@@ -0,0 +1,30 @@
+// 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.
+
+#pragma once
+
+#include <chrono>
+
+#include "io/time.hpp"
+
+namespace memgraph::io::simulator {
+
+using memgraph::io::Time;
+
+struct SimulatorConfig {
+  uint8_t drop_percent = 0;
+  bool perform_timeouts = false;
+  bool scramble_messages = true;
+  uint64_t rng_seed = 0;
+  Time start_time = Time::min();
+  Time abort_time = Time::max();
+};
+};  // namespace memgraph::io::simulator

src/io/simulator/simulator_handle.cpp

@@ -0,0 +1,154 @@
+// 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 "io/simulator/simulator_handle.hpp"
+#include "io/address.hpp"
+#include "io/errors.hpp"
+#include "io/simulator/simulator_config.hpp"
+#include "io/simulator/simulator_stats.hpp"
+#include "io/time.hpp"
+#include "io/transport.hpp"
+
+namespace memgraph::io::simulator {
+
+using memgraph::io::Duration;
+using memgraph::io::Time;
+
+void SimulatorHandle::ShutDown() {
+  std::unique_lock<std::mutex> lock(mu_);
+  should_shut_down_ = true;
+  cv_.notify_all();
+}
+
+bool SimulatorHandle::ShouldShutDown() const {
+  std::unique_lock<std::mutex> lock(mu_);
+  return should_shut_down_;
+}
+
+void SimulatorHandle::IncrementServerCountAndWaitForQuiescentState(Address address) {
+  std::unique_lock<std::mutex> lock(mu_);
+  server_addresses_.insert(address);
+
+  while (true) {
+    const size_t blocked_servers = BlockedServers();
+
+    const bool all_servers_blocked = blocked_servers == server_addresses_.size();
+
+    if (all_servers_blocked) {
+      return;
+    }
+
+    cv_.wait(lock);
+  }
+}
+
+size_t SimulatorHandle::BlockedServers() {
+  size_t blocked_servers = blocked_on_receive_;
+
+  for (auto &[promise_key, opaque_promise] : promises_) {
+    if (opaque_promise.promise.IsAwaited() && server_addresses_.contains(promise_key.requester_address)) {
+      blocked_servers++;
+    }
+  }
+
+  return blocked_servers;
+}
+
+bool SimulatorHandle::MaybeTickSimulator() {
+  std::unique_lock<std::mutex> lock(mu_);
+
+  const size_t blocked_servers = BlockedServers();
+
+  if (blocked_servers < server_addresses_.size()) {
+    // we only need to advance the simulator when all
+    // servers have reached a quiescent state, blocked
+    // on their own futures or receive methods.
+    return false;
+  }
+
+  stats_.simulator_ticks++;
+
+  cv_.notify_all();
+
+  TimeoutPromisesPastDeadline();
+
+  if (in_flight_.empty()) {
+    // return early here because there are no messages to schedule
+
+    // We tick the clock forward when all servers are blocked but
+    // there are no in-flight messages to schedule delivery of.
+    std::poisson_distribution<> time_distrib(50);
+    Duration clock_advance = std::chrono::microseconds{time_distrib(rng_)};
+    cluster_wide_time_microseconds_ += clock_advance;
+
+    MG_ASSERT(cluster_wide_time_microseconds_ < config_.abort_time,
+              "Cluster has executed beyond its configured abort_time, and something may be failing to make progress "
+              "in an expected amount of time.");
+    return true;
+  }
+
+  if (config_.scramble_messages) {
+    // scramble messages
+    std::uniform_int_distribution<size_t> swap_distrib(0, in_flight_.size() - 1);
+    const size_t swap_index = swap_distrib(rng_);
+    std::swap(in_flight_[swap_index], in_flight_.back());
+  }
+
+  auto [to_address, opaque_message] = std::move(in_flight_.back());
+  in_flight_.pop_back();
+
+  std::uniform_int_distribution<int> drop_distrib(0, 99);
+  const int drop_threshold = drop_distrib(rng_);
+  const bool should_drop = drop_threshold < config_.drop_percent;
+
+  if (should_drop) {
+    stats_.dropped_messages++;
+  }
+
+  PromiseKey promise_key{.requester_address = to_address,
+                         .request_id = opaque_message.request_id,
+                         .replier_address = opaque_message.from_address};
+
+  if (promises_.contains(promise_key)) {
+    // complete waiting promise if it's there
+    DeadlineAndOpaquePromise dop = std::move(promises_.at(promise_key));
+    promises_.erase(promise_key);
+
+    const bool normal_timeout = config_.perform_timeouts && (dop.deadline < cluster_wide_time_microseconds_);
+
+    if (should_drop || normal_timeout) {
+      stats_.timed_out_requests++;
+      dop.promise.TimeOut();
+    } else {
+      stats_.total_responses++;
+      dop.promise.Fill(std::move(opaque_message));
+    }
+  } else if (should_drop) {
+    // don't add it anywhere, let it drop
+  } else {
+    // add to can_receive_ if not
+    const auto &[om_vec, inserted] = can_receive_.try_emplace(to_address, std::vector<OpaqueMessage>());
+    om_vec->second.emplace_back(std::move(opaque_message));
+  }
+
+  return true;
+}
+
+Time SimulatorHandle::Now() const {
+  std::unique_lock<std::mutex> lock(mu_);
+  return cluster_wide_time_microseconds_;
+}
+
+SimulatorStats SimulatorHandle::Stats() {
+  std::unique_lock<std::mutex> lock(mu_);
+  return stats_;
+}
+}  // namespace memgraph::io::simulator

src/io/simulator/simulator_handle.hpp

@@ -0,0 +1,206 @@
+// 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.
+
+#pragma once
+
+#include <any>
+#include <compare>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <optional>
+#include <set>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#include "io/address.hpp"
+#include "io/errors.hpp"
+#include "io/simulator/message_conversion.hpp"
+#include "io/simulator/simulator_config.hpp"
+#include "io/simulator/simulator_stats.hpp"
+#include "io/time.hpp"
+#include "io/transport.hpp"
+
+namespace memgraph::io::simulator {
+
+using memgraph::io::Duration;
+using memgraph::io::Time;
+
+struct PromiseKey {
+  Address requester_address;
+  uint64_t request_id;
+  // TODO(tyler) possibly remove replier_address from promise key
+  // once we want to support DSR.
+  Address replier_address;
+
+ public:
+  friend bool operator<(const PromiseKey &lhs, const PromiseKey &rhs) {
+    if (lhs.requester_address != rhs.requester_address) {
+      return lhs.requester_address < rhs.requester_address;
+    }
+
+    if (lhs.request_id != rhs.request_id) {
+      return lhs.request_id < rhs.request_id;
+    }
+
+    return lhs.replier_address < rhs.replier_address;
+  }
+};
+
+struct DeadlineAndOpaquePromise {
+  Time deadline;
+  OpaquePromise promise;
+};
+
+class SimulatorHandle {
+  mutable std::mutex mu_{};
+  mutable std::condition_variable cv_;
+
+  // messages that have not yet been scheduled or dropped
+  std::vector<std::pair<Address, OpaqueMessage>> in_flight_;
+
+  // the responses to requests that are being waited on
+  std::map<PromiseKey, DeadlineAndOpaquePromise> promises_;
+
+  // messages that are sent to servers that may later receive them
+  std::map<Address, std::vector<OpaqueMessage>> can_receive_;
+
+  Time cluster_wide_time_microseconds_;
+  bool should_shut_down_ = false;
+  SimulatorStats stats_;
+  size_t blocked_on_receive_ = 0;
+  std::set<Address> server_addresses_;
+  std::mt19937 rng_;
+  SimulatorConfig config_;
+
+  /// Returns the number of servers currently blocked on Receive, plus
+  /// the servers that are blocked on Futures that were created through
+  /// SimulatorTransport::Request.
+  ///
+  /// TODO(tyler) investigate whether avoiding consideration of Futures
+  /// increases determinism.
+  size_t BlockedServers();
+
+  void TimeoutPromisesPastDeadline() {
+    const Time now = cluster_wide_time_microseconds_;
+
+    for (auto &[promise_key, dop] : promises_) {
+      if (dop.deadline < now) {
+        spdlog::debug("timing out request from requester {} to replier {}.", promise_key.requester_address.ToString(),
+                      promise_key.replier_address.ToString());
+        std::move(dop).promise.TimeOut();
+        promises_.erase(promise_key);
+
+        stats_.timed_out_requests++;
+      }
+    }
+  }
+
+ public:
+  explicit SimulatorHandle(SimulatorConfig config)
+      : cluster_wide_time_microseconds_(config.start_time), rng_(config.rng_seed), config_(config) {}
+
+  void IncrementServerCountAndWaitForQuiescentState(Address address);
+
+  /// This method causes most of the interesting simulation logic to happen, wrt network behavior.
+  /// It checks to see if all background "server" threads are blocked on new messages, and if so,
+  /// it will decide whether to drop, reorder, or deliver in-flight messages based on the SimulatorConfig
+  /// that was used to create the Simulator.
+  bool MaybeTickSimulator();
+
+  void ShutDown();
+
+  bool ShouldShutDown() const;
+
+  template <Message Request, Message Response>
+  void SubmitRequest(Address to_address, Address from_address, uint64_t request_id, Request &&request, Duration timeout,
+                     ResponsePromise<Response> &&promise) {
+    std::unique_lock<std::mutex> lock(mu_);
+
+    const Time deadline = cluster_wide_time_microseconds_ + timeout;
+
+    std::any message(request);
+    OpaqueMessage om{.from_address = from_address, .request_id = request_id, .message = std::move(message)};
+    in_flight_.emplace_back(std::make_pair(to_address, std::move(om)));
+
+    PromiseKey promise_key{.requester_address = from_address, .request_id = request_id, .replier_address = to_address};
+    OpaquePromise opaque_promise(std::move(promise).ToUnique());
+    DeadlineAndOpaquePromise dop{.deadline = deadline, .promise = std::move(opaque_promise)};
+    promises_.emplace(std::move(promise_key), std::move(dop));
+
+    stats_.total_messages++;
+    stats_.total_requests++;
+
+    cv_.notify_all();
+  }
+
+  template <Message... Ms>
+  requires(sizeof...(Ms) > 0) RequestResult<Ms...> Receive(const Address &receiver, Duration timeout) {
+    std::unique_lock<std::mutex> lock(mu_);
+
+    blocked_on_receive_ += 1;
+
+    const Time deadline = cluster_wide_time_microseconds_ + timeout;
+
+    while (!should_shut_down_ && (cluster_wide_time_microseconds_ < deadline)) {
+      if (can_receive_.contains(receiver)) {
+        std::vector<OpaqueMessage> &can_rx = can_receive_.at(receiver);
+        if (!can_rx.empty()) {
+          OpaqueMessage message = std::move(can_rx.back());
+          can_rx.pop_back();
+
+          // TODO(tyler) search for item in can_receive_ that matches the desired types, rather
+          // than asserting that the last item in can_rx matches.
+          auto m_opt = std::move(message).Take<Ms...>();
+
+          blocked_on_receive_ -= 1;
+
+          return std::move(m_opt).value();
+        }
+      }
+
+      lock.unlock();
+      bool made_progress = MaybeTickSimulator();
+      lock.lock();
+      if (!should_shut_down_ && !made_progress) {
+        cv_.wait(lock);
+      }
+    }
+
+    blocked_on_receive_ -= 1;
+
+    return TimedOut{};
+  }
+
+  template <Message M>
+  void Send(Address to_address, Address from_address, uint64_t request_id, M message) {
+    std::unique_lock<std::mutex> lock(mu_);
+    std::any message_any(std::move(message));
+    OpaqueMessage om{.from_address = from_address, .request_id = request_id, .message = std::move(message_any)};
+    in_flight_.emplace_back(std::make_pair(std::move(to_address), std::move(om)));
+
+    stats_.total_messages++;
+
+    cv_.notify_all();
+  }
+
+  Time Now() const;
+
+  template <class D = std::poisson_distribution<>, class Return = uint64_t>
+  Return Rand(D distrib) {
+    std::unique_lock<std::mutex> lock(mu_);
+    return distrib(rng_);
+  }
+
+  SimulatorStats Stats();
+};
+};  // namespace memgraph::io::simulator

src/io/simulator/simulator_stats.hpp

@@ -0,0 +1,25 @@
+// 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.
+
+#pragma once
+
+#include <cstdint>
+
+namespace memgraph::io::simulator {
+struct SimulatorStats {
+  uint64_t total_messages = 0;
+  uint64_t dropped_messages = 0;
+  uint64_t timed_out_requests = 0;
+  uint64_t total_requests = 0;
+  uint64_t total_responses = 0;
+  uint64_t simulator_ticks = 0;
+};
+};  // namespace memgraph::io::simulator

src/io/simulator/simulator_transport.hpp

@@ -0,0 +1,65 @@
+// 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.
+
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include "io/address.hpp"
+#include "io/simulator/simulator_handle.hpp"
+#include "io/time.hpp"
+
+namespace memgraph::io::simulator {
+
+using memgraph::io::Duration;
+using memgraph::io::Time;
+
+class SimulatorTransport {
+  std::shared_ptr<SimulatorHandle> simulator_handle_;
+  const Address address_;
+  std::mt19937 rng_;
+
+ public:
+  SimulatorTransport(std::shared_ptr<SimulatorHandle> simulator_handle, Address address, uint64_t seed)
+      : simulator_handle_(simulator_handle), address_(address), rng_(std::mt19937{seed}) {}
+
+  template <Message Request, Message Response>
+  ResponseFuture<Response> Request(Address address, uint64_t request_id, Request request, Duration timeout) {
+    std::function<bool()> maybe_tick_simulator = [this] { return simulator_handle_->MaybeTickSimulator(); };
+    auto [future, promise] =
+        memgraph::io::FuturePromisePairWithNotifier<ResponseResult<Response>>(maybe_tick_simulator);
+
+    simulator_handle_->SubmitRequest(address, address_, request_id, std::move(request), timeout, std::move(promise));
+
+    return std::move(future);
+  }
+
+  template <Message... Ms>
+  requires(sizeof...(Ms) > 0) RequestResult<Ms...> Receive(Duration timeout) {
+    return simulator_handle_->template Receive<Ms...>(address_, timeout);
+  }
+
+  template <Message M>
+  void Send(Address address, uint64_t request_id, M message) {
+    return simulator_handle_->template Send<M>(address, address_, request_id, message);
+  }
+
+  Time Now() const { return simulator_handle_->Now(); }
+
+  bool ShouldShutDown() const { return simulator_handle_->ShouldShutDown(); }
+
+  template <class D = std::poisson_distribution<>, class Return = uint64_t>
+  Return Rand(D distrib) {
+    return distrib(rng_);
+  }
+};
+};  // namespace memgraph::io::simulator

src/io/time.hpp

@@ -0,0 +1,21 @@
+// 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.
+
+#pragma once
+
+#include <chrono>
+
+namespace memgraph::io {
+
+using Duration = std::chrono::microseconds;
+using Time = std::chrono::time_point<std::chrono::local_t, Duration>;
+
+}  // namespace memgraph::io

src/io/transport.hpp

@@ -0,0 +1,133 @@
+// 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.
+
+#pragma once
+
+#include <chrono>
+#include <concepts>
+#include <random>
+#include <variant>
+
+#include "io/address.hpp"
+#include "io/errors.hpp"
+#include "io/future.hpp"
+#include "io/time.hpp"
+#include "utils/result.hpp"
+
+namespace memgraph::io {
+
+using memgraph::utils::BasicResult;
+
+// TODO(tyler) ensure that Message continues to represent
+// reasonable constraints around message types over time,
+// as we adapt things to use Thrift-generated message types.
+template <typename T>
+concept Message = std::same_as<T, std::decay_t<T>>;
+
+template <Message M>
+struct ResponseEnvelope {
+  M message;
+  uint64_t request_id;
+  Address from_address;
+};
+
+template <Message M>
+using ResponseResult = BasicResult<TimedOut, ResponseEnvelope<M>>;
+
+template <Message M>
+using ResponseFuture = memgraph::io::Future<ResponseResult<M>>;
+
+template <Message M>
+using ResponsePromise = memgraph::io::Promise<ResponseResult<M>>;
+
+template <Message... Ms>
+struct RequestEnvelope {
+  std::variant<Ms...> message;
+  uint64_t request_id;
+  Address from_address;
+};
+
+template <Message... Ms>
+using RequestResult = BasicResult<TimedOut, RequestEnvelope<Ms...>>;
+
+template <typename I>
+class Io {
+  I implementation_;
+  Address address_;
+  uint64_t request_id_counter_ = 0;
+  Duration default_timeout_ = std::chrono::microseconds{50000};
+
+ public:
+  Io(I io, Address address) : implementation_(io), address_(address) {}
+
+  /// Set the default timeout for all requests that are issued
+  /// without an explicit timeout set.
+  void SetDefaultTimeout(Duration timeout) { default_timeout_ = timeout; }
+
+  /// Returns the current default timeout for this Io instance.
+  Duration GetDefaultTimeout() { return default_timeout_; }
+
+  /// Issue a request with an explicit timeout in microseconds provided. This tends to be used by clients.
+  template <Message Request, Message Response>
+  ResponseFuture<Response> RequestWithTimeout(Address address, Request request, Duration timeout) {
+    const uint64_t request_id = ++request_id_counter_;
+    return implementation_.template Request<Request, Response>(address, request_id, request, timeout);
+  }
+
+  /// Issue a request that times out after the default timeout. This tends
+  /// to be used by clients.
+  template <Message Request, Message Response>
+  ResponseFuture<Response> Request(Address address, Request request) {
+    const uint64_t request_id = ++request_id_counter_;
+    const Duration timeout = default_timeout_;
+    return implementation_.template Request<Request, Response>(address, request_id, std::move(request), timeout);
+  }
+
+  /// Wait for an explicit number of microseconds for a request of one of the
+  /// provided types to arrive. This tends to be used by servers.
+  template <Message... Ms>
+  RequestResult<Ms...> ReceiveWithTimeout(Duration timeout) {
+    return implementation_.template Receive<Ms...>(timeout);
+  }
+
+  /// Wait the default number of microseconds for a request of one of the
+  /// provided types to arrive. This tends to be used by servers.
+  template <Message... Ms>
+  requires(sizeof...(Ms) > 0) RequestResult<Ms...> Receive() {
+    const Duration timeout = default_timeout_;
+    return implementation_.template Receive<Ms...>(timeout);
+  }
+
+  /// Send a message in a best-effort fashion. This is used for messaging where
+  /// responses are not necessarily expected, and for servers to respond to requests.
+  /// If you need reliable delivery, this must be built on-top. TCP is not enough for most use cases.
+  template <Message M>
+  void Send(Address address, uint64_t request_id, M message) {
+    return implementation_.template Send<M>(address, request_id, std::move(message));
+  }
+
+  /// The current system time. This time source should be preferred over any other,
+  /// because it lets us deterministically control clocks from tests for making
+  /// things like timeouts deterministic.
+  Time Now() const { return implementation_.Now(); }
+
+  /// Returns true if the system should shut-down.
+  bool ShouldShutDown() const { return implementation_.ShouldShutDown(); }
+
+  /// Returns a random number within the specified distribution.
+  template <class D = std::poisson_distribution<>, class Return = uint64_t>
+  Return Rand(D distrib) {
+    return implementation_.template Rand<D, Return>(distrib);
+  }
+
+  Address GetAddress() { return address_; }
+};
+};  // namespace memgraph::io

src/memgraph.cpp

@@ -1252,9 +1252,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/query/CMakeLists.txt

@@ -39,9 +39,7 @@ set(mg_query_sources
     stream/common.cpp
     trigger.cpp
     trigger_context.cpp
-    typed_value.cpp
-    graph.cpp
-    db_accessor.cpp)
+    typed_value.cpp)
 
 find_package(Boost REQUIRED)
 
@@ -84,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/common.cpp

@@ -61,7 +61,6 @@ bool TypedValueCompare(const TypedValue &a, const TypedValue &b) {
     case TypedValue::Type::Vertex:
     case TypedValue::Type::Edge:
     case TypedValue::Type::Path:
-    case TypedValue::Type::Graph:
       throw QueryRuntimeException("Comparison is not defined for values of type {}.", a.type());
     case TypedValue::Type::Null:
       LOG_FATAL("Invalid type");

src/query/cypher_query_interpreter.cpp

@@ -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.cpp

@@ -1,155 +0,0 @@
-// 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 "query/db_accessor.hpp"
-
-#include "query/graph.hpp"
-
-#include <cppitertools/filter.hpp>
-#include <cppitertools/imap.hpp>
-#include "utils/pmr/unordered_set.hpp"
-
-namespace memgraph::query {
-SubgraphDbAccessor::SubgraphDbAccessor(query::DbAccessor *db_accessor, Graph *graph)
-    : db_accessor_(db_accessor), graph_(graph) {}
-
-SubgraphDbAccessor *SubgraphDbAccessor::MakeSubgraphDbAccessor(DbAccessor *db_accessor, Graph *graph) {
-  return new SubgraphDbAccessor(db_accessor, graph);
-}
-
-storage::PropertyId SubgraphDbAccessor::NameToProperty(const std::string_view name) {
-  return db_accessor_->NameToProperty(name);
-}
-
-storage::LabelId SubgraphDbAccessor::NameToLabel(const std::string_view name) {
-  return db_accessor_->NameToLabel(name);
-}
-
-storage::EdgeTypeId SubgraphDbAccessor::NameToEdgeType(const std::string_view name) {
-  return db_accessor_->NameToEdgeType(name);
-}
-
-const std::string &SubgraphDbAccessor::PropertyToName(storage::PropertyId prop) const {
-  return db_accessor_->PropertyToName(prop);
-}
-
-const std::string &SubgraphDbAccessor::LabelToName(storage::LabelId label) const {
-  return db_accessor_->LabelToName(label);
-}
-
-const std::string &SubgraphDbAccessor::EdgeTypeToName(storage::EdgeTypeId type) const {
-  return db_accessor_->EdgeTypeToName(type);
-}
-
-storage::Result<std::optional<EdgeAccessor>> SubgraphDbAccessor::RemoveEdge(EdgeAccessor *edge) {
-  auto result = db_accessor_->RemoveEdge(edge);
-  if (result.HasError() || !*result) {
-    return result;
-  }
-  return this->graph_->RemoveEdge(*edge);
-}
-
-storage::Result<EdgeAccessor> SubgraphDbAccessor::InsertEdge(SubgraphVertexAccessor *from, SubgraphVertexAccessor *to,
-                                                             const storage::EdgeTypeId &edge_type) {
-  VertexAccessor *from_impl = &from->impl_;
-  VertexAccessor *to_impl = &to->impl_;
-
-  auto result = db_accessor_->InsertEdge(from_impl, to_impl, edge_type);
-  if (result.HasError()) {
-    return result;
-  }
-  this->graph_->InsertEdge(*result);
-  return result;
-}
-
-storage::Result<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>>
-SubgraphDbAccessor::DetachRemoveVertex(
-    VertexAccessor *) {  // NOLINT(hicpp-named-parameter, readability-convert-member-functions-to-static)
-  throw std::logic_error{"Such operation not possible on subgraph"};
-}
-
-storage::Result<std::optional<VertexAccessor>> SubgraphDbAccessor::RemoveVertex(
-    SubgraphVertexAccessor *subgraphvertex_accessor) {
-  VertexAccessor *vertex_accessor = &subgraphvertex_accessor->impl_;
-  auto result = db_accessor_->RemoveVertex(vertex_accessor);
-  if (result.HasError() || !*result) {
-    return result;
-  }
-  return this->graph_->RemoveVertex(*vertex_accessor);
-}
-
-SubgraphVertexAccessor SubgraphDbAccessor::InsertVertex() {
-  VertexAccessor vertex = db_accessor_->InsertVertex();
-  this->graph_->InsertVertex(vertex);
-  return SubgraphVertexAccessor(vertex, this->getGraph());
-}
-
-VerticesIterable SubgraphDbAccessor::Vertices(storage::View) {
-  return VerticesIterable(graph_->vertices());
-}  // NOLINT(hicpp-named-parameter)
-
-std::optional<VertexAccessor> SubgraphDbAccessor::FindVertex(storage::Gid gid, storage::View view) {
-  std::optional<VertexAccessor> maybe_vertex = db_accessor_->FindVertex(gid, view);
-  if (maybe_vertex && this->graph_->ContainsVertex(*maybe_vertex)) {
-    return *maybe_vertex;
-  }
-  return std::nullopt;
-}
-
-query::Graph *SubgraphDbAccessor::getGraph() { return graph_; }
-
-VertexAccessor SubgraphVertexAccessor::GetVertexAccessor() const { return impl_; }
-
-auto SubgraphVertexAccessor::OutEdges(storage::View view) const -> decltype(impl_.OutEdges(view)) {
-  auto maybe_edges = impl_.impl_.OutEdges(view, {});
-  if (maybe_edges.HasError()) return maybe_edges.GetError();
-  auto edges = std::move(*maybe_edges);
-  auto graph_edges = graph_->edges();
-
-  std::unordered_set<storage::EdgeAccessor> graph_edges_storage;
-
-  for (auto e : graph_edges) {
-    graph_edges_storage.insert(e.impl_);
-  }
-
-  std::vector<storage::EdgeAccessor> filteredOutEdges;
-  for (auto &edge : edges) {
-    if (std::find(begin(graph_edges_storage), end(graph_edges_storage), edge) != std::end(graph_edges_storage)) {
-      filteredOutEdges.push_back(edge);
-    }
-  }
-
-  return iter::imap(VertexAccessor::MakeEdgeAccessor, std::move(filteredOutEdges));
-}
-
-auto SubgraphVertexAccessor::InEdges(storage::View view) const -> decltype(impl_.InEdges(view)) {
-  auto maybe_edges = impl_.impl_.InEdges(view, {});
-  if (maybe_edges.HasError()) return maybe_edges.GetError();
-  auto edges = std::move(*maybe_edges);
-  auto graph_edges = graph_->edges();
-
-  std::unordered_set<storage::EdgeAccessor> graph_edges_storage;
-
-  for (auto e : graph_edges) {
-    graph_edges_storage.insert(e.impl_);
-  }
-
-  std::vector<storage::EdgeAccessor> filteredOutEdges;
-  for (auto &edge : edges) {
-    if (std::find(begin(graph_edges_storage), end(graph_edges_storage), edge) != std::end(graph_edges_storage)) {
-      filteredOutEdges.push_back(edge);
-    }
-  }
-
-  return iter::imap(VertexAccessor::MakeEdgeAccessor, std::move(filteredOutEdges));
-}
-
-}  // namespace memgraph::query

src/query/db_accessor.hpp

@@ -20,8 +20,6 @@
 #include "storage/v2/id_types.hpp"
 #include "storage/v2/property_value.hpp"
 #include "storage/v2/result.hpp"
-#include "utils/pmr/unordered_set.hpp"
-#include "utils/variant_helpers.hpp"
 
 ///////////////////////////////////////////////////////////
 // Our communication layer and query engine don't mix
@@ -47,14 +45,12 @@
 
 namespace memgraph::query {
 
-class Graph;
 class VertexAccessor;
 
 class EdgeAccessor final {
  public:
   storage::EdgeAccessor impl_;
 
- public:
   explicit EdgeAccessor(storage::EdgeAccessor impl) : impl_(std::move(impl)) {}
 
   bool IsVisible(storage::View view) const { return impl_.IsVisible(view); }
@@ -100,7 +96,6 @@ class VertexAccessor final {
 
   static EdgeAccessor MakeEdgeAccessor(const storage::EdgeAccessor impl) { return EdgeAccessor(impl); }
 
- public:
   explicit VertexAccessor(storage::VertexAccessor impl) : impl_(impl) {}
 
   bool IsVisible(storage::View view) const { return impl_.IsVisible(view); }
@@ -188,115 +183,38 @@ inline VertexAccessor EdgeAccessor::From() const { return VertexAccessor(impl_.F
 
 inline bool EdgeAccessor::IsCycle() const { return To() == From(); }
 
-class SubgraphVertexAccessor final {
- public:
-  query::VertexAccessor impl_;
-  query::Graph *graph_;
-
-  explicit SubgraphVertexAccessor(query::VertexAccessor impl, query::Graph *graph_) : impl_(impl), graph_(graph_) {}
-
-  bool operator==(const SubgraphVertexAccessor &v) const noexcept {
-    static_assert(noexcept(impl_ == v.impl_));
-    return impl_ == v.impl_;
-  }
-
-  auto InEdges(storage::View view) const -> decltype(impl_.OutEdges(view));
-
-  auto OutEdges(storage::View view) const -> decltype(impl_.OutEdges(view));
-
-  auto Labels(storage::View view) const { return impl_.Labels(view); }
-
-  storage::Result<bool> AddLabel(storage::LabelId label) { return impl_.AddLabel(label); }
-
-  storage::Result<bool> RemoveLabel(storage::LabelId label) { return impl_.RemoveLabel(label); }
-
-  storage::Result<bool> HasLabel(storage::View view, storage::LabelId label) const {
-    return impl_.HasLabel(view, label);
-  }
-
-  auto Properties(storage::View view) const { return impl_.Properties(view); }
-
-  storage::Result<storage::PropertyValue> GetProperty(storage::View view, storage::PropertyId key) const {
-    return impl_.GetProperty(view, key);
-  }
-
-  storage::Gid Gid() const noexcept { return impl_.Gid(); }
-
-  storage::Result<storage::PropertyValue> SetProperty(storage::PropertyId key, const storage::PropertyValue &value) {
-    return impl_.SetProperty(key, value);
-  }
-  VertexAccessor GetVertexAccessor() const;
-};
-}  // namespace memgraph::query
-
-namespace std {
-
-template <>
-struct hash<memgraph::query::VertexAccessor> {
-  size_t operator()(const memgraph::query::VertexAccessor &v) const { return std::hash<decltype(v.impl_)>{}(v.impl_); }
-};
-
-template <>
-struct hash<memgraph::query::EdgeAccessor> {
-  size_t operator()(const memgraph::query::EdgeAccessor &e) const { return std::hash<decltype(e.impl_)>{}(e.impl_); }
-};
-
-}  // namespace std
-
-namespace memgraph::query {
-
-class VerticesIterable final {
-  std::variant<storage::VerticesIterable, std::unordered_set<VertexAccessor, std::hash<VertexAccessor>,
-                                                             std::equal_to<void>, utils::Allocator<VertexAccessor>>>
-      iterable_;
-
- public:
-  class Iterator final {
-    std::variant<storage::VerticesIterable::Iterator,
-                 std::unordered_set<VertexAccessor, std::hash<VertexAccessor>, std::equal_to<void>,
-                                    utils::Allocator<VertexAccessor>>::iterator>
-        it_;
-
-   public:
-    explicit Iterator(storage::VerticesIterable::Iterator it) : it_(it) {}
-    explicit Iterator(std::unordered_set<VertexAccessor, std::hash<VertexAccessor>, std::equal_to<void>,
-                                         utils::Allocator<VertexAccessor>>::iterator it)
-        : it_(it) {}
-
-    VertexAccessor operator*() const {
-      return std::visit(memgraph::utils::Overloaded{[](auto it_) { return VertexAccessor(*it_); }}, it_);
-    }
-
-    Iterator &operator++() {
-      std::visit(memgraph::utils::Overloaded{[this](auto it_) { this->it_ = ++it_; }}, it_);
-      return *this;
-    }
-
-    bool operator==(const Iterator &other) const { return it_ == other.it_; }
-
-    bool operator!=(const Iterator &other) const { return !(other == *this); }
-  };
-
-  explicit VerticesIterable(storage::VerticesIterable iterable) : iterable_(std::move(iterable)) {}
-  explicit VerticesIterable(std::unordered_set<VertexAccessor, std::hash<VertexAccessor>, std::equal_to<void>,
-                                               utils::Allocator<VertexAccessor>>
-                                vertices)
-      : iterable_(vertices) {}
-
-  Iterator begin() {
-    return std::visit(memgraph::utils::Overloaded{[](auto &iterable_) { return Iterator(iterable_.begin()); }},
-                      iterable_);
-  }
-
-  Iterator end() {
-    return std::visit(memgraph::utils::Overloaded{[](auto &iterable_) { return Iterator(iterable_.end()); }},
-                      iterable_);
-  }
-};
-
 class DbAccessor final {
   storage::Storage::Accessor *accessor_;
 
+  class VerticesIterable final {
+    storage::VerticesIterable iterable_;
+
+   public:
+    class Iterator final {
+      storage::VerticesIterable::Iterator it_;
+
+     public:
+      explicit Iterator(storage::VerticesIterable::Iterator it) : it_(it) {}
+
+      VertexAccessor operator*() const { return VertexAccessor(*it_); }
+
+      Iterator &operator++() {
+        ++it_;
+        return *this;
+      }
+
+      bool operator==(const Iterator &other) const { return it_ == other.it_; }
+
+      bool operator!=(const Iterator &other) const { return !(other == *this); }
+    };
+
+    explicit VerticesIterable(storage::VerticesIterable iterable) : iterable_(std::move(iterable)) {}
+
+    Iterator begin() { return Iterator(iterable_.begin()); }
+
+    Iterator end() { return Iterator(iterable_.end()); }
+  };
+
  public:
   explicit DbAccessor(storage::Storage::Accessor *accessor) : accessor_(accessor) {}
 
@@ -438,44 +356,18 @@ class DbAccessor final {
   storage::ConstraintsInfo ListAllConstraints() const { return accessor_->ListAllConstraints(); }
 };
 
-class SubgraphDbAccessor final {
-  DbAccessor *db_accessor_;
-  Graph *graph_;
+}  // namespace memgraph::query
 
- public:
-  explicit SubgraphDbAccessor(DbAccessor *db_accessor, Graph *graph);
+namespace std {
 
-  static SubgraphDbAccessor *MakeSubgraphDbAccessor(DbAccessor *db_accessor, Graph *graph);
-
-  storage::PropertyId NameToProperty(std::string_view name);
-
-  storage::LabelId NameToLabel(std::string_view name);
-
-  storage::EdgeTypeId NameToEdgeType(std::string_view name);
-
-  const std::string &PropertyToName(storage::PropertyId prop) const;
-
-  const std::string &LabelToName(storage::LabelId label) const;
-
-  const std::string &EdgeTypeToName(storage::EdgeTypeId type) const;
-
-  storage::Result<std::optional<EdgeAccessor>> RemoveEdge(EdgeAccessor *edge);
-
-  storage::Result<EdgeAccessor> InsertEdge(SubgraphVertexAccessor *from, SubgraphVertexAccessor *to,
-                                           const storage::EdgeTypeId &edge_type);
-
-  storage::Result<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> DetachRemoveVertex(
-      VertexAccessor *vertex_accessor);
-
-  storage::Result<std::optional<VertexAccessor>> RemoveVertex(SubgraphVertexAccessor *vertex_accessor);
-
-  SubgraphVertexAccessor InsertVertex();
-
-  VerticesIterable Vertices(storage::View view);
-
-  std::optional<VertexAccessor> FindVertex(storage::Gid gid, storage::View view);
-
-  Graph *getGraph();
+template <>
+struct hash<memgraph::query::VertexAccessor> {
+  size_t operator()(const memgraph::query::VertexAccessor &v) const { return std::hash<decltype(v.impl_)>{}(v.impl_); }
 };
 
-}  // namespace memgraph::query
+template <>
+struct hash<memgraph::query::EdgeAccessor> {
+  size_t operator()(const memgraph::query::EdgeAccessor &e) const { return std::hash<decltype(e.impl_)>{}(e.impl_); }
+};
+
+}  // namespace std

src/query/frontend/ast/ast.lcp

@@ -464,7 +464,7 @@ cpp<#
                :documentation "Symbol table position of the symbol this Aggregation is mapped to."))
   (:public
     (lcp:define-enum op
-      (count min max sum avg collect-list collect-map project)
+      (count min max sum avg collect-list collect-map)
       (:serialize))
     #>cpp
     Aggregation() = default;
@@ -475,11 +475,10 @@ cpp<#
     static const constexpr char *const kSum = "SUM";
     static const constexpr char *const kAvg = "AVG";
     static const constexpr char *const kCollect = "COLLECT";
-    static const constexpr char *const kProject = "PROJECT";
 
     static std::string OpToString(Op op) {
       const char *op_strings[] = {kCount, kMin,     kMax,    kSum,
-                                  kAvg,   kCollect, kCollect, kProject};
+                                  kAvg,   kCollect, kCollect};
       return op_strings[static_cast<int>(op)];
     }
 

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);
     }

src/query/frontend/stripped_lexer_constants.hpp

@@ -204,7 +204,7 @@ const trie::Trie kKeywords = {"union",
                               "pulsar",
                               "service_url",
                               "version",
-                              "websocket"
+                              "websocket",
                               "foreach"};
 
 // Unicode codepoints that are allowed at the start of the unescaped name.

src/query/graph.cpp

@@ -1,91 +0,0 @@
-// 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 "query/graph.hpp"
-#include "query/path.hpp"
-
-namespace memgraph::query {
-
-Graph::Graph(utils::MemoryResource *memory) : vertices_(memory), edges_(memory) {}
-
-Graph::Graph(const Graph &other, utils::MemoryResource *memory)
-    : vertices_(other.vertices_, memory), edges_(other.edges_, memory) {}
-
-Graph::Graph(Graph &&other) noexcept : Graph(std::move(other), other.GetMemoryResource()) {}
-
-Graph::Graph(const Graph &other)
-    : Graph(other,
-            std::allocator_traits<allocator_type>::select_on_container_copy_construction(other.GetMemoryResource())
-                .GetMemoryResource()) {}
-
-Graph::Graph(Graph &&other, utils::MemoryResource *memory)
-    : vertices_(std::move(other.vertices_), memory), edges_(std::move(other.edges_), memory) {}
-
-void Graph::Expand(const Path &path) {
-  const auto &path_vertices_ = path.vertices();
-  const auto &path_edges_ = path.edges();
-  std::for_each(path_vertices_.begin(), path_vertices_.end(), [this](const VertexAccessor v) { vertices_.insert(v); });
-  std::for_each(path_edges_.begin(), path_edges_.end(), [this](const EdgeAccessor e) { edges_.insert(e); });
-}
-
-void Graph::InsertVertex(const VertexAccessor &vertex) { vertices_.insert(vertex); }
-
-void Graph::InsertEdge(const EdgeAccessor &edge) { edges_.insert(edge); }
-
-bool Graph::ContainsVertex(const VertexAccessor &vertex) {
-  return std::find(begin(vertices_), end(vertices_), vertex) != std::end(vertices_);
-}
-
-std::optional<VertexAccessor> Graph::RemoveVertex(const VertexAccessor &vertex) {
-  if (!ContainsVertex(vertex)) {
-    return std::nullopt;
-  }
-  auto value = vertices_.erase(vertex);
-  if (value == 0) {
-    return std::nullopt;
-  }
-  return vertex;
-}
-
-std::optional<EdgeAccessor> Graph::RemoveEdge(const EdgeAccessor &edge) {
-  auto value = edges_.erase(edge);
-  if (value == 0) {
-    return std::nullopt;
-  }
-  return edge;
-}
-
-std::vector<EdgeAccessor> Graph::OutEdges(VertexAccessor vertex_accessor) {
-  std::vector<EdgeAccessor> out_edges;
-  for (const auto &edge : edges_) {
-    if (edge.From() == vertex_accessor) {
-      out_edges.emplace_back(edge);
-    }
-  }
-  return out_edges;
-}
-
-/** Copy assign other, utils::MemoryResource of `this` is used */
-Graph &Graph::operator=(const Graph &) = default;
-
-/** Move assign other, utils::MemoryResource of `this` is used. */
-Graph &Graph::operator=(Graph &&) noexcept = default;
-
-Graph::~Graph() = default;
-
-utils::pmr::unordered_set<VertexAccessor> &Graph::vertices() { return vertices_; }
-utils::pmr::unordered_set<EdgeAccessor> &Graph::edges() { return edges_; }
-const utils::pmr::unordered_set<VertexAccessor> &Graph::vertices() const { return vertices_; }
-const utils::pmr::unordered_set<EdgeAccessor> &Graph::edges() const { return edges_; }
-
-utils::MemoryResource *Graph::GetMemoryResource() const { return vertices_.get_allocator().GetMemoryResource(); }
-
-}  // namespace memgraph::query

src/query/graph.hpp

@@ -1,111 +0,0 @@
-// 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.
-
-#pragma once
-
-#include <functional>
-#include <utility>
-#include "query/db_accessor.hpp"
-#include "utils/logging.hpp"
-#include "utils/memory.hpp"
-#include "utils/pmr/unordered_set.hpp"
-#include "utils/pmr/vector.hpp"
-
-namespace memgraph::query {
-
-class Path;
-/**
- *  A data structure that holds a graph. A graph consists of at least one
- * vertex, and zero or more edges.
- */
-class Graph final {
- public:
-  /** Allocator type so that STL containers are aware that we need one */
-  using allocator_type = utils::Allocator<char>;
-
-  /**
-   * Create the graph with no elements
-   * Allocations are done using the given MemoryResource.
-   */
-  explicit Graph(utils::MemoryResource *memory);
-
-  /**
-   * Construct a copy of other.
-   * utils::MemoryResource is obtained by calling
-   * std::allocator_traits<>::
-   *     select_on_container_copy_construction(other.GetMemoryResource()).
-   * Since we use utils::Allocator, which does not propagate, this means that we
-   * will default to utils::NewDeleteResource().
-   */
-  Graph(const Graph &other);
-
-  /** Construct a copy using the given utils::MemoryResource */
-  Graph(const Graph &other, utils::MemoryResource *memory);
-
-  /**
-   * Construct with the value of other.
-   * utils::MemoryResource is obtained from other. After the move, other will be
-   * empty.
-   */
-  Graph(Graph &&other) noexcept;
-
-  /**
-   * Construct with the value of other, but use the given utils::MemoryResource.
-   * After the move, other may not be empty if `*memory !=
-   * *other.GetMemoryResource()`, because an element-wise move will be
-   * performed.
-   */
-  Graph(Graph &&other, utils::MemoryResource *memory);
-
-  /** Expands the graph with the given path. */
-  void Expand(const Path &path);
-
-  /** Inserts the vertex in the graph. */
-  void InsertVertex(const VertexAccessor &vertex);
-
-  /** Inserts the edge in the graph. */
-  void InsertEdge(const EdgeAccessor &edge);
-
-  /** Checks whether the graph contains the vertex. */
-  bool ContainsVertex(const VertexAccessor &vertex);
-
-  /** Removes the vertex from the graph if the vertex is in the graph. */
-  std::optional<VertexAccessor> RemoveVertex(const VertexAccessor &vertex);
-
-  /** Removes the vertex from the graph if the vertex is in the graph. */
-  std::optional<EdgeAccessor> RemoveEdge(const EdgeAccessor &edge);
-
-  /** Return the out edges of the given vertex. */
-  std::vector<EdgeAccessor> OutEdges(VertexAccessor vertex_accessor);
-
-  /** Copy assign other, utils::MemoryResource of `this` is used */
-  Graph &operator=(const Graph &);
-
-  /** Move assign other, utils::MemoryResource of `this` is used. */
-  Graph &operator=(Graph &&) noexcept;
-
-  ~Graph();
-
-  utils::pmr::unordered_set<VertexAccessor> &vertices();
-  utils::pmr::unordered_set<EdgeAccessor> &edges();
-  const utils::pmr::unordered_set<VertexAccessor> &vertices() const;
-  const utils::pmr::unordered_set<EdgeAccessor> &edges() const;
-
-  utils::MemoryResource *GetMemoryResource() const;
-
- private:
-  // Contains all the vertices in the Graph.
-  utils::pmr::unordered_set<VertexAccessor> vertices_;
-  // Contains all the edges in the Graph
-  utils::pmr::unordered_set<EdgeAccessor> edges_;
-};
-
-}  // namespace memgraph::query

src/query/interpret/awesome_memgraph_functions.cpp

@@ -587,8 +587,6 @@ TypedValue ValueType(const TypedValue *args, int64_t nargs, const FunctionContex
       return TypedValue("LOCAL_DATE_TIME", ctx.memory);
     case TypedValue::Type::Duration:
       return TypedValue("DURATION", ctx.memory);
-    case TypedValue::Type::Graph:
-      throw QueryRuntimeException("Trying to get graph");
   }
 }
 

src/query/interpret/eval.hpp

@@ -365,9 +365,6 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         }
         throw QueryRuntimeException("Invalid property name {} for LocalDateTime", prop_name);
       }
-      case TypedValue::Type::Graph: {
-        throw QueryRuntimeException("Invalid operation for Graph");
-      }
       default:
         throw QueryRuntimeException("Only nodes, edges, maps and temporal types have properties to be looked-up.");
     }

src/query/interpreter.cpp

@@ -1181,7 +1181,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");
@@ -1248,7 +1248,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");
@@ -1566,8 +1566,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 {};
       }};
 }
@@ -2123,8 +2122,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.

src/query/interpreter.hpp

@@ -173,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

@@ -114,4 +114,4 @@ std::string ExecutionStatsKeyToString(const ExecutionStats::Key key) {
   }
 }
 
-}  // namespace memgraph::query
+}  // namespace memgraph::query

src/query/path.hpp

@@ -31,12 +31,6 @@ class Path {
   /** Allocator type so that STL containers are aware that we need one */
   using allocator_type = utils::Allocator<char>;
 
-  /**
-   * Create the path with no elements
-   * Allocations are done using the given MemoryResource.
-   */
-  explicit Path(utils::MemoryResource *memory) : vertices_(memory), edges_(memory) {}
-
   /**
    * Create the path starting with the given vertex.
    * Allocations are done using the given MemoryResource.

src/query/plan/operator.cpp

@@ -31,7 +31,6 @@
 #include "query/exceptions.hpp"
 #include "query/frontend/ast/ast.hpp"
 #include "query/frontend/semantic/symbol_table.hpp"
-#include "query/graph.hpp"
 #include "query/interpret/eval.hpp"
 #include "query/path.hpp"
 #include "query/plan/scoped_profile.hpp"
@@ -369,13 +368,12 @@ VertexAccessor &CreateExpand::CreateExpandCursor::OtherVertex(Frame &frame, Exec
     TypedValue &dest_node_value = frame[self_.node_info_.symbol];
     ExpectType(self_.node_info_.symbol, dest_node_value, TypedValue::Type::Vertex);
     return dest_node_value.ValueVertex();
-  } else {
-    auto &created_vertex = CreateLocalVertex(self_.node_info_, &frame, context);
-    if (context.trigger_context_collector) {
-      context.trigger_context_collector->RegisterCreatedObject(created_vertex);
-    }
-    return created_vertex;
   }
+  auto &created_vertex = CreateLocalVertex(self_.node_info_, &frame, context);
+  if (context.trigger_context_collector) {
+    context.trigger_context_collector->RegisterCreatedObject(created_vertex);
+  }
+  return created_vertex;
 }
 
 template <class TVerticesFun>
@@ -2601,19 +2599,17 @@ 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::COLLECT_MAP:
-      return TypedValue(TypedValue::TMap(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::PROJECT:
-      return TypedValue(query::Graph(memory));
+    case Aggregation::Op::COLLECT_MAP:
+      return TypedValue(TypedValue::TMap(memory));
   }
 }
 }  // namespace
@@ -2631,9 +2627,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_)
@@ -2778,6 +2772,7 @@ class AggregateCursor : public Cursor {
                "Expected as much AggregationValue.counts_ as there are "
                "aggregations.");
 
+    // we iterate over counts, values and aggregation info at the same time
     auto count_it = agg_value->counts_.begin();
     auto value_it = agg_value->values_.begin();
     auto agg_elem_it = self_.aggregations_.begin();
@@ -2816,11 +2811,6 @@ class AggregateCursor : public Cursor {
           case Aggregation::Op::COLLECT_LIST:
             value_it->ValueList().push_back(input_value);
             break;
-          case Aggregation::Op::PROJECT: {
-            EnsureOkForProject(input_value);
-            value_it->ValueGraph().Expand(input_value.ValuePath());
-            break;
-          }
           case Aggregation::Op::COLLECT_MAP:
             auto key = agg_elem_it->key->Accept(*evaluator);
             if (key.type() != TypedValue::Type::String) throw QueryRuntimeException("Map key must be a string.");
@@ -2869,11 +2859,6 @@ class AggregateCursor : public Cursor {
         case Aggregation::Op::COLLECT_LIST:
           value_it->ValueList().push_back(input_value);
           break;
-        case Aggregation::Op::PROJECT: {
-          EnsureOkForProject(input_value);
-          value_it->ValueGraph().Expand(input_value.ValuePath());
-          break;
-        }
         case Aggregation::Op::COLLECT_MAP:
           auto key = agg_elem_it->key->Accept(*evaluator);
           if (key.type() != TypedValue::Type::String) throw QueryRuntimeException("Map key must be a string.");
@@ -2910,18 +2895,6 @@ class AggregateCursor : public Cursor {
         throw QueryRuntimeException("Only numeric values allowed in SUM and AVG aggregations.");
     }
   }
-
-  /** Checks if the given TypedValue is legal in PROJECT and PROJECT_TRANSITIVE. If not
-   * an appropriate exception is thrown. */
-  // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
-  void EnsureOkForProject(const TypedValue &value) const {
-    switch (value.type()) {
-      case TypedValue::Type::Path:
-        return;
-      default:
-        throw QueryRuntimeException("Only path values allowed in PROJECT aggregation.");
-    }
-  }
 };
 
 UniqueCursorPtr Aggregate::MakeCursor(utils::MemoryResource *mem) const {
@@ -3734,15 +3707,6 @@ void CallCustomProcedure(const std::string_view fully_qualified_procedure_name,
   for (auto *expression : args) {
     args_list.emplace_back(expression->Accept(*evaluator));
   }
-
-  if (!args_list.empty() && args_list.front().type() == TypedValue::Type::Graph) {
-    auto *subgraph =
-        new query::Graph(std::move(args_list.front().ValueGraph()), args_list.front().ValueGraph().GetMemoryResource());
-    args_list.erase(args_list.begin());
-
-    graph.impl = query::SubgraphDbAccessor::MakeSubgraphDbAccessor(std::get<query::DbAccessor *>(graph.impl), subgraph);
-  }
-
   procedure::ConstructArguments(args_list, proc, fully_qualified_procedure_name, proc_args, graph);
   if (memory_limit) {
     SPDLOG_INFO("Running '{}' with memory limit of {}", fully_qualified_procedure_name,

src/query/procedure/mg_procedure_impl.cpp

@@ -38,9 +38,6 @@
 #include "utils/temporal.hpp"
 #include "utils/variant_helpers.hpp"
 
-#include <cppitertools/filter.hpp>
-#include <cppitertools/imap.hpp>
-
 // This file contains implementation of top level C API functions, but this is
 // all actually part of memgraph::query::procedure. So use that namespace for simplicity.
 // NOLINTNEXTLINE(google-build-using-namespace)
@@ -293,8 +290,6 @@ mgp_value_type FromTypedValueType(memgraph::query::TypedValue::Type type) {
       return MGP_VALUE_TYPE_LOCAL_DATE_TIME;
     case memgraph::query::TypedValue::Type::Duration:
       return MGP_VALUE_TYPE_DURATION;
-    case memgraph::query::TypedValue::Type::Graph:
-      throw std::logic_error{"No graph type"};
   }
 }
 }  // namespace
@@ -329,19 +324,17 @@ memgraph::query::TypedValue ToTypedValue(const mgp_value &val, memgraph::utils::
       return memgraph::query::TypedValue(std::move(tv_map));
     }
     case MGP_VALUE_TYPE_VERTEX:
-      return memgraph::query::TypedValue(val.vertex_v->getImpl(), memory);
+      return memgraph::query::TypedValue(val.vertex_v->impl, memory);
     case MGP_VALUE_TYPE_EDGE:
       return memgraph::query::TypedValue(val.edge_v->impl, memory);
     case MGP_VALUE_TYPE_PATH: {
       const auto *path = val.path_v;
       MG_ASSERT(!path->vertices.empty());
       MG_ASSERT(path->vertices.size() == path->edges.size() + 1);
-
-      ;
-      memgraph::query::Path tv_path(path->vertices[0].getImpl(), memory);
+      memgraph::query::Path tv_path(path->vertices[0].impl, memory);
       for (size_t i = 0; i < path->edges.size(); ++i) {
         tv_path.Expand(path->edges[i].impl);
-        tv_path.Expand(path->vertices[i + 1].getImpl());
+        tv_path.Expand(path->vertices[i + 1].impl);
       }
       return memgraph::query::TypedValue(std::move(tv_path));
     }
@@ -461,31 +454,12 @@ mgp_value::mgp_value(const memgraph::query::TypedValue &tv, mgp_graph *graph, me
     }
     case MGP_VALUE_TYPE_VERTEX: {
       memgraph::utils::Allocator<mgp_vertex> allocator(m);
-      vertex_v = std::visit(
-          memgraph::utils::Overloaded{
-              [&](memgraph::query::DbAccessor *) { return allocator.new_object<mgp_vertex>(tv.ValueVertex(), graph); },
-              [&](memgraph::query::SubgraphDbAccessor *impl) {
-                return allocator.new_object<mgp_vertex>(
-                    memgraph::query::SubgraphVertexAccessor(tv.ValueVertex(), impl->getGraph()), graph);
-              }},
-          graph->impl);
-
+      vertex_v = allocator.new_object<mgp_vertex>(tv.ValueVertex(), graph);
       break;
     }
     case MGP_VALUE_TYPE_EDGE: {
       memgraph::utils::Allocator<mgp_edge> allocator(m);
-
-      edge_v = std::visit(
-          memgraph::utils::Overloaded{
-              [&tv, graph, &allocator](memgraph::query::DbAccessor *) {
-                return allocator.new_object<mgp_edge>(tv.ValueEdge(), graph);
-              },
-              [&tv, graph, &allocator](memgraph::query::SubgraphDbAccessor *db_impl) {
-                return allocator.new_object<mgp_edge>(
-                    tv.ValueEdge(), memgraph::query::SubgraphVertexAccessor(tv.ValueEdge().From(), db_impl->getGraph()),
-                    memgraph::query::SubgraphVertexAccessor(tv.ValueEdge().To(), db_impl->getGraph()), graph);
-              }},
-          graph->impl);
+      edge_v = allocator.new_object<mgp_edge>(tv.ValueEdge(), graph);
       break;
     }
     case MGP_VALUE_TYPE_PATH: {
@@ -496,24 +470,11 @@ mgp_value::mgp_value(const memgraph::query::TypedValue &tv, mgp_graph *graph, me
       mgp_path tmp_path(m);
       tmp_path.vertices.reserve(tv.ValuePath().vertices().size());
       for (const auto &v : tv.ValuePath().vertices()) {
-        std::visit(
-            memgraph::utils::Overloaded{
-                [&v, graph, &tmp_path](memgraph::query::DbAccessor *) { tmp_path.vertices.emplace_back(v, graph); },
-                [&v, graph, &tmp_path](memgraph::query::SubgraphDbAccessor *impl) {
-                  tmp_path.vertices.emplace_back(memgraph::query::SubgraphVertexAccessor(v, impl->getGraph()), graph);
-                }},
-            graph->impl);
+        tmp_path.vertices.emplace_back(v, graph);
       }
       tmp_path.edges.reserve(tv.ValuePath().edges().size());
       for (const auto &e : tv.ValuePath().edges()) {
-        std::visit(memgraph::utils::Overloaded{
-                       [&e, graph, &tmp_path](memgraph::query::DbAccessor *) { tmp_path.edges.emplace_back(e, graph); },
-                       [&e, graph, &tmp_path](memgraph::query::SubgraphDbAccessor *db_impl) {
-                         tmp_path.edges.emplace_back(
-                             e, memgraph::query::SubgraphVertexAccessor(e.From(), db_impl->getGraph()),
-                             memgraph::query::SubgraphVertexAccessor(e.To(), db_impl->getGraph()), graph);
-                       }},
-                   graph->impl);
+        tmp_path.edges.emplace_back(e, graph);
       }
       memgraph::utils::Allocator<mgp_path> allocator(m);
       path_v = allocator.new_object<mgp_path>(std::move(tmp_path));
@@ -838,15 +799,7 @@ mgp_value::mgp_value(mgp_value &&other, memgraph::utils::MemoryResource *m) : ty
 mgp_value::~mgp_value() noexcept { DeleteValueMember(this); }
 
 mgp_edge *mgp_edge::Copy(const mgp_edge &edge, mgp_memory &memory) {
-  return std::visit(
-      memgraph::utils::Overloaded{
-          [&](memgraph::query::DbAccessor *) { return NewRawMgpObject<mgp_edge>(&memory, edge.impl, edge.from.graph); },
-          [&](memgraph::query::SubgraphDbAccessor *db_impl) {
-            return NewRawMgpObject<mgp_edge>(
-                &memory, edge.impl, memgraph::query::SubgraphVertexAccessor(edge.impl.From(), db_impl->getGraph()),
-                memgraph::query::SubgraphVertexAccessor(edge.impl.To(), db_impl->getGraph()), edge.to.graph);
-          }},
-      edge.to.graph->impl);
+  return NewRawMgpObject<mgp_edge>(&memory, edge.impl, edge.from.graph);
 }
 
 void mgp_value_destroy(mgp_value *val) { DeleteRawMgpObject(val); }
@@ -1177,7 +1130,7 @@ mgp_error mgp_path_equal(mgp_path *p1, mgp_path *p2, int *result) {
         }
         const auto *start1 = Call<mgp_vertex *>(mgp_path_vertex_at, p1, 0);
         const auto *start2 = Call<mgp_vertex *>(mgp_path_vertex_at, p2, 0);
-        static_assert(noexcept(start1 == start2));
+        static_assert(noexcept(start1->impl == start2->impl));
         if (*start1 != *start2) {
           return 0;
         }
@@ -1544,15 +1497,9 @@ mgp_error mgp_properties_iterator_next(mgp_properties_iterator *it, mgp_property
           return nullptr;
         }
         memgraph::utils::OnScopeExit clean_up([it] { it->current = std::nullopt; });
-        auto propToName = std::visit(
-            memgraph::utils::Overloaded{
-                [it](auto *impl) {
-                  return memgraph::utils::pmr::string(impl->PropertyToName(it->current_it->first),
-                                                      it->GetMemoryResource());
-                },
-            },
-            it->graph->impl);
-        it->current.emplace(propToName, mgp_value(it->current_it->second, it->GetMemoryResource()));
+        it->current.emplace(memgraph::utils::pmr::string(it->graph->impl->PropertyToName(it->current_it->first),
+                                                         it->GetMemoryResource()),
+                            mgp_value(it->current_it->second, it->GetMemoryResource()));
         it->property.name = it->current->first.c_str();
         it->property.value = &it->current->second;
         clean_up.Disable();
@@ -1562,12 +1509,7 @@ mgp_error mgp_properties_iterator_next(mgp_properties_iterator *it, mgp_property
 }
 
 mgp_error mgp_vertex_get_id(mgp_vertex *v, mgp_vertex_id *result) {
-  return WrapExceptions(
-      [v] {
-        return mgp_vertex_id{
-            .as_int = std::visit(memgraph::utils::Overloaded{[](auto &impl) { return impl.Gid().AsInt(); }}, v->impl)};
-      },
-      result);
+  return WrapExceptions([v] { return mgp_vertex_id{.as_int = v->impl.Gid().AsInt()}; }, result);
 }
 
 mgp_error mgp_vertex_underlying_graph_is_mutable(mgp_vertex *v, int *result) {
@@ -1639,15 +1581,8 @@ mgp_error mgp_vertex_set_property(struct mgp_vertex *v, const char *property_nam
     if (!MgpVertexIsMutable(*v)) {
       throw ImmutableObjectException{"Cannot set a property on an immutable vertex!"};
     }
-
-    const auto prop_key = std::visit(
-        memgraph::utils::Overloaded{[property_name](auto *impl) { return impl->NameToProperty(property_name); }},
-        v->graph->impl);
-
-    const auto result = std::visit(memgraph::utils::Overloaded{[prop_key, property_value](auto &impl) {
-                                     return impl.SetProperty(prop_key, ToPropertyValue(*property_value));
-                                   }},
-                                   v->impl);
+    const auto prop_key = v->graph->impl->NameToProperty(property_name);
+    const auto result = v->impl.SetProperty(prop_key, ToPropertyValue(*property_value));
     if (result.HasError()) {
       switch (result.GetError()) {
         case memgraph::storage::Error::DELETED_OBJECT:
@@ -1673,11 +1608,11 @@ mgp_error mgp_vertex_set_property(struct mgp_vertex *v, const char *property_nam
     }
     const auto old_value = memgraph::query::TypedValue(*result);
     if (property_value->type == mgp_value_type::MGP_VALUE_TYPE_NULL) {
-      trigger_ctx_collector->RegisterRemovedObjectProperty(v->getImpl(), prop_key, old_value);
+      trigger_ctx_collector->RegisterRemovedObjectProperty(v->impl, prop_key, old_value);
       return;
     }
     const auto new_value = ToTypedValue(*property_value, property_value->memory);
-    trigger_ctx_collector->RegisterSetObjectProperty(v->getImpl(), prop_key, old_value, new_value);
+    trigger_ctx_collector->RegisterSetObjectProperty(v->impl, prop_key, old_value, new_value);
   });
 }
 
@@ -1686,18 +1621,8 @@ mgp_error mgp_vertex_add_label(struct mgp_vertex *v, mgp_label label) {
     if (!MgpVertexIsMutable(*v)) {
       throw ImmutableObjectException{"Cannot add a label to an immutable vertex!"};
     }
-    const auto label_id = std::visit(
-        memgraph::utils::Overloaded{
-            [label](auto *impl) { return impl->NameToLabel(label.name); },
-        },
-        v->graph->impl);
-
-    const auto result = std::visit(
-        memgraph::utils::Overloaded{
-            [label_id](auto &impl) { return impl.AddLabel(label_id); },
-
-        },
-        v->impl);
+    const auto label_id = v->graph->impl->NameToLabel(label.name);
+    const auto result = v->impl.AddLabel(label_id);
 
     if (result.HasError()) {
       switch (result.GetError()) {
@@ -1718,7 +1643,7 @@ mgp_error mgp_vertex_add_label(struct mgp_vertex *v, mgp_label label) {
     ctx->execution_stats[memgraph::query::ExecutionStats::Key::CREATED_LABELS] += 1;
 
     if (ctx->trigger_context_collector) {
-      ctx->trigger_context_collector->RegisterSetVertexLabel(v->getImpl(), label_id);
+      ctx->trigger_context_collector->RegisterSetVertexLabel(v->impl, label_id);
     }
   });
 }
@@ -1728,17 +1653,8 @@ mgp_error mgp_vertex_remove_label(struct mgp_vertex *v, mgp_label label) {
     if (!MgpVertexIsMutable(*v)) {
       throw ImmutableObjectException{"Cannot remove a label from an immutable vertex!"};
     }
-    const auto label_id = std::visit(
-        memgraph::utils::Overloaded{
-            [label](auto *impl) { return impl->NameToLabel(label.name); },
-        },
-        v->graph->impl);
-    const auto result = std::visit(
-        memgraph::utils::Overloaded{
-            [label_id](auto &impl) { return impl.RemoveLabel(label_id); },
-
-        },
-        v->impl);
+    const auto label_id = v->graph->impl->NameToLabel(label.name);
+    const auto result = v->impl.RemoveLabel(label_id);
 
     if (result.HasError()) {
       switch (result.GetError()) {
@@ -1759,7 +1675,7 @@ mgp_error mgp_vertex_remove_label(struct mgp_vertex *v, mgp_label label) {
     ctx->execution_stats[memgraph::query::ExecutionStats::Key::DELETED_LABELS] += 1;
 
     if (ctx->trigger_context_collector) {
-      ctx->trigger_context_collector->RegisterRemovedVertexLabel(v->getImpl(), label_id);
+      ctx->trigger_context_collector->RegisterRemovedVertexLabel(v->impl, label_id);
     }
   });
 }
@@ -1780,8 +1696,7 @@ mgp_error mgp_vertex_equal(mgp_vertex *v1, mgp_vertex *v2, int *result) {
 mgp_error mgp_vertex_labels_count(mgp_vertex *v, size_t *result) {
   return WrapExceptions(
       [v]() -> size_t {
-        auto maybe_labels = std::visit(
-            memgraph::utils::Overloaded{[v](const auto &impl) { return impl.Labels(v->graph->view); }}, v->impl);
+        auto maybe_labels = v->impl.Labels(v->graph->view);
         if (maybe_labels.HasError()) {
           switch (maybe_labels.GetError()) {
             case memgraph::storage::Error::DELETED_OBJECT:
@@ -1803,11 +1718,7 @@ mgp_error mgp_vertex_label_at(mgp_vertex *v, size_t i, mgp_label *result) {
   return WrapExceptions(
       [v, i]() -> const char * {
         // TODO: Maybe it's worth caching this in mgp_vertex.
-        auto maybe_labels = std::visit(
-            memgraph::utils::Overloaded{
-                [v](const auto &impl) { return impl.Labels(v->graph->view); },
-            },
-            v->impl);
+        auto maybe_labels = v->impl.Labels(v->graph->view);
         if (maybe_labels.HasError()) {
           switch (maybe_labels.GetError()) {
             case memgraph::storage::Error::DELETED_OBJECT:
@@ -1824,16 +1735,10 @@ mgp_error mgp_vertex_label_at(mgp_vertex *v, size_t i, mgp_label *result) {
           throw std::out_of_range("Label cannot be retrieved, because index exceeds the number of labels!");
         }
         const auto &label = (*maybe_labels)[i];
-        static_assert(std::is_lvalue_reference_v<
-                          decltype(std::get<memgraph::query::DbAccessor *>(v->graph->impl)->LabelToName(label))>,
+        static_assert(std::is_lvalue_reference_v<decltype(v->graph->impl->LabelToName(label))>,
                       "Expected LabelToName to return a pointer or reference, so we "
                       "don't have to take a copy and manage memory.");
-
-        const auto &name = std::visit(
-            memgraph::utils::Overloaded{
-                [label](const auto *impl) { return impl->LabelToName(label); },
-            },
-            v->graph->impl);
+        const auto &name = v->graph->impl->LabelToName(label);
         return name.c_str();
       },
       &result->name);
@@ -1843,17 +1748,9 @@ mgp_error mgp_vertex_has_label_named(mgp_vertex *v, const char *name, int *resul
   return WrapExceptions(
       [v, name] {
         memgraph::storage::LabelId label;
-        label = std::visit(
-            memgraph::utils::Overloaded{
-                [name](auto *impl) { return impl->NameToLabel(name); },
-            },
-            v->graph->impl);
+        label = v->graph->impl->NameToLabel(name);
 
-        auto maybe_has_label = std::visit(
-            memgraph::utils::Overloaded{
-                [v, label](auto &impl) { return impl.HasLabel(v->graph->view, label); },
-            },
-            v->impl);
+        auto maybe_has_label = v->impl.HasLabel(v->graph->view, label);
         if (maybe_has_label.HasError()) {
           switch (maybe_has_label.GetError()) {
             case memgraph::storage::Error::DELETED_OBJECT:
@@ -1881,17 +1778,8 @@ mgp_error mgp_vertex_has_label(mgp_vertex *v, mgp_label label, int *result) {
 mgp_error mgp_vertex_get_property(mgp_vertex *v, const char *name, mgp_memory *memory, mgp_value **result) {
   return WrapExceptions(
       [v, name, memory]() -> mgp_value * {
-        const auto &key = std::visit(
-            memgraph::utils::Overloaded{
-                [name](auto *impl) { return impl->NameToProperty(name); },
-            },
-            v->graph->impl);
-
-        auto maybe_prop = std::visit(
-            memgraph::utils::Overloaded{
-                [v, key](auto &impl) { return impl.GetProperty(v->graph->view, key); },
-            },
-            v->impl);
+        const auto &key = v->graph->impl->NameToProperty(name);
+        auto maybe_prop = v->impl.GetProperty(v->graph->view, key);
         if (maybe_prop.HasError()) {
           switch (maybe_prop.GetError()) {
             case memgraph::storage::Error::DELETED_OBJECT:
@@ -1917,11 +1805,7 @@ mgp_error mgp_vertex_iter_properties(mgp_vertex *v, mgp_memory *memory, mgp_prop
   // will probably require a different API in storage.
   return WrapExceptions(
       [v, memory] {
-        auto maybe_props = std::visit(
-            memgraph::utils::Overloaded{
-                [v](auto &impl) { return impl.Properties(v->graph->view); },
-            },
-            v->impl);
+        auto maybe_props = v->impl.Properties(v->graph->view);
         if (maybe_props.HasError()) {
           switch (maybe_props.GetError()) {
             case memgraph::storage::Error::DELETED_OBJECT:
@@ -1949,11 +1833,7 @@ mgp_error mgp_vertex_iter_in_edges(mgp_vertex *v, mgp_memory *memory, mgp_edges_
         auto it = NewMgpObject<mgp_edges_iterator>(memory, *v);
         MG_ASSERT(it != nullptr);
 
-        auto maybe_edges = std::visit(
-            memgraph::utils::Overloaded{
-                [v](auto &impl) { return impl.InEdges(v->graph->view); },
-            },
-            v->impl);
+        auto maybe_edges = v->impl.InEdges(v->graph->view);
         if (maybe_edges.HasError()) {
           switch (maybe_edges.GetError()) {
             case memgraph::storage::Error::DELETED_OBJECT:
@@ -1971,19 +1851,7 @@ mgp_error mgp_vertex_iter_in_edges(mgp_vertex *v, mgp_memory *memory, mgp_edges_
         it->in.emplace(std::move(*maybe_edges));
         it->in_it.emplace(it->in->begin());
         if (*it->in_it != it->in->end()) {
-          std::visit(memgraph::utils::Overloaded{
-                         [&](memgraph::query::DbAccessor *) {
-                           it->current_e.emplace(**it->in_it, (**it->in_it).From(), (**it->in_it).To(), v->graph,
-                                                 it->GetMemoryResource());
-                         },
-                         [&](memgraph::query::SubgraphDbAccessor *impl) {
-                           it->current_e.emplace(
-                               **it->in_it,
-                               memgraph::query::SubgraphVertexAccessor((**it->in_it).From(), impl->getGraph()),
-                               memgraph::query::SubgraphVertexAccessor((**it->in_it).To(), impl->getGraph()), v->graph,
-                               it->GetMemoryResource());
-                         }},
-                     v->graph->impl);
+          it->current_e.emplace(**it->in_it, v->graph, it->GetMemoryResource());
         }
 
         return it.release();
@@ -1996,12 +1864,8 @@ mgp_error mgp_vertex_iter_out_edges(mgp_vertex *v, mgp_memory *memory, mgp_edges
       [v, memory] {
         auto it = NewMgpObject<mgp_edges_iterator>(memory, *v);
         MG_ASSERT(it != nullptr);
-        auto maybe_edges = std::visit(
-            memgraph::utils::Overloaded{
-                [v](auto &impl) { return impl.OutEdges(v->graph->view); },
-            },
-            v->impl);
 
+        auto maybe_edges = v->impl.OutEdges(v->graph->view);
         if (maybe_edges.HasError()) {
           switch (maybe_edges.GetError()) {
             case memgraph::storage::Error::DELETED_OBJECT:
@@ -2016,23 +1880,10 @@ mgp_error mgp_vertex_iter_out_edges(mgp_vertex *v, mgp_memory *memory, mgp_edges
               LOG_FATAL("Unexpected error when getting the outbound edges of a vertex.");
           }
         }
-
         it->out.emplace(std::move(*maybe_edges));
         it->out_it.emplace(it->out->begin());
         if (*it->out_it != it->out->end()) {
-          std::visit(memgraph::utils::Overloaded{
-                         [&](memgraph::query::DbAccessor *) {
-                           it->current_e.emplace(**it->out_it, (**it->out_it).From(), (**it->out_it).To(), v->graph,
-                                                 it->GetMemoryResource());
-                         },
-                         [&](memgraph::query::SubgraphDbAccessor *impl) {
-                           it->current_e.emplace(
-                               **it->out_it,
-                               memgraph::query::SubgraphVertexAccessor((**it->out_it).From(), impl->getGraph()),
-                               memgraph::query::SubgraphVertexAccessor((**it->out_it).To(), impl->getGraph()), v->graph,
-                               it->GetMemoryResource());
-                         }},
-                     v->graph->impl);
+          it->current_e.emplace(**it->out_it, v->graph, it->GetMemoryResource());
         }
 
         return it.release();
@@ -2070,19 +1921,7 @@ mgp_error mgp_edges_iterator_next(mgp_edges_iterator *it, mgp_edge **result) {
             it->current_e = std::nullopt;
             return nullptr;
           }
-          std::visit(memgraph::utils::Overloaded{
-                         [&](memgraph::query::DbAccessor *) {
-                           it->current_e.emplace(**impl_it, (**impl_it).From(), (**impl_it).To(),
-                                                 it->source_vertex.graph, it->GetMemoryResource());
-                         },
-                         [&](memgraph::query::SubgraphDbAccessor *impl) {
-                           it->current_e.emplace(
-                               **impl_it, memgraph::query::SubgraphVertexAccessor((**impl_it).From(), impl->getGraph()),
-                               memgraph::query::SubgraphVertexAccessor((**impl_it).To(), impl->getGraph()),
-                               it->source_vertex.graph, it->GetMemoryResource());
-                         }},
-                     it->source_vertex.graph->impl);
-
+          it->current_e.emplace(**impl_it, it->source_vertex.graph, it->GetMemoryResource());
           return &*it->current_e;
         };
         if (it->in_it) {
@@ -2117,14 +1956,10 @@ mgp_error mgp_edge_equal(mgp_edge *e1, mgp_edge *e2, int *result) {
 mgp_error mgp_edge_get_type(mgp_edge *e, mgp_edge_type *result) {
   return WrapExceptions(
       [e] {
-        const auto &name = std::visit(
-            memgraph::utils::Overloaded{
-                [e](const auto *impl) { return impl->EdgeTypeToName(e->impl.EdgeType()); },
-            },
-            e->from.graph->impl);
-        // static_assert(std::is_lvalue_reference_v<decltype(e->from.graph->impl->EdgeTypeToName(e->impl.EdgeType()))>,
-        //               "Expected EdgeTypeToName to return a pointer or reference, so we "
-        //               "don't have to take a copy and manage memory.");
+        const auto &name = e->from.graph->impl->EdgeTypeToName(e->impl.EdgeType());
+        static_assert(std::is_lvalue_reference_v<decltype(e->from.graph->impl->EdgeTypeToName(e->impl.EdgeType()))>,
+                      "Expected EdgeTypeToName to return a pointer or reference, so we "
+                      "don't have to take a copy and manage memory.");
         return name.c_str();
       },
       &result->name);
@@ -2143,11 +1978,7 @@ mgp_error mgp_edge_get_to(mgp_edge *e, mgp_vertex **result) {
 mgp_error mgp_edge_get_property(mgp_edge *e, const char *name, mgp_memory *memory, mgp_value **result) {
   return WrapExceptions(
       [e, name, memory] {
-        const auto &key = std::visit(
-            memgraph::utils::Overloaded{
-                [name](auto *impl) { return impl->NameToProperty(name); },
-            },
-            e->from.graph->impl);
+        const auto &key = e->from.graph->impl->NameToProperty(name);
         auto view = e->from.graph->view;
         auto maybe_prop = e->impl.GetProperty(view, key);
         if (maybe_prop.HasError()) {
@@ -2173,11 +2004,7 @@ mgp_error mgp_edge_set_property(struct mgp_edge *e, const char *property_name, m
     if (!MgpEdgeIsMutable(*e)) {
       throw ImmutableObjectException{"Cannot set a property on an immutable edge!"};
     }
-    const auto prop_key = std::visit(
-        memgraph::utils::Overloaded{
-            [property_name](auto *impl) { return impl->NameToProperty(property_name); },
-        },
-        e->from.graph->impl);
+    const auto prop_key = e->from.graph->impl->NameToProperty(property_name);
     const auto result = e->impl.SetProperty(prop_key, ToPropertyValue(*property_value));
 
     if (result.HasError()) {
@@ -2244,24 +2071,9 @@ mgp_error mgp_edge_iter_properties(mgp_edge *e, mgp_memory *memory, mgp_properti
 mgp_error mgp_graph_get_vertex_by_id(mgp_graph *graph, mgp_vertex_id id, mgp_memory *memory, mgp_vertex **result) {
   return WrapExceptions(
       [graph, id, memory]() -> mgp_vertex * {
-        std::optional<memgraph::query::VertexAccessor> maybe_vertex = std::visit(
-            memgraph::utils::Overloaded{
-                [graph, id](auto *impl) {
-                  return impl->FindVertex(memgraph::storage::Gid::FromInt(id.as_int), graph->view);
-                },
-            },
-            graph->impl);
+        auto maybe_vertex = graph->impl->FindVertex(memgraph::storage::Gid::FromInt(id.as_int), graph->view);
         if (maybe_vertex) {
-          return std::visit(memgraph::utils::Overloaded{
-                                [memory, graph, maybe_vertex](memgraph::query::DbAccessor *) {
-                                  return NewRawMgpObject<mgp_vertex>(memory, *maybe_vertex, graph);
-                                },
-                                [memory, graph, maybe_vertex](memgraph::query::SubgraphDbAccessor *impl) {
-                                  return NewRawMgpObject<mgp_vertex>(
-                                      memory, memgraph::query::SubgraphVertexAccessor(*maybe_vertex, impl->getGraph()),
-                                      graph);
-                                }},
-                            graph->impl);
+          return NewRawMgpObject<mgp_vertex>(memory, *maybe_vertex, graph);
         }
         return nullptr;
       },
@@ -2279,18 +2091,15 @@ mgp_error mgp_graph_create_vertex(struct mgp_graph *graph, mgp_memory *memory, m
         if (!MgpGraphIsMutable(*graph)) {
           throw ImmutableObjectException{"Cannot create a vertex in an immutable graph!"};
         }
-        auto *vertex = std::visit(memgraph::utils::Overloaded{[=](auto *impl) {
-                                    return NewRawMgpObject<mgp_vertex>(memory, impl->InsertVertex(), graph);
-                                  }},
-                                  graph->impl);
+        auto vertex = graph->impl->InsertVertex();
 
         auto &ctx = graph->ctx;
         ctx->execution_stats[memgraph::query::ExecutionStats::Key::CREATED_NODES] += 1;
 
         if (ctx->trigger_context_collector) {
-          ctx->trigger_context_collector->RegisterCreatedObject(vertex->getImpl());
+          ctx->trigger_context_collector->RegisterCreatedObject(vertex);
         }
-        return vertex;
+        return NewRawMgpObject<mgp_vertex>(memory, vertex, graph);
       },
       result);
 }
@@ -2300,24 +2109,7 @@ mgp_error mgp_graph_delete_vertex(struct mgp_graph *graph, mgp_vertex *vertex) {
     if (!MgpGraphIsMutable(*graph)) {
       throw ImmutableObjectException{"Cannot remove a vertex from an immutable graph!"};
     }
-
-    const auto result =
-        std::visit(memgraph::utils::Overloaded{
-                       [&](memgraph::query::DbAccessor *impl) {
-                         if (std::holds_alternative<memgraph::query::SubgraphVertexAccessor>(vertex->impl)) {
-                           throw std::logic_error{
-                               "Remove vertex for DbAccessor should not get reference to SubgraphVertexAccessor"};
-                         }
-                         return impl->RemoveVertex(&std::get<memgraph::query::VertexAccessor>(vertex->impl));
-                       },
-                       [&](memgraph::query::SubgraphDbAccessor *impl) {
-                         if (std::holds_alternative<memgraph::query::VertexAccessor>(vertex->impl)) {
-                           throw std::logic_error{
-                               "Remove vertex for SubgraphDbAccessor should not get reference to VertexAccessor"};
-                         }
-                         return impl->RemoveVertex(&(std::get<memgraph::query::SubgraphVertexAccessor>(vertex->impl)));
-                       }},
-                   graph->impl);
+    const auto result = graph->impl->RemoveVertex(&vertex->impl);
 
     if (result.HasError()) {
       switch (result.GetError()) {
@@ -2352,23 +2144,7 @@ mgp_error mgp_graph_detach_delete_vertex(struct mgp_graph *graph, mgp_vertex *ve
     if (!MgpGraphIsMutable(*graph)) {
       throw ImmutableObjectException{"Cannot remove a vertex from an immutable graph!"};
     }
-    const auto result =
-        std::visit(memgraph::utils::Overloaded{
-                       [vertex](memgraph::query::DbAccessor *impl) {
-                         if (std::holds_alternative<memgraph::query::SubgraphVertexAccessor>(vertex->impl)) {
-                           throw std::logic_error{"Wrong type"};
-                         }
-                         return impl->DetachRemoveVertex(&std::get<memgraph::query::VertexAccessor>(vertex->impl));
-                       },
-                       [vertex](memgraph::query::SubgraphDbAccessor *impl) {
-                         // todo antoniofilipovic change this, it is wrong here since it needs to be
-                         // SubgraphVertexAccessor
-                         if (std::holds_alternative<memgraph::query::SubgraphVertexAccessor>(vertex->impl)) {
-                           throw std::logic_error{"Wrong type"};
-                         }
-                         return impl->DetachRemoveVertex(&std::get<memgraph::query::VertexAccessor>(vertex->impl));
-                       }},
-                   graph->impl);
+    const auto result = graph->impl->DetachRemoveVertex(&vertex->impl);
 
     if (result.HasError()) {
       switch (result.GetError()) {
@@ -2415,28 +2191,8 @@ mgp_error mgp_graph_create_edge(mgp_graph *graph, mgp_vertex *from, mgp_vertex *
         if (!MgpGraphIsMutable(*graph)) {
           throw ImmutableObjectException{"Cannot create an edge in an immutable graph!"};
         }
-        auto edge =
-            std::visit(memgraph::utils::Overloaded{
-                           [from, to, type](memgraph::query::DbAccessor *impl) {
-                             if (std::holds_alternative<memgraph::query::SubgraphVertexAccessor>(from->impl) ||
-                                 std::holds_alternative<memgraph::query::SubgraphVertexAccessor>(to->impl)) {
-                               throw std::logic_error{"Both vertices must be of VertexAccessor type"};
-                             }
-                             return impl->InsertEdge(&std::get<memgraph::query::VertexAccessor>(from->impl),
-                                                     &std::get<memgraph::query::VertexAccessor>(to->impl),
-                                                     impl->NameToEdgeType(type.name));
-                           },
-                           [from, to, type](memgraph::query::SubgraphDbAccessor *impl) {
-                             if (std::holds_alternative<memgraph::query::VertexAccessor>(from->impl) ||
-                                 std::holds_alternative<memgraph::query::VertexAccessor>(to->impl)) {
-                               throw std::logic_error{"Both vertices must be of SubgraphVertexAccessor type"};
-                             }
-                             return impl->InsertEdge(&std::get<memgraph::query::SubgraphVertexAccessor>(from->impl),
-                                                     &std::get<memgraph::query::SubgraphVertexAccessor>(to->impl),
-                                                     impl->NameToEdgeType(type.name));
-                           }},
-                       graph->impl);
 
+        auto edge = graph->impl->InsertEdge(&from->impl, &to->impl, from->graph->impl->NameToEdgeType(type.name));
         if (edge.HasError()) {
           switch (edge.GetError()) {
             case memgraph::storage::Error::DELETED_OBJECT:
@@ -2457,18 +2213,7 @@ mgp_error mgp_graph_create_edge(mgp_graph *graph, mgp_vertex *from, mgp_vertex *
         if (ctx->trigger_context_collector) {
           ctx->trigger_context_collector->RegisterCreatedObject(*edge);
         }
-        return std::visit(
-            memgraph::utils::Overloaded{
-                [memory, edge, from](memgraph::query::DbAccessor *) {
-                  return NewRawMgpObject<mgp_edge>(memory->impl, edge.GetValue(), from->graph);
-                },
-                [memory, edge, from](memgraph::query::SubgraphDbAccessor *db_impl) {
-                  const auto &v_from =
-                      memgraph::query::SubgraphVertexAccessor(edge.GetValue().From(), db_impl->getGraph());
-                  const auto &v_to = memgraph::query::SubgraphVertexAccessor(edge.GetValue().To(), db_impl->getGraph());
-                  return NewRawMgpObject<mgp_edge>(memory->impl, edge.GetValue(), v_from, v_to, from->graph);
-                }},
-            graph->impl);
+        return NewRawMgpObject<mgp_edge>(memory, edge.GetValue(), from->graph);
       },
       result);
 }
@@ -2478,9 +2223,8 @@ mgp_error mgp_graph_delete_edge(struct mgp_graph *graph, mgp_edge *edge) {
     if (!MgpGraphIsMutable(*graph)) {
       throw ImmutableObjectException{"Cannot remove an edge from an immutable graph!"};
     }
+    const auto result = graph->impl->RemoveEdge(&edge->impl);
 
-    const auto result = std::visit(
-        memgraph::utils::Overloaded{[edge](auto *impl) { return impl->RemoveEdge(&edge->impl); }}, graph->impl);
     if (result.HasError()) {
       switch (result.GetError()) {
         case memgraph::storage::Error::NONEXISTENT_OBJECT:
@@ -2541,18 +2285,7 @@ mgp_error mgp_vertices_iterator_next(mgp_vertices_iterator *it, mgp_vertex **res
           return nullptr;
         }
         memgraph::utils::OnScopeExit clean_up([it] { it->current_v = std::nullopt; });
-        std::visit(memgraph::utils::Overloaded{[it](memgraph::query::DbAccessor *) {
-                                                 it->current_v.emplace(*it->current_it, it->graph,
-                                                                       it->GetMemoryResource());
-                                                 ;
-                                               },
-                                               [it](memgraph::query::SubgraphDbAccessor *impl) {
-                                                 it->current_v.emplace(memgraph::query::SubgraphVertexAccessor(
-                                                                           *it->current_it, impl->getGraph()),
-                                                                       it->graph, it->GetMemoryResource());
-                                               }},
-                   it->graph->impl);
-
+        it->current_v.emplace(*it->current_it, it->graph, it->GetMemoryResource());
         clean_up.Disable();
         return &*it->current_v;
       },
@@ -2835,7 +2568,6 @@ std::ostream &PrintValue(const TypedValue &value, std::ostream *stream) {
     case TypedValue::Type::Vertex:
     case TypedValue::Type::Edge:
     case TypedValue::Type::Path:
-    case TypedValue::Type::Graph:
       LOG_FATAL("value must not be a graph element");
   }
 }

src/query/procedure/mg_procedure_impl.hpp

@@ -32,7 +32,6 @@
 #include "utils/pmr/string.hpp"
 #include "utils/pmr/vector.hpp"
 #include "utils/temporal.hpp"
-#include "utils/variant_helpers.hpp"
 /// Wraps memory resource used in custom procedures.
 ///
 /// This should have been `using mgp_memory = memgraph::utils::MemoryResource`, but that's
@@ -443,69 +442,21 @@ struct mgp_vertex {
   mgp_vertex(memgraph::query::VertexAccessor v, mgp_graph *graph, memgraph::utils::MemoryResource *memory) noexcept
       : memory(memory), impl(v), graph(graph) {}
 
-  mgp_vertex(memgraph::query::SubgraphVertexAccessor v, mgp_graph *graph,
-             memgraph::utils::MemoryResource *memory) noexcept
-      : memory(memory), impl(v), graph(graph) {}
-
   mgp_vertex(const mgp_vertex &other, memgraph::utils::MemoryResource *memory) noexcept
-      : memory(memory), impl(other.impl), graph(other.graph) {
-    std::visit(memgraph::utils::Overloaded{
-                   [](memgraph::query::VertexAccessor) { std::cout << "VertexAccessor" << std::endl; },
-                   [](memgraph::query::SubgraphVertexAccessor) { std::cout << "SubgraphVertexAccessor" << std::endl; }},
-               other.impl);
-
-    std::visit(memgraph::utils::Overloaded{
-                   [](memgraph::query::VertexAccessor) { std::cout << "VertexAccessor" << std::endl; },
-                   [](memgraph::query::SubgraphVertexAccessor) { std::cout << "SubgraphVertexAccessor" << std::endl; }},
-               this->impl);
-  }
+      : memory(memory), impl(other.impl), graph(other.graph) {}
 
   mgp_vertex(mgp_vertex &&other, memgraph::utils::MemoryResource *memory) noexcept
-      : memory(memory), impl(other.impl), graph(other.graph) {
-    std::visit(memgraph::utils::Overloaded{
-                   [](memgraph::query::VertexAccessor) { std::cout << "VertexAccessor" << std::endl; },
-                   [](memgraph::query::SubgraphVertexAccessor) { std::cout << "SubgraphVertexAccessor" << std::endl; }},
-               other.impl);
-
-    std::visit(memgraph::utils::Overloaded{
-                   [](memgraph::query::VertexAccessor) { std::cout << "VertexAccessor" << std::endl; },
-                   [](memgraph::query::SubgraphVertexAccessor) { std::cout << "SubgraphVertexAccessor" << std::endl; }},
-               this->impl);
-  }
+      : memory(memory), impl(other.impl), graph(other.graph) {}
 
   mgp_vertex(mgp_vertex &&other) noexcept : memory(other.memory), impl(other.impl), graph(other.graph) {}
 
-  memgraph::query::VertexAccessor getImpl() const {
-    return std::visit(
-        memgraph::utils::Overloaded{[](memgraph::query::VertexAccessor impl) { return impl; },
-                                    [](memgraph::query::SubgraphVertexAccessor impl) { return impl.impl_; }},
-        this->impl);
-  }
-
   /// Copy construction without memgraph::utils::MemoryResource is not allowed.
   mgp_vertex(const mgp_vertex &) = delete;
 
   mgp_vertex &operator=(const mgp_vertex &) = delete;
   mgp_vertex &operator=(mgp_vertex &&) = delete;
 
-  bool operator==(const mgp_vertex &other) const noexcept {
-    return std::visit(memgraph::utils::Overloaded{
-                          [&other](memgraph::query::VertexAccessor impl) {
-                            if (std::holds_alternative<memgraph::query::SubgraphVertexAccessor>(other.impl)) {
-                              return false;
-                            }
-                            return impl == std::get<memgraph::query::VertexAccessor>(other.impl);
-                          },
-                          [&other](memgraph::query::SubgraphVertexAccessor impl) -> bool {
-                            if (std::holds_alternative<memgraph::query::VertexAccessor>(other.impl)) {
-                              return false;
-                            }
-                            return impl == std::get<memgraph::query::SubgraphVertexAccessor>(other.impl);
-                          },
-                      },
-                      this->impl);
-  }
-
+  bool operator==(const mgp_vertex &other) const noexcept { return this->impl == other.impl; }
   bool operator!=(const mgp_vertex &other) const noexcept { return !(*this == other); };
 
   ~mgp_vertex() = default;
@@ -513,38 +464,10 @@ struct mgp_vertex {
   memgraph::utils::MemoryResource *GetMemoryResource() const noexcept { return memory; }
 
   memgraph::utils::MemoryResource *memory;
-  std::variant<memgraph::query::VertexAccessor, memgraph::query::SubgraphVertexAccessor> impl;
+  memgraph::query::VertexAccessor impl;
   mgp_graph *graph;
 };
 
-struct mgp_graph {
-  std::variant<memgraph::query::DbAccessor *, memgraph::query::SubgraphDbAccessor *> impl;
-  memgraph::storage::View view;
-  // TODO: Merge `mgp_graph` and `mgp_memory` into a single `mgp_context`. The
-  // `ctx` field is out of place here.
-  memgraph::query::ExecutionContext *ctx;
-
-  // memgraph:::query::Graph *subraph;
-
-  static mgp_graph WritableGraph(memgraph::query::DbAccessor &acc, memgraph::storage::View view,
-                                 memgraph::query::ExecutionContext &ctx) {
-    return mgp_graph{&acc, view, &ctx};
-  }
-
-  static mgp_graph NonWritableGraph(memgraph::query::DbAccessor &acc, memgraph::storage::View view) {
-    return mgp_graph{&acc, view, nullptr};
-  }
-
-  static mgp_graph WritableGraph(memgraph::query::SubgraphDbAccessor &acc, memgraph::storage::View view,
-                                 memgraph::query::ExecutionContext &ctx) {
-    return mgp_graph{&acc, view, &ctx};
-  }
-
-  static mgp_graph NonWritableGraph(memgraph::query::SubgraphDbAccessor &acc, memgraph::storage::View view) {
-    return mgp_graph{&acc, view, nullptr};
-  }
-};
-
 struct mgp_edge {
   /// Allocator type so that STL containers are aware that we need one.
   /// We don't actually need this, but it simplifies the C API, because we store
@@ -561,16 +484,6 @@ struct mgp_edge {
            memgraph::utils::MemoryResource *memory) noexcept
       : memory(memory), impl(impl), from(impl.From(), graph, memory), to(impl.To(), graph, memory) {}
 
-  mgp_edge(const memgraph::query::EdgeAccessor &impl, const memgraph::query::VertexAccessor &from_v,
-           const memgraph::query::VertexAccessor &to_v, mgp_graph *graph,
-           memgraph::utils::MemoryResource *memory) noexcept
-      : memory(memory), impl(impl), from(from_v, graph, memory), to(to_v, graph, memory) {}
-
-  mgp_edge(const memgraph::query::EdgeAccessor &impl, const memgraph::query::SubgraphVertexAccessor &from_v,
-           const memgraph::query::SubgraphVertexAccessor &to_v, mgp_graph *graph,
-           memgraph::utils::MemoryResource *memory) noexcept
-      : memory(memory), impl(impl), from(from_v, graph, memory), to(to_v, graph, memory) {}
-
   mgp_edge(const mgp_edge &other, memgraph::utils::MemoryResource *memory) noexcept
       : memory(memory), impl(other.impl), from(other.from, memory), to(other.to, memory) {}
 
@@ -657,6 +570,23 @@ struct mgp_func_result {
   std::optional<memgraph::utils::pmr::string> error_msg;
 };
 
+struct mgp_graph {
+  memgraph::query::DbAccessor *impl;
+  memgraph::storage::View view;
+  // TODO: Merge `mgp_graph` and `mgp_memory` into a single `mgp_context`. The
+  // `ctx` field is out of place here.
+  memgraph::query::ExecutionContext *ctx;
+
+  static mgp_graph WritableGraph(memgraph::query::DbAccessor &acc, memgraph::storage::View view,
+                                 memgraph::query::ExecutionContext &ctx) {
+    return mgp_graph{&acc, view, &ctx};
+  }
+
+  static mgp_graph NonWritableGraph(memgraph::query::DbAccessor &acc, memgraph::storage::View view) {
+    return mgp_graph{&acc, view, nullptr};
+  }
+};
+
 // Prevents user to use ExecutionContext in writable callables
 struct mgp_func_context {
   memgraph::query::DbAccessor *impl;
@@ -685,18 +615,8 @@ struct mgp_properties_iterator {
   mgp_properties_iterator(mgp_graph *graph, decltype(pvs) pvs, memgraph::utils::MemoryResource *memory)
       : memory(memory), graph(graph), pvs(std::move(pvs)), current_it(this->pvs.begin()) {
     if (current_it != this->pvs.end()) {
-      auto value =
-          std::visit(memgraph::utils::Overloaded{
-                         [this, memory](const memgraph::query::DbAccessor *impl) {
-                           return memgraph::utils::pmr::string(impl->PropertyToName(current_it->first), memory);
-                         },
-                         [this, memory](const memgraph::query::SubgraphDbAccessor *impl) {
-                           return memgraph::utils::pmr::string(impl->PropertyToName(current_it->first), memory);
-                         },
-                     },
-                     graph->impl);
-
-      current.emplace(value, mgp_value(current_it->second, memory));
+      current.emplace(memgraph::utils::pmr::string(graph->impl->PropertyToName(current_it->first), memory),
+                      mgp_value(current_it->second, memory));
       property.name = current->first.c_str();
       property.value = &current->second;
     }
@@ -715,6 +635,7 @@ struct mgp_properties_iterator {
 
 struct mgp_edges_iterator {
   using allocator_type = memgraph::utils::Allocator<mgp_edges_iterator>;
+
   // Hopefully mgp_vertex copy constructor remains noexcept, so that we can
   // have everything noexcept here.
   static_assert(std::is_nothrow_constructible_v<mgp_vertex, const mgp_vertex &, memgraph::utils::MemoryResource *>);
@@ -741,14 +662,9 @@ struct mgp_edges_iterator {
 
   memgraph::utils::MemoryResource *memory;
   mgp_vertex source_vertex;
-
-  std::optional<std::remove_reference_t<
-      decltype(*std::get<memgraph::query::VertexAccessor>(source_vertex.impl).InEdges(source_vertex.graph->view))>>
-      in;
+  std::optional<std::remove_reference_t<decltype(*source_vertex.impl.InEdges(source_vertex.graph->view))>> in;
   std::optional<decltype(in->begin())> in_it;
-  std::optional<std::remove_reference_t<
-      decltype(*std::get<memgraph::query::VertexAccessor>(source_vertex.impl).InEdges(source_vertex.graph->view))>>
-      out;
+  std::optional<std::remove_reference_t<decltype(*source_vertex.impl.OutEdges(source_vertex.graph->view))>> out;
   std::optional<decltype(out->begin())> out_it;
   std::optional<mgp_edge> current_e;
 };
@@ -758,20 +674,9 @@ struct mgp_vertices_iterator {
 
   /// @throw anything VerticesIterable may throw
   mgp_vertices_iterator(mgp_graph *graph, memgraph::utils::MemoryResource *memory)
-      : memory(memory),
-        graph(graph),
-        vertices(std::visit(memgraph::utils::Overloaded{[graph](auto *impl) { return impl->Vertices(graph->view); }},
-                            graph->impl)),
-        current_it(vertices.begin()) {
+      : memory(memory), graph(graph), vertices(graph->impl->Vertices(graph->view)), current_it(vertices.begin()) {
     if (current_it != vertices.end()) {
-      std::visit(
-          memgraph::utils::Overloaded{
-              [this, graph, memory](memgraph::query::DbAccessor *) { current_v.emplace(*current_it, graph, memory); },
-              [this, graph, memory](memgraph::query::SubgraphDbAccessor *impl) {
-                current_v.emplace(memgraph::query::SubgraphVertexAccessor(*current_it, impl->getGraph()), graph,
-                                  memory);
-              }},
-          graph->impl);
+      current_v.emplace(*current_it, graph, memory);
     }
   }
 
@@ -779,7 +684,7 @@ struct mgp_vertices_iterator {
 
   memgraph::utils::MemoryResource *memory;
   mgp_graph *graph;
-  memgraph::query::VerticesIterable vertices;
+  decltype(graph->impl->Vertices(graph->view)) vertices;
   decltype(vertices.begin()) current_it;
   std::optional<mgp_vertex> current_v;
 };

src/query/procedure/module.hpp

@@ -235,7 +235,6 @@ void ConstructArguments(const std::vector<TypedValue> &args, const TCall &callab
       throw QueryRuntimeException("'{}' argument named '{}' at position {} must be of type {}.", fully_qualified_name,
                                   name, i, type->GetPresentableName());
     }
-    // why do we move graph here?
     args_list.elems.emplace_back(std::move(arg), &graph);
   }
   // Fill missing optional arguments with their default values.

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

@@ -214,9 +214,6 @@ TypedValue::TypedValue(const TypedValue &other, utils::MemoryResource *memory) :
     case Type::Duration:
       new (&duration_v) utils::Duration(other.duration_v);
       return;
-    case Type::Graph:
-      new (&graph_v) Graph(other.graph_v, memory_);
-      return;
   }
   LOG_FATAL("Unsupported TypedValue::Type");
 }
@@ -266,8 +263,6 @@ TypedValue::TypedValue(TypedValue &&other, utils::MemoryResource *memory) : memo
     case Type::Duration:
       new (&duration_v) utils::Duration(other.duration_v);
       break;
-    case Type::Graph:
-      new (&graph_v) Graph(std::move(other.graph_v), memory_);
   }
   other.DestroyValue();
 }
@@ -302,8 +297,6 @@ TypedValue::operator storage::PropertyValue() const {
           storage::TemporalData{storage::TemporalType::LocalDateTime, local_date_time_v.MicrosecondsSinceEpoch()});
     case Type::Duration:
       return storage::PropertyValue(storage::TemporalData{storage::TemporalType::Duration, duration_v.microseconds});
-    case Type::Graph:
-      throw TypedValueException("Unsupported copy from StorageValue to TypedValue");
     default:
       break;
   }
@@ -338,7 +331,6 @@ DEFINE_VALUE_AND_TYPE_GETTERS(utils::Date, Date, date_v)
 DEFINE_VALUE_AND_TYPE_GETTERS(utils::LocalTime, LocalTime, local_time_v)
 DEFINE_VALUE_AND_TYPE_GETTERS(utils::LocalDateTime, LocalDateTime, local_date_time_v)
 DEFINE_VALUE_AND_TYPE_GETTERS(utils::Duration, Duration, duration_v)
-DEFINE_VALUE_AND_TYPE_GETTERS(Graph, Graph, graph_v)
 
 #undef DEFINE_VALUE_AND_TYPE_GETTERS
 
@@ -395,8 +387,6 @@ std::ostream &operator<<(std::ostream &os, const TypedValue::Type &type) {
       return os << "local_date_time";
     case TypedValue::Type::Duration:
       return os << "duration";
-    case TypedValue::Type::Graph:
-      return os << "graph";
   }
   LOG_FATAL("Unsupported TypedValue::Type");
 }
@@ -532,9 +522,6 @@ TypedValue &TypedValue::operator=(const TypedValue &other) {
       case TypedValue::Type::Path:
         new (&path_v) Path(other.path_v, memory_);
         return *this;
-      case TypedValue::Type::Graph:
-        new (&graph_v) Graph(other.graph_v, memory_);
-        return *this;
       case Type::Date:
         new (&date_v) utils::Date(other.date_v);
         return *this;
@@ -606,9 +593,6 @@ TypedValue &TypedValue::operator=(TypedValue &&other) noexcept(false) {
       case Type::Duration:
         new (&duration_v) utils::Duration(other.duration_v);
         break;
-      case Type::Graph:
-        new (&graph_v) Graph(std::move(other.graph_v), memory_);
-        break;
     }
     other.DestroyValue();
   }
@@ -649,9 +633,6 @@ void TypedValue::DestroyValue() {
     case Type::LocalDateTime:
     case Type::Duration:
       break;
-    case Type::Graph:
-      graph_v.~Graph();
-      break;
   }
 
   type_ = TypedValue::Type::Null;
@@ -811,8 +792,6 @@ TypedValue operator==(const TypedValue &a, const TypedValue &b) {
       return TypedValue(a.ValueLocalDateTime() == b.ValueLocalDateTime(), a.GetMemoryResource());
     case TypedValue::Type::Duration:
       return TypedValue(a.ValueDuration() == b.ValueDuration(), a.GetMemoryResource());
-    case TypedValue::Type::Graph:
-      throw TypedValueException("Unsupported comparison operator");
     default:
       LOG_FATAL("Unhandled comparison for types");
   }
@@ -1121,8 +1100,6 @@ size_t TypedValue::Hash::operator()(const TypedValue &value) const {
     case TypedValue::Type::Duration:
       return utils::DurationHash{}(value.ValueDuration());
       break;
-    case TypedValue::Type::Graph:
-      throw TypedValueException("Unsupported hash function for Graph");
   }
   LOG_FATAL("Unhandled TypedValue.type() in hash function");
 }

src/query/typed_value.hpp

@@ -21,7 +21,6 @@
 #include <vector>
 
 #include "query/db_accessor.hpp"
-#include "query/graph.hpp"
 #include "query/path.hpp"
 #include "utils/exceptions.hpp"
 #include "utils/memory.hpp"
@@ -83,8 +82,7 @@ class TypedValue {
     Date,
     LocalTime,
     LocalDateTime,
-    Duration,
-    Graph
+    Duration
   };
 
   // TypedValue at this exact moment of compilation is an incomplete type, and
@@ -403,22 +401,6 @@ class TypedValue {
     new (&path_v) Path(std::move(path), memory_);
   }
 
-  /**
-   * Construct with the value of graph.
-   * utils::MemoryResource is obtained from graph. After the move, graph will be
-   * left empty.
-   */
-  explicit TypedValue(Graph &&graph) noexcept : TypedValue(std::move(graph), graph.GetMemoryResource()) {}
-
-  /**
-   * Construct with the value of graph and use the given MemoryResource.
-   * If `*graph.GetMemoryResource() != *memory`, this call will perform an
-   * element-wise move and graph is not guaranteed to be empty.
-   */
-  TypedValue(Graph &&graph, utils::MemoryResource *memory) : memory_(memory), type_(Type::Graph) {
-    new (&graph_v) Graph(std::move(graph), memory_);
-  }
-
   /**
    * Construct with the value of other.
    * Default utils::NewDeleteResource() is used for allocations. After the move,
@@ -504,7 +486,6 @@ class TypedValue {
   DECLARE_VALUE_AND_TYPE_GETTERS(utils::LocalTime, LocalTime)
   DECLARE_VALUE_AND_TYPE_GETTERS(utils::LocalDateTime, LocalDateTime)
   DECLARE_VALUE_AND_TYPE_GETTERS(utils::Duration, Duration)
-  DECLARE_VALUE_AND_TYPE_GETTERS(Graph, Graph)
 
 #undef DECLARE_VALUE_AND_TYPE_GETTERS
 
@@ -547,7 +528,6 @@ class TypedValue {
     utils::LocalTime local_time_v;
     utils::LocalDateTime local_date_time_v;
     utils::Duration duration_v;
-    Graph graph_v;
   };
 
   /**

src/query/v2/CMakeLists.txt

@@ -0,0 +1,104 @@
+define_add_lcp(add_lcp_query lcp_query_v2_cpp_files generated_lcp_query_v2_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_v2 DEPENDS ${generated_lcp_query_v2_files})
+
+set(mg_query_v2_sources
+    ${lcp_query_v2_cpp_files}
+    common.cpp
+    cypher_query_interpreter.cpp
+    dump.cpp
+    frontend/ast/cypher_main_visitor.cpp
+    frontend/ast/pretty_print.cpp
+    frontend/parsing.cpp
+    frontend/semantic/required_privileges.cpp
+    frontend/semantic/symbol_generator.cpp
+    frontend/stripped.cpp
+    interpret/awesome_memgraph_functions.cpp
+    interpret/eval.cpp
+    interpreter.cpp
+    metadata.cpp
+    plan/operator.cpp
+    plan/preprocess.cpp
+    plan/pretty_print.cpp
+    plan/profile.cpp
+    plan/read_write_type_checker.cpp
+    plan/rewrite/index_lookup.cpp
+    plan/rule_based_planner.cpp
+    plan/variable_start_planner.cpp
+    procedure/mg_procedure_impl.cpp
+    procedure/mg_procedure_helpers.cpp
+    procedure/module.cpp
+    procedure/py_module.cpp
+    serialization/property_value.cpp
+    stream/streams.cpp
+    stream/sources.cpp
+    stream/common.cpp
+    trigger.cpp
+    trigger_context.cpp
+    typed_value.cpp)
+
+find_package(Boost REQUIRED)
+
+add_library(mg-query-v2 STATIC ${mg_query_v2_sources})
+add_dependencies(mg-query-v2 generate_lcp_query_v2)
+target_include_directories(mg-query-v2 PUBLIC ${CMAKE_SOURCE_DIR}/include)
+target_link_libraries(mg-query-v2 dl cppitertools Boost::headers)
+target_link_libraries(mg-query-v2 mg-integrations-pulsar mg-integrations-kafka mg-storage-v3 mg-license mg-utils mg-kvstore mg-memory)
+
+if(NOT "${MG_PYTHON_PATH}" STREQUAL "")
+    set(Python3_ROOT_DIR "${MG_PYTHON_PATH}")
+endif()
+
+if("${MG_PYTHON_VERSION}" STREQUAL "")
+    find_package(Python3 3.5 REQUIRED COMPONENTS Development)
+else()
+    find_package(Python3 "${MG_PYTHON_VERSION}" EXACT REQUIRED COMPONENTS Development)
+endif()
+
+target_link_libraries(mg-query-v2 Python3::Python)
+
+# Generate Antlr openCypher parser
+set(opencypher_frontend ${CMAKE_CURRENT_SOURCE_DIR}/frontend/opencypher)
+set(opencypher_generated ${opencypher_frontend}/generated)
+set(opencypher_lexer_grammar ${opencypher_frontend}/grammar/MemgraphCypherLexer.g4)
+set(opencypher_parser_grammar ${opencypher_frontend}/grammar/MemgraphCypher.g4)
+
+set(antlr_opencypher_generated_src
+    ${opencypher_generated}/MemgraphCypherLexer.cpp
+    ${opencypher_generated}/MemgraphCypher.cpp
+    ${opencypher_generated}/MemgraphCypherBaseVisitor.cpp
+    ${opencypher_generated}/MemgraphCypherVisitor.cpp
+)
+set(antlr_opencypher_generated_include
+    ${opencypher_generated}/MemgraphCypherLexer.h
+    ${opencypher_generated}/MemgraphCypher.h
+    ${opencypher_generated}/MemgraphCypherBaseVisitor.h
+    ${opencypher_generated}/MemgraphCypherVisitor.h
+)
+
+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.10.1-complete.jar
+    -Dlanguage=Cpp -visitor -package antlropencypher
+    -o ${opencypher_generated}
+    ${opencypher_lexer_grammar} ${opencypher_parser_grammar}
+    WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
+    DEPENDS
+    ${opencypher_lexer_grammar} ${opencypher_parser_grammar}
+    ${opencypher_frontend}/grammar/CypherLexer.g4
+    ${opencypher_frontend}/grammar/Cypher.g4)
+
+add_custom_target(generate_opencypher_parser_v2
+    DEPENDS ${antlr_opencypher_generated_src} ${antlr_opencypher_generated_include})
+
+add_library(antlr_opencypher_parser_lib_v2 STATIC ${antlr_opencypher_generated_src})
+add_dependencies(antlr_opencypher_parser_lib_v2 generate_opencypher_parser_v2)
+target_link_libraries(antlr_opencypher_parser_lib_v2 antlr4)
+
+target_link_libraries(mg-query-v2 antlr_opencypher_parser_lib_v2)

src/query/v2/auth_checker.hpp

@@ -0,0 +1,29 @@
+// 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.
+
+#pragma once
+
+#include "query/v2/frontend/ast/ast.hpp"
+
+namespace memgraph::query::v2 {
+class AuthChecker {
+ public:
+  virtual bool IsUserAuthorized(const std::optional<std::string> &username,
+                                const std::vector<query::v2::AuthQuery::Privilege> &privileges) const = 0;
+};
+
+class AllowEverythingAuthChecker final : public query::v2::AuthChecker {
+  bool IsUserAuthorized(const std::optional<std::string> & /*username*/,
+                        const std::vector<query::v2::AuthQuery::Privilege> & /*privileges*/) const override {
+    return true;
+  }
+};
+}  // namespace memgraph::query::v2

src/query/v2/common.cpp

@@ -0,0 +1,76 @@
+// 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 "query/v2/common.hpp"
+
+namespace memgraph::query::v2 {
+
+namespace impl {
+
+bool TypedValueCompare(const TypedValue &a, const TypedValue &b) {
+  // in ordering null comes after everything else
+  // at the same time Null is not less that null
+  // first deal with Null < Whatever case
+  if (a.IsNull()) return false;
+  // now deal with NotNull < Null case
+  if (b.IsNull()) return true;
+
+  // comparisons are from this point legal only between values of
+  // the  same type, or int+float combinations
+  if ((a.type() != b.type() && !(a.IsNumeric() && b.IsNumeric())))
+    throw QueryRuntimeException("Can't compare value of type {} to value of type {}.", a.type(), b.type());
+
+  switch (a.type()) {
+    case TypedValue::Type::Bool:
+      return !a.ValueBool() && b.ValueBool();
+    case TypedValue::Type::Int:
+      if (b.type() == TypedValue::Type::Double)
+        return a.ValueInt() < b.ValueDouble();
+      else
+        return a.ValueInt() < b.ValueInt();
+    case TypedValue::Type::Double:
+      if (b.type() == TypedValue::Type::Int)
+        return a.ValueDouble() < b.ValueInt();
+      else
+        return a.ValueDouble() < b.ValueDouble();
+    case TypedValue::Type::String:
+      // NOLINTNEXTLINE(modernize-use-nullptr)
+      return a.ValueString() < b.ValueString();
+    case TypedValue::Type::Date:
+      // NOLINTNEXTLINE(modernize-use-nullptr)
+      return a.ValueDate() < b.ValueDate();
+    case TypedValue::Type::LocalTime:
+      // NOLINTNEXTLINE(modernize-use-nullptr)
+      return a.ValueLocalTime() < b.ValueLocalTime();
+    case TypedValue::Type::LocalDateTime:
+      // NOLINTNEXTLINE(modernize-use-nullptr)
+      return a.ValueLocalDateTime() < b.ValueLocalDateTime();
+    case TypedValue::Type::Duration:
+      // NOLINTNEXTLINE(modernize-use-nullptr)
+      return a.ValueDuration() < b.ValueDuration();
+    case TypedValue::Type::List:
+    case TypedValue::Type::Map:
+    case TypedValue::Type::Vertex:
+    case TypedValue::Type::Edge:
+    case TypedValue::Type::Path:
+      throw QueryRuntimeException("Comparison is not defined for values of type {}.", a.type());
+    case TypedValue::Type::Null:
+      LOG_FATAL("Invalid type");
+  }
+}
+
+}  // namespace impl
+
+int64_t QueryTimestamp() {
+  return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch())
+      .count();
+}
+}  // namespace memgraph::query::v2

src/query/v2/common.hpp

@@ -0,0 +1,168 @@
+// 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.
+
+/// @file
+#pragma once
+
+#include <concepts>
+#include <cstdint>
+#include <string>
+#include <string_view>
+#include <type_traits>
+
+#include "query/v2/db_accessor.hpp"
+#include "query/v2/exceptions.hpp"
+#include "query/v2/frontend/ast/ast.hpp"
+#include "query/v2/frontend/semantic/symbol.hpp"
+#include "query/v2/typed_value.hpp"
+#include "storage/v3/id_types.hpp"
+#include "storage/v3/property_value.hpp"
+#include "storage/v3/result.hpp"
+#include "storage/v3/schema_validator.hpp"
+#include "storage/v3/view.hpp"
+#include "utils/exceptions.hpp"
+#include "utils/logging.hpp"
+#include "utils/variant_helpers.hpp"
+
+namespace memgraph::query::v2 {
+
+namespace impl {
+bool TypedValueCompare(const TypedValue &a, const TypedValue &b);
+}  // namespace impl
+
+/// Custom Comparator type for comparing vectors of TypedValues.
+///
+/// Does lexicographical ordering of elements based on the above
+/// defined TypedValueCompare, and also accepts a vector of Orderings
+/// the define how respective elements compare.
+class TypedValueVectorCompare final {
+ public:
+  TypedValueVectorCompare() {}
+  explicit TypedValueVectorCompare(const std::vector<Ordering> &ordering) : ordering_(ordering) {}
+
+  template <class TAllocator>
+  bool operator()(const std::vector<TypedValue, TAllocator> &c1, const std::vector<TypedValue, TAllocator> &c2) const {
+    // ordering is invalid if there are more elements in the collections
+    // then there are in the ordering_ vector
+    MG_ASSERT(c1.size() <= ordering_.size() && c2.size() <= ordering_.size(),
+              "Collections contain more elements then there are orderings");
+
+    auto c1_it = c1.begin();
+    auto c2_it = c2.begin();
+    auto ordering_it = ordering_.begin();
+    for (; c1_it != c1.end() && c2_it != c2.end(); c1_it++, c2_it++, ordering_it++) {
+      if (impl::TypedValueCompare(*c1_it, *c2_it)) return *ordering_it == Ordering::ASC;
+      if (impl::TypedValueCompare(*c2_it, *c1_it)) return *ordering_it == Ordering::DESC;
+    }
+
+    // at least one collection is exhausted
+    // c1 is less then c2 iff c1 reached the end but c2 didn't
+    return (c1_it == c1.end()) && (c2_it != c2.end());
+  }
+
+  // TODO: Remove this, member is public
+  const auto &ordering() const { return ordering_; }
+
+  std::vector<Ordering> ordering_;
+};
+
+/// Raise QueryRuntimeException if the value for symbol isn't of expected type.
+inline void ExpectType(const Symbol &symbol, const TypedValue &value, TypedValue::Type expected) {
+  if (value.type() != expected)
+    throw QueryRuntimeException("Expected a {} for '{}', but got {}.", expected, symbol.name(), value.type());
+}
+
+template <typename T>
+concept AccessorWithSetProperty = requires(T accessor, const storage::v3::PropertyId key,
+                                           const storage::v3::PropertyValue new_value) {
+  { accessor.SetProperty(key, new_value) } -> std::same_as<storage::v3::Result<storage::v3::PropertyValue>>;
+};
+
+inline void HandleSchemaViolation(const storage::v3::SchemaViolation &schema_violation, const DbAccessor &dba) {
+  switch (schema_violation.status) {
+    case storage::v3::SchemaViolation::ValidationStatus::VERTEX_HAS_NO_PRIMARY_PROPERTY: {
+      throw SchemaViolationException(
+          fmt::format("Primary key {} not defined on label :{}",
+                      storage::v3::SchemaTypeToString(schema_violation.violated_schema_property->type),
+                      dba.LabelToName(schema_violation.label)));
+    }
+    case storage::v3::SchemaViolation::ValidationStatus::NO_SCHEMA_DEFINED_FOR_LABEL: {
+      throw SchemaViolationException(
+          fmt::format("Label :{} is not a primary label", dba.LabelToName(schema_violation.label)));
+    }
+    case storage::v3::SchemaViolation::ValidationStatus::VERTEX_PROPERTY_WRONG_TYPE: {
+      throw SchemaViolationException(
+          fmt::format("Wrong type of property {} in schema :{}, should be of type {}",
+                      *schema_violation.violated_property_value, dba.LabelToName(schema_violation.label),
+                      storage::v3::SchemaTypeToString(schema_violation.violated_schema_property->type)));
+    }
+    case storage::v3::SchemaViolation::ValidationStatus::VERTEX_UPDATE_PRIMARY_KEY: {
+      throw SchemaViolationException(fmt::format("Updating of primary key {} on schema :{} not supported",
+                                                 *schema_violation.violated_property_value,
+                                                 dba.LabelToName(schema_violation.label)));
+    }
+    case storage::v3::SchemaViolation::ValidationStatus::VERTEX_MODIFY_PRIMARY_LABEL: {
+      throw SchemaViolationException(fmt::format("Cannot add or remove label :{} since it is a primary label",
+                                                 dba.LabelToName(schema_violation.label)));
+    }
+    case storage::v3::SchemaViolation::ValidationStatus::VERTEX_SECONDARY_LABEL_IS_PRIMARY: {
+      throw SchemaViolationException(
+          fmt::format("Cannot create vertex with secondary label :{}", dba.LabelToName(schema_violation.label)));
+    }
+  }
+}
+
+inline void HandleErrorOnPropertyUpdate(const storage::v3::Error error) {
+  switch (error) {
+    case storage::v3::Error::SERIALIZATION_ERROR:
+      throw TransactionSerializationException();
+    case storage::v3::Error::DELETED_OBJECT:
+      throw QueryRuntimeException("Trying to set properties on a deleted object.");
+    case storage::v3::Error::PROPERTIES_DISABLED:
+      throw QueryRuntimeException("Can't set property because properties on edges are disabled.");
+    case storage::v3::Error::VERTEX_HAS_EDGES:
+    case storage::v3::Error::NONEXISTENT_OBJECT:
+      throw QueryRuntimeException("Unexpected error when setting a property.");
+  }
+}
+
+/// Set a property `value` mapped with given `key` on a `record`.
+///
+/// @throw QueryRuntimeException if value cannot be set as a property value
+template <AccessorWithSetProperty T>
+storage::v3::PropertyValue PropsSetChecked(T *record, const DbAccessor &dba, const storage::v3::PropertyId &key,
+                                           const TypedValue &value) {
+  try {
+    if constexpr (std::is_same_v<T, VertexAccessor>) {
+      const auto maybe_old_value = record->SetPropertyAndValidate(key, storage::v3::PropertyValue(value));
+      if (maybe_old_value.HasError()) {
+        std::visit(utils::Overloaded{[](const storage::v3::Error error) { HandleErrorOnPropertyUpdate(error); },
+                                     [&dba](const storage::v3::SchemaViolation &schema_violation) {
+                                       HandleSchemaViolation(schema_violation, dba);
+                                     }},
+                   maybe_old_value.GetError());
+      }
+      return std::move(*maybe_old_value);
+    } else {
+      // No validation on edge properties
+      const auto maybe_old_value = record->SetProperty(key, storage::v3::PropertyValue(value));
+      if (maybe_old_value.HasError()) {
+        HandleErrorOnPropertyUpdate(maybe_old_value.GetError());
+      }
+      return std::move(*maybe_old_value);
+    }
+  } catch (const TypedValueException &) {
+    throw QueryRuntimeException("'{}' cannot be used as a property value.", value.type());
+  }
+}
+
+int64_t QueryTimestamp();
+}  // namespace memgraph::query::v2

src/query/v2/config.hpp

@@ -0,0 +1,32 @@
+// 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.
+
+#pragma once
+#include <chrono>
+#include <string>
+
+namespace memgraph::query::v2 {
+struct InterpreterConfig {
+  struct Query {
+    bool allow_load_csv{true};
+  } query;
+
+  // The default execution timeout is 10 minutes.
+  double execution_timeout_sec{600.0};
+  // The same as \ref memgraph::storage::v3::replication::ReplicationClientConfig
+  std::chrono::seconds replication_replica_check_frequency{1};
+
+  std::string default_kafka_bootstrap_servers;
+  std::string default_pulsar_service_url;
+  uint32_t stream_transaction_conflict_retries;
+  std::chrono::milliseconds stream_transaction_retry_interval;
+};
+}  // namespace memgraph::query::v2

src/query/v2/constants.hpp

@@ -0,0 +1,19 @@
+// 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.
+
+#pragma once
+#include <cstdint>
+#include <string>
+
+namespace memgraph::query::v2 {
+inline constexpr uint16_t kDefaultReplicationPort = 10000;
+inline constexpr auto *kDefaultReplicationServerIp = "0.0.0.0";
+}  // namespace memgraph::query::v2

src/query/v2/context.hpp

@@ -0,0 +1,89 @@
+// 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.
+
+#pragma once
+
+#include <type_traits>
+
+#include "query/v2/common.hpp"
+#include "query/v2/frontend/semantic/symbol_table.hpp"
+#include "query/v2/metadata.hpp"
+#include "query/v2/parameters.hpp"
+#include "query/v2/plan/profile.hpp"
+#include "query/v2/trigger.hpp"
+#include "utils/async_timer.hpp"
+
+namespace memgraph::query::v2 {
+
+struct EvaluationContext {
+  /// Memory for allocations during evaluation of a *single* Pull call.
+  ///
+  /// Although the assigned memory may live longer than the duration of a Pull
+  /// (e.g. memory is the same as the whole execution memory), you have to treat
+  /// it as if the lifetime is only valid during the Pull.
+  utils::MemoryResource *memory{utils::NewDeleteResource()};
+  int64_t timestamp{-1};
+  Parameters parameters;
+  /// All properties indexable via PropertyIx
+  std::vector<storage::v3::PropertyId> properties;
+  /// All labels indexable via LabelIx
+  std::vector<storage::v3::LabelId> labels;
+  /// All counters generated by `counter` function, mutable because the function
+  /// modifies the values
+  mutable std::unordered_map<std::string, int64_t> counters;
+};
+
+inline std::vector<storage::v3::PropertyId> NamesToProperties(const std::vector<std::string> &property_names,
+                                                              DbAccessor *dba) {
+  std::vector<storage::v3::PropertyId> properties;
+  properties.reserve(property_names.size());
+  for (const auto &name : property_names) {
+    properties.push_back(dba->NameToProperty(name));
+  }
+  return properties;
+}
+
+inline std::vector<storage::v3::LabelId> NamesToLabels(const std::vector<std::string> &label_names, DbAccessor *dba) {
+  std::vector<storage::v3::LabelId> labels;
+  labels.reserve(label_names.size());
+  for (const auto &name : label_names) {
+    labels.push_back(dba->NameToLabel(name));
+  }
+  return labels;
+}
+
+struct ExecutionContext {
+  DbAccessor *db_accessor{nullptr};
+  SymbolTable symbol_table;
+  EvaluationContext evaluation_context;
+  std::atomic<bool> *is_shutting_down{nullptr};
+  bool is_profile_query{false};
+  std::chrono::duration<double> profile_execution_time;
+  plan::ProfilingStats stats;
+  plan::ProfilingStats *stats_root{nullptr};
+  ExecutionStats execution_stats;
+  TriggerContextCollector *trigger_context_collector{nullptr};
+  utils::AsyncTimer timer;
+};
+
+static_assert(std::is_move_assignable_v<ExecutionContext>, "ExecutionContext must be move assignable!");
+static_assert(std::is_move_constructible_v<ExecutionContext>, "ExecutionContext must be move constructible!");
+
+inline bool MustAbort(const ExecutionContext &context) noexcept {
+  return (context.is_shutting_down != nullptr && context.is_shutting_down->load(std::memory_order_acquire)) ||
+         context.timer.IsExpired();
+}
+
+inline plan::ProfilingStatsWithTotalTime GetStatsWithTotalTime(const ExecutionContext &context) {
+  return plan::ProfilingStatsWithTotalTime{context.stats, context.profile_execution_time};
+}
+
+}  // namespace memgraph::query::v2

src/query/v2/cypher_query_interpreter.cpp

@@ -0,0 +1,153 @@
+// 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 "query/v2/cypher_query_interpreter.hpp"
+
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DEFINE_HIDDEN_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()));
+
+namespace memgraph::query::v2 {
+CachedPlan::CachedPlan(std::unique_ptr<LogicalPlan> plan) : plan_(std::move(plan)) {}
+
+ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::string, storage::v3::PropertyValue> &params,
+                       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
+  // caching.
+  frontend::StrippedQuery stripped_query{query_string};
+
+  // Copy over the parameters that were introduced during stripping.
+  Parameters parameters{stripped_query.literals()};
+
+  // Check that all user-specified parameters are provided.
+  for (const auto &param_pair : stripped_query.parameters()) {
+    auto it = params.find(param_pair.second);
+
+    if (it == params.end()) {
+      throw query::v2::UnprovidedParameterError("Parameter ${} not provided.", param_pair.second);
+    }
+
+    parameters.Add(param_pair.first, it->second);
+  }
+
+  // Cache the query's AST if it isn't already.
+  auto hash = stripped_query.hash();
+  auto accessor = cache->access();
+  auto it = accessor.find(hash);
+  std::unique_ptr<frontend::opencypher::Parser> parser;
+
+  // Return a copy of both the AST storage and the query.
+  CachedQuery result;
+  bool is_cacheable = true;
+
+  auto get_information_from_cache = [&](const auto &cached_query) {
+    result.ast_storage.properties_ = cached_query.ast_storage.properties_;
+    result.ast_storage.labels_ = cached_query.ast_storage.labels_;
+    result.ast_storage.edge_types_ = cached_query.ast_storage.edge_types_;
+
+    result.query = cached_query.query->Clone(&result.ast_storage);
+    result.required_privileges = cached_query.required_privileges;
+  };
+
+  if (it == accessor.end()) {
+    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.");
+    }
+
+    // Convert the ANTLR4 parse tree into an AST.
+    AstStorage ast_storage;
+    frontend::ParsingContext context{true};
+    frontend::CypherMainVisitor visitor(context, &ast_storage);
+
+    visitor.visit(parser->tree());
+
+    if (visitor.GetQueryInfo().has_load_csv && !query_config.allow_load_csv) {
+      throw utils::BasicException("Load CSV not allowed on this instance because it was disabled by a config.");
+    }
+
+    if (visitor.GetQueryInfo().is_cacheable) {
+      CachedQuery cached_query{std::move(ast_storage), visitor.query(),
+                               query::v2::GetRequiredPrivileges(visitor.query())};
+      it = accessor.insert({hash, std::move(cached_query)}).first;
+
+      get_information_from_cache(it->second);
+    } else {
+      result.ast_storage.properties_ = ast_storage.properties_;
+      result.ast_storage.labels_ = ast_storage.labels_;
+      result.ast_storage.edge_types_ = ast_storage.edge_types_;
+
+      result.query = visitor.query()->Clone(&result.ast_storage);
+      result.required_privileges = query::v2::GetRequiredPrivileges(visitor.query());
+
+      is_cacheable = false;
+    }
+  } else {
+    get_information_from_cache(it->second);
+  }
+
+  return ParsedQuery{query_string,
+                     params,
+                     std::move(parameters),
+                     std::move(stripped_query),
+                     std::move(result.ast_storage),
+                     result.query,
+                     std::move(result.required_privileges),
+                     is_cacheable};
+}
+
+std::unique_ptr<LogicalPlan> MakeLogicalPlan(AstStorage ast_storage, CypherQuery *query, const Parameters &parameters,
+                                             DbAccessor *db_accessor,
+                                             const std::vector<Identifier *> &predefined_identifiers) {
+  auto vertex_counts = plan::MakeVertexCountCache(db_accessor);
+  auto symbol_table = MakeSymbolTable(query, predefined_identifiers);
+  auto planning_context = plan::MakePlanningContext(&ast_storage, &symbol_table, query, &vertex_counts);
+  auto [root, cost] = plan::MakeLogicalPlan(&planning_context, parameters, FLAGS_query_cost_planner);
+  return std::make_unique<SingleNodeLogicalPlan>(std::move(root), cost, std::move(ast_storage),
+                                                 std::move(symbol_table));
+}
+
+std::shared_ptr<CachedPlan> CypherQueryToPlan(uint64_t hash, AstStorage ast_storage, CypherQuery *query,
+                                              const Parameters &parameters, utils::SkipList<PlanCacheEntry> *plan_cache,
+                                              DbAccessor *db_accessor,
+                                              const std::vector<Identifier *> &predefined_identifiers) {
+  std::optional<utils::SkipList<PlanCacheEntry>::Accessor> plan_cache_access;
+  if (plan_cache) {
+    plan_cache_access.emplace(plan_cache->access());
+    auto it = plan_cache_access->find(hash);
+    if (it != plan_cache_access->end()) {
+      if (it->second->IsExpired()) {
+        plan_cache_access->remove(hash);
+      } else {
+        return it->second;
+      }
+    }
+  }
+
+  auto plan = std::make_shared<CachedPlan>(
+      MakeLogicalPlan(std::move(ast_storage), query, parameters, db_accessor, predefined_identifiers));
+  if (plan_cache_access) {
+    plan_cache_access->insert({hash, plan});
+  }
+  return plan;
+}
+}  // namespace memgraph::query::v2

src/query/v2/cypher_query_interpreter.hpp

@@ -0,0 +1,151 @@
+// 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.
+
+#pragma once
+
+#include "query/v2/config.hpp"
+#include "query/v2/frontend/ast/cypher_main_visitor.hpp"
+#include "query/v2/frontend/opencypher/parser.hpp"
+#include "query/v2/frontend/semantic/required_privileges.hpp"
+#include "query/v2/frontend/semantic/symbol_generator.hpp"
+#include "query/v2/frontend/stripped.hpp"
+#include "query/v2/plan/planner.hpp"
+#include "utils/flag_validation.hpp"
+#include "utils/timer.hpp"
+
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_bool(query_cost_planner);
+// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+DECLARE_int32(query_plan_cache_ttl);
+
+namespace memgraph::query::v2 {
+
+// TODO: Maybe this should move to query/plan/planner.
+/// Interface for accessing the root operator of a logical plan.
+class LogicalPlan {
+ public:
+  explicit LogicalPlan() = default;
+
+  virtual ~LogicalPlan() = default;
+
+  LogicalPlan(const LogicalPlan &) = default;
+  LogicalPlan &operator=(const LogicalPlan &) = default;
+  LogicalPlan(LogicalPlan &&) = default;
+  LogicalPlan &operator=(LogicalPlan &&) = default;
+
+  virtual const plan::LogicalOperator &GetRoot() const = 0;
+  virtual double GetCost() const = 0;
+  virtual const SymbolTable &GetSymbolTable() const = 0;
+  virtual const AstStorage &GetAstStorage() const = 0;
+};
+
+class CachedPlan {
+ public:
+  explicit CachedPlan(std::unique_ptr<LogicalPlan> plan);
+
+  const auto &plan() const { return plan_->GetRoot(); }
+  double cost() const { return plan_->GetCost(); }
+  const auto &symbol_table() const { return plan_->GetSymbolTable(); }
+  const auto &ast_storage() const { return plan_->GetAstStorage(); }
+
+  bool IsExpired() const {
+    // NOLINTNEXTLINE (modernize-use-nullptr)
+    return cache_timer_.Elapsed() > std::chrono::seconds(FLAGS_query_plan_cache_ttl);
+  };
+
+ private:
+  std::unique_ptr<LogicalPlan> plan_;
+  utils::Timer cache_timer_;
+};
+
+struct CachedQuery {
+  AstStorage ast_storage;
+  Query *query;
+  std::vector<AuthQuery::Privilege> required_privileges;
+};
+
+struct QueryCacheEntry {
+  bool operator==(const QueryCacheEntry &other) const { return first == other.first; }
+  bool operator<(const QueryCacheEntry &other) const { return first < other.first; }
+  bool operator==(const uint64_t &other) const { return first == other; }
+  bool operator<(const uint64_t &other) const { return first < other; }
+
+  uint64_t first;
+  // TODO: Maybe store the query string here and use it as a key with the hash
+  // so that we eliminate the risk of hash collisions.
+  CachedQuery second;
+};
+
+struct PlanCacheEntry {
+  bool operator==(const PlanCacheEntry &other) const { return first == other.first; }
+  bool operator<(const PlanCacheEntry &other) const { return first < other.first; }
+  bool operator==(const uint64_t &other) const { return first == other; }
+  bool operator<(const uint64_t &other) const { return first < other; }
+
+  uint64_t first;
+  // TODO: Maybe store the query string here and use it as a key with the hash
+  // so that we eliminate the risk of hash collisions.
+  std::shared_ptr<CachedPlan> second;
+};
+
+/**
+ * A container for data related to the parsing of a query.
+ */
+struct ParsedQuery {
+  std::string query_string;
+  std::map<std::string, storage::v3::PropertyValue> user_parameters;
+  Parameters parameters;
+  frontend::StrippedQuery stripped_query;
+  AstStorage ast_storage;
+  Query *query;
+  std::vector<AuthQuery::Privilege> required_privileges;
+  bool is_cacheable{true};
+};
+
+ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::string, storage::v3::PropertyValue> &params,
+                       utils::SkipList<QueryCacheEntry> *cache, const InterpreterConfig::Query &query_config);
+
+class SingleNodeLogicalPlan final : public LogicalPlan {
+ public:
+  SingleNodeLogicalPlan(std::unique_ptr<plan::LogicalOperator> root, double cost, AstStorage storage,
+                        const SymbolTable &symbol_table)
+      : root_(std::move(root)), cost_(cost), storage_(std::move(storage)), symbol_table_(symbol_table) {}
+
+  const plan::LogicalOperator &GetRoot() const override { return *root_; }
+  double GetCost() const override { return cost_; }
+  const SymbolTable &GetSymbolTable() const override { return symbol_table_; }
+  const AstStorage &GetAstStorage() const override { return storage_; }
+
+ private:
+  std::unique_ptr<plan::LogicalOperator> root_;
+  double cost_;
+  AstStorage storage_;
+  SymbolTable symbol_table_;
+};
+
+std::unique_ptr<LogicalPlan> MakeLogicalPlan(AstStorage ast_storage, CypherQuery *query, const Parameters &parameters,
+                                             DbAccessor *db_accessor,
+                                             const std::vector<Identifier *> &predefined_identifiers);
+
+/**
+ * Return the parsed *Cypher* query's AST cached logical plan, or create and
+ * cache a fresh one if it doesn't yet exist.
+ * @param predefined_identifiers optional identifiers you want to inject into a query.
+ * If an identifier is not defined in a scope, we check the predefined identifiers.
+ * If an identifier is contained there, we inject it at that place and remove it,
+ * because a predefined identifier can be used only in one scope.
+ */
+std::shared_ptr<CachedPlan> CypherQueryToPlan(uint64_t hash, AstStorage ast_storage, CypherQuery *query,
+                                              const Parameters &parameters, utils::SkipList<PlanCacheEntry> *plan_cache,
+                                              DbAccessor *db_accessor,
+                                              const std::vector<Identifier *> &predefined_identifiers = {});
+
+}  // namespace memgraph::query::v2

src/query/v2/db_accessor.hpp

@@ -0,0 +1,415 @@
+// 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.
+
+#pragma once
+
+#include <optional>
+#include <vector>
+
+#include <cppitertools/filter.hpp>
+#include <cppitertools/imap.hpp>
+
+#include "query/v2/exceptions.hpp"
+#include "storage/v3/id_types.hpp"
+#include "storage/v3/property_value.hpp"
+#include "storage/v3/result.hpp"
+
+///////////////////////////////////////////////////////////
+// Our communication layer and query engine don't mix
+// very well on Centos because OpenSSL version available
+// on Centos 7 include  libkrb5 which has brilliant macros
+// called TRUE and FALSE. For more detailed explanation go
+// to memgraph.cpp.
+//
+// Because of the replication storage now uses some form of
+// communication so we have some unwanted macros.
+// This cannot be avoided by simple include orderings so we
+// simply undefine those macros as we're sure that libkrb5
+// won't and can't be used anywhere in the query engine.
+#include "storage/v3/storage.hpp"
+#include "utils/logging.hpp"
+#include "utils/result.hpp"
+
+#undef FALSE
+#undef TRUE
+///////////////////////////////////////////////////////////
+
+#include "storage/v3/view.hpp"
+#include "utils/bound.hpp"
+#include "utils/exceptions.hpp"
+
+namespace memgraph::query::v2 {
+
+class VertexAccessor;
+
+class EdgeAccessor final {
+ public:
+  storage::v3::EdgeAccessor impl_;
+
+  explicit EdgeAccessor(storage::v3::EdgeAccessor impl) : impl_(std::move(impl)) {}
+
+  bool IsVisible(storage::v3::View view) const { return impl_.IsVisible(view); }
+
+  storage::v3::EdgeTypeId EdgeType() const { return impl_.EdgeType(); }
+
+  auto Properties(storage::v3::View view) const { return impl_.Properties(view); }
+
+  storage::v3::Result<storage::v3::PropertyValue> GetProperty(storage::v3::View view,
+                                                              storage::v3::PropertyId key) const {
+    return impl_.GetProperty(key, view);
+  }
+
+  storage::v3::Result<storage::v3::PropertyValue> SetProperty(storage::v3::PropertyId key,
+                                                              const storage::v3::PropertyValue &value) {
+    return impl_.SetProperty(key, value);
+  }
+
+  storage::v3::Result<storage::v3::PropertyValue> RemoveProperty(storage::v3::PropertyId key) {
+    return SetProperty(key, storage::v3::PropertyValue());
+  }
+
+  storage::v3::Result<std::map<storage::v3::PropertyId, storage::v3::PropertyValue>> ClearProperties() {
+    return impl_.ClearProperties();
+  }
+
+  VertexAccessor To() const;
+
+  VertexAccessor From() const;
+
+  bool IsCycle() const;
+
+  int64_t CypherId() const { return impl_.Gid().AsInt(); }
+
+  storage::v3::Gid Gid() const noexcept { return impl_.Gid(); }
+
+  bool operator==(const EdgeAccessor &e) const noexcept { return impl_ == e.impl_; }
+
+  bool operator!=(const EdgeAccessor &e) const noexcept { return !(*this == e); }
+};
+
+class VertexAccessor final {
+ public:
+  storage::v3::VertexAccessor impl_;
+
+  static EdgeAccessor MakeEdgeAccessor(const storage::v3::EdgeAccessor impl) { return EdgeAccessor(impl); }
+
+  explicit VertexAccessor(storage::v3::VertexAccessor impl) : impl_(impl) {}
+
+  bool IsVisible(storage::v3::View view) const { return impl_.IsVisible(view); }
+
+  auto Labels(storage::v3::View view) const { return impl_.Labels(view); }
+
+  auto PrimaryLabel(storage::v3::View view) const { return impl_.PrimaryLabel(view); }
+
+  storage::v3::Result<bool> AddLabel(storage::v3::LabelId label) { return impl_.AddLabel(label); }
+
+  storage::v3::ResultSchema<bool> AddLabelAndValidate(storage::v3::LabelId label) {
+    return impl_.AddLabelAndValidate(label);
+  }
+
+  storage::v3::Result<bool> RemoveLabel(storage::v3::LabelId label) { return impl_.RemoveLabel(label); }
+
+  storage::v3::ResultSchema<bool> RemoveLabelAndValidate(storage::v3::LabelId label) {
+    return impl_.RemoveLabelAndValidate(label);
+  }
+
+  storage::v3::Result<bool> HasLabel(storage::v3::View view, storage::v3::LabelId label) const {
+    return impl_.HasLabel(label, view);
+  }
+
+  auto Properties(storage::v3::View view) const { return impl_.Properties(view); }
+
+  storage::v3::Result<storage::v3::PropertyValue> GetProperty(storage::v3::View view,
+                                                              storage::v3::PropertyId key) const {
+    return impl_.GetProperty(key, view);
+  }
+
+  storage::v3::Result<storage::v3::PropertyValue> SetProperty(storage::v3::PropertyId key,
+                                                              const storage::v3::PropertyValue &value) {
+    return impl_.SetProperty(key, value);
+  }
+
+  storage::v3::ResultSchema<storage::v3::PropertyValue> SetPropertyAndValidate(
+      storage::v3::PropertyId key, const storage::v3::PropertyValue &value) {
+    return impl_.SetPropertyAndValidate(key, value);
+  }
+
+  storage::v3::ResultSchema<storage::v3::PropertyValue> RemovePropertyAndValidate(storage::v3::PropertyId key) {
+    return SetPropertyAndValidate(key, storage::v3::PropertyValue{});
+  }
+
+  storage::v3::Result<std::map<storage::v3::PropertyId, storage::v3::PropertyValue>> ClearProperties() {
+    return impl_.ClearProperties();
+  }
+
+  auto InEdges(storage::v3::View view, const std::vector<storage::v3::EdgeTypeId> &edge_types) const
+      -> storage::v3::Result<decltype(iter::imap(MakeEdgeAccessor, *impl_.InEdges(view)))> {
+    auto maybe_edges = impl_.InEdges(view, edge_types);
+    if (maybe_edges.HasError()) return maybe_edges.GetError();
+    return iter::imap(MakeEdgeAccessor, std::move(*maybe_edges));
+  }
+
+  auto InEdges(storage::v3::View view) const { return InEdges(view, {}); }
+
+  auto InEdges(storage::v3::View view, const std::vector<storage::v3::EdgeTypeId> &edge_types,
+               const VertexAccessor &dest) const
+      -> storage::v3::Result<decltype(iter::imap(MakeEdgeAccessor, *impl_.InEdges(view)))> {
+    auto maybe_edges = impl_.InEdges(view, edge_types, &dest.impl_);
+    if (maybe_edges.HasError()) return maybe_edges.GetError();
+    return iter::imap(MakeEdgeAccessor, std::move(*maybe_edges));
+  }
+
+  auto OutEdges(storage::v3::View view, const std::vector<storage::v3::EdgeTypeId> &edge_types) const
+      -> storage::v3::Result<decltype(iter::imap(MakeEdgeAccessor, *impl_.OutEdges(view)))> {
+    auto maybe_edges = impl_.OutEdges(view, edge_types);
+    if (maybe_edges.HasError()) return maybe_edges.GetError();
+    return iter::imap(MakeEdgeAccessor, std::move(*maybe_edges));
+  }
+
+  auto OutEdges(storage::v3::View view) const { return OutEdges(view, {}); }
+
+  auto OutEdges(storage::v3::View view, const std::vector<storage::v3::EdgeTypeId> &edge_types,
+                const VertexAccessor &dest) const
+      -> storage::v3::Result<decltype(iter::imap(MakeEdgeAccessor, *impl_.OutEdges(view)))> {
+    auto maybe_edges = impl_.OutEdges(view, edge_types, &dest.impl_);
+    if (maybe_edges.HasError()) return maybe_edges.GetError();
+    return iter::imap(MakeEdgeAccessor, std::move(*maybe_edges));
+  }
+
+  storage::v3::Result<size_t> InDegree(storage::v3::View view) const { return impl_.InDegree(view); }
+
+  storage::v3::Result<size_t> OutDegree(storage::v3::View view) const { return impl_.OutDegree(view); }
+
+  int64_t CypherId() const { return impl_.Gid().AsInt(); }
+
+  storage::v3::Gid Gid() const noexcept { return impl_.Gid(); }
+
+  bool operator==(const VertexAccessor &v) const noexcept {
+    static_assert(noexcept(impl_ == v.impl_));
+    return impl_ == v.impl_;
+  }
+
+  bool operator!=(const VertexAccessor &v) const noexcept { return !(*this == v); }
+};
+
+inline VertexAccessor EdgeAccessor::To() const { return VertexAccessor(impl_.ToVertex()); }
+
+inline VertexAccessor EdgeAccessor::From() const { return VertexAccessor(impl_.FromVertex()); }
+
+inline bool EdgeAccessor::IsCycle() const { return To() == From(); }
+
+class DbAccessor final {
+  storage::v3::Storage::Accessor *accessor_;
+
+  class VerticesIterable final {
+    storage::v3::VerticesIterable iterable_;
+
+   public:
+    class Iterator final {
+      storage::v3::VerticesIterable::Iterator it_;
+
+     public:
+      explicit Iterator(storage::v3::VerticesIterable::Iterator it) : it_(it) {}
+
+      VertexAccessor operator*() const { return VertexAccessor(*it_); }
+
+      Iterator &operator++() {
+        ++it_;
+        return *this;
+      }
+
+      bool operator==(const Iterator &other) const { return it_ == other.it_; }
+
+      bool operator!=(const Iterator &other) const { return !(other == *this); }
+    };
+
+    explicit VerticesIterable(storage::v3::VerticesIterable iterable) : iterable_(std::move(iterable)) {}
+
+    Iterator begin() { return Iterator(iterable_.begin()); }
+
+    Iterator end() { return Iterator(iterable_.end()); }
+  };
+
+ public:
+  explicit DbAccessor(storage::v3::Storage::Accessor *accessor) : accessor_(accessor) {}
+
+  std::optional<VertexAccessor> FindVertex(storage::v3::Gid gid, storage::v3::View view) {
+    auto maybe_vertex = accessor_->FindVertex(gid, view);
+    if (maybe_vertex) return VertexAccessor(*maybe_vertex);
+    return std::nullopt;
+  }
+
+  void FinalizeTransaction() { accessor_->FinalizeTransaction(); }
+
+  VerticesIterable Vertices(storage::v3::View view) { return VerticesIterable(accessor_->Vertices(view)); }
+
+  VerticesIterable Vertices(storage::v3::View view, storage::v3::LabelId label) {
+    return VerticesIterable(accessor_->Vertices(label, view));
+  }
+
+  VerticesIterable Vertices(storage::v3::View view, storage::v3::LabelId label, storage::v3::PropertyId property) {
+    return VerticesIterable(accessor_->Vertices(label, property, view));
+  }
+
+  VerticesIterable Vertices(storage::v3::View view, storage::v3::LabelId label, storage::v3::PropertyId property,
+                            const storage::v3::PropertyValue &value) {
+    return VerticesIterable(accessor_->Vertices(label, property, value, view));
+  }
+
+  VerticesIterable Vertices(storage::v3::View view, storage::v3::LabelId label, storage::v3::PropertyId property,
+                            const std::optional<utils::Bound<storage::v3::PropertyValue>> &lower,
+                            const std::optional<utils::Bound<storage::v3::PropertyValue>> &upper) {
+    return VerticesIterable(accessor_->Vertices(label, property, lower, upper, view));
+  }
+
+  // TODO Remove when query modules have been fixed
+  [[deprecated]] VertexAccessor InsertVertex() { return VertexAccessor(accessor_->CreateVertex()); }
+
+  storage::v3::ResultSchema<VertexAccessor> InsertVertexAndValidate(
+      const storage::v3::LabelId primary_label, const std::vector<storage::v3::LabelId> &labels,
+      const std::vector<std::pair<storage::v3::PropertyId, storage::v3::PropertyValue>> &properties) {
+    auto maybe_vertex_acc = accessor_->CreateVertexAndValidate(primary_label, labels, properties);
+    if (maybe_vertex_acc.HasError()) {
+      return {std::move(maybe_vertex_acc.GetError())};
+    }
+    return VertexAccessor{maybe_vertex_acc.GetValue()};
+  }
+
+  storage::v3::Result<EdgeAccessor> InsertEdge(VertexAccessor *from, VertexAccessor *to,
+                                               const storage::v3::EdgeTypeId &edge_type) {
+    auto maybe_edge = accessor_->CreateEdge(&from->impl_, &to->impl_, edge_type);
+    if (maybe_edge.HasError()) return storage::v3::Result<EdgeAccessor>(maybe_edge.GetError());
+    return EdgeAccessor(*maybe_edge);
+  }
+
+  storage::v3::Result<std::optional<EdgeAccessor>> RemoveEdge(EdgeAccessor *edge) {
+    auto res = accessor_->DeleteEdge(&edge->impl_);
+    if (res.HasError()) {
+      return res.GetError();
+    }
+
+    const auto &value = res.GetValue();
+    if (!value) {
+      return std::optional<EdgeAccessor>{};
+    }
+
+    return std::make_optional<EdgeAccessor>(*value);
+  }
+
+  storage::v3::Result<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>> DetachRemoveVertex(
+      VertexAccessor *vertex_accessor) {
+    using ReturnType = std::pair<VertexAccessor, std::vector<EdgeAccessor>>;
+
+    auto res = accessor_->DetachDeleteVertex(&vertex_accessor->impl_);
+    if (res.HasError()) {
+      return res.GetError();
+    }
+
+    const auto &value = res.GetValue();
+    if (!value) {
+      return std::optional<ReturnType>{};
+    }
+
+    const auto &[vertex, edges] = *value;
+
+    std::vector<EdgeAccessor> deleted_edges;
+    deleted_edges.reserve(edges.size());
+    std::transform(edges.begin(), edges.end(), std::back_inserter(deleted_edges),
+                   [](const auto &deleted_edge) { return EdgeAccessor{deleted_edge}; });
+
+    return std::make_optional<ReturnType>(vertex, std::move(deleted_edges));
+  }
+
+  storage::v3::Result<std::optional<VertexAccessor>> RemoveVertex(VertexAccessor *vertex_accessor) {
+    auto res = accessor_->DeleteVertex(&vertex_accessor->impl_);
+    if (res.HasError()) {
+      return res.GetError();
+    }
+
+    const auto &value = res.GetValue();
+    if (!value) {
+      return std::optional<VertexAccessor>{};
+    }
+
+    return {std::make_optional<VertexAccessor>(*value)};
+  }
+
+  storage::v3::PropertyId NameToProperty(const std::string_view name) { return accessor_->NameToProperty(name); }
+
+  storage::v3::LabelId NameToLabel(const std::string_view name) { return accessor_->NameToLabel(name); }
+
+  storage::v3::EdgeTypeId NameToEdgeType(const std::string_view name) { return accessor_->NameToEdgeType(name); }
+
+  const std::string &PropertyToName(storage::v3::PropertyId prop) const { return accessor_->PropertyToName(prop); }
+
+  const std::string &LabelToName(storage::v3::LabelId label) const { return accessor_->LabelToName(label); }
+
+  const std::string &EdgeTypeToName(storage::v3::EdgeTypeId type) const { return accessor_->EdgeTypeToName(type); }
+
+  void AdvanceCommand() { accessor_->AdvanceCommand(); }
+
+  utils::BasicResult<storage::v3::ConstraintViolation, void> Commit() { return accessor_->Commit(); }
+
+  void Abort() { accessor_->Abort(); }
+
+  bool LabelIndexExists(storage::v3::LabelId label) const { return accessor_->LabelIndexExists(label); }
+
+  bool LabelPropertyIndexExists(storage::v3::LabelId label, storage::v3::PropertyId prop) const {
+    return accessor_->LabelPropertyIndexExists(label, prop);
+  }
+
+  int64_t VerticesCount() const { return accessor_->ApproximateVertexCount(); }
+
+  int64_t VerticesCount(storage::v3::LabelId label) const { return accessor_->ApproximateVertexCount(label); }
+
+  int64_t VerticesCount(storage::v3::LabelId label, storage::v3::PropertyId property) const {
+    return accessor_->ApproximateVertexCount(label, property);
+  }
+
+  int64_t VerticesCount(storage::v3::LabelId label, storage::v3::PropertyId property,
+                        const storage::v3::PropertyValue &value) const {
+    return accessor_->ApproximateVertexCount(label, property, value);
+  }
+
+  int64_t VerticesCount(storage::v3::LabelId label, storage::v3::PropertyId property,
+                        const std::optional<utils::Bound<storage::v3::PropertyValue>> &lower,
+                        const std::optional<utils::Bound<storage::v3::PropertyValue>> &upper) const {
+    return accessor_->ApproximateVertexCount(label, property, lower, upper);
+  }
+
+  storage::v3::IndicesInfo ListAllIndices() const { return accessor_->ListAllIndices(); }
+
+  storage::v3::ConstraintsInfo ListAllConstraints() const { return accessor_->ListAllConstraints(); }
+
+  const storage::v3::SchemaValidator &GetSchemaValidator() const { return accessor_->GetSchemaValidator(); }
+
+  storage::v3::SchemasInfo ListAllSchemas() const { return accessor_->ListAllSchemas(); }
+};
+
+}  // namespace memgraph::query::v2
+
+namespace std {
+
+template <>
+struct hash<memgraph::query::v2::VertexAccessor> {
+  size_t operator()(const memgraph::query::v2::VertexAccessor &v) const {
+    return std::hash<decltype(v.impl_)>{}(v.impl_);
+  }
+};
+
+template <>
+struct hash<memgraph::query::v2::EdgeAccessor> {
+  size_t operator()(const memgraph::query::v2::EdgeAccessor &e) const {
+    return std::hash<decltype(e.impl_)>{}(e.impl_);
+  }
+};
+
+}  // namespace std

src/query/v2/discard_value_stream.hpp

@@ -0,0 +1,24 @@
+// 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.
+
+#pragma once
+
+#include <vector>
+
+#include "query/v2/typed_value.hpp"
+
+namespace memgraph::query::v2 {
+struct DiscardValueResultStream final {
+  void Result(const std::vector<query::v2::TypedValue> & /*values*/) {
+    // do nothing
+  }
+};
+}  // namespace memgraph::query::v2

src/query/v2/dump.cpp

@@ -0,0 +1,541 @@
+// 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 "query/v2/dump.hpp"
+
+#include <iomanip>
+#include <limits>
+#include <map>
+#include <optional>
+#include <ostream>
+#include <utility>
+#include <vector>
+
+#include <fmt/format.h>
+
+#include "query/v2/db_accessor.hpp"
+#include "query/v2/exceptions.hpp"
+#include "query/v2/stream.hpp"
+#include "query/v2/typed_value.hpp"
+#include "storage/v3/property_value.hpp"
+#include "storage/v3/storage.hpp"
+#include "utils/algorithm.hpp"
+#include "utils/logging.hpp"
+#include "utils/string.hpp"
+#include "utils/temporal.hpp"
+
+namespace memgraph::query::v2 {
+
+namespace {
+
+// Property that is used to make a difference among vertices. It is added to
+// property set of vertices to match edges and removed after the entire graph
+// is built.
+const char *kInternalPropertyId = "__mg_id__";
+
+// Label that is attached to each vertex and is used for easier creation of
+// index on internal property 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 out;
+  out.reserve(value.size() + 2);
+  out.append(1, '`');
+  for (auto c : value) {
+    if (c == '`') {
+      out.append("``");
+    } else {
+      out.append(1, c);
+    }
+  }
+  out.append(1, '`');
+  return out;
+}
+
+void DumpPreciseDouble(std::ostream *os, double value) {
+  // A temporary stream is used to keep precision of the original output
+  // stream unchanged.
+  std::ostringstream temp_oss;
+  temp_oss << std::setprecision(std::numeric_limits<double>::max_digits10) << value;
+  *os << temp_oss.str();
+}
+
+namespace {
+void DumpDate(std::ostream &os, const storage::v3::TemporalData &value) {
+  utils::Date date(value.microseconds);
+  os << "DATE(\"" << date << "\")";
+}
+
+void DumpLocalTime(std::ostream &os, const storage::v3::TemporalData &value) {
+  utils::LocalTime lt(value.microseconds);
+  os << "LOCALTIME(\"" << lt << "\")";
+}
+
+void DumpLocalDateTime(std::ostream &os, const storage::v3::TemporalData &value) {
+  utils::LocalDateTime ldt(value.microseconds);
+  os << "LOCALDATETIME(\"" << ldt << "\")";
+}
+
+void DumpDuration(std::ostream &os, const storage::v3::TemporalData &value) {
+  utils::Duration dur(value.microseconds);
+  os << "DURATION(\"" << dur << "\")";
+}
+
+void DumpTemporalData(std::ostream &os, const storage::v3::TemporalData &value) {
+  switch (value.type) {
+    case storage::v3::TemporalType::Date: {
+      DumpDate(os, value);
+      return;
+    }
+    case storage::v3::TemporalType::LocalTime: {
+      DumpLocalTime(os, value);
+      return;
+    }
+    case storage::v3::TemporalType::LocalDateTime: {
+      DumpLocalDateTime(os, value);
+      return;
+    }
+    case storage::v3::TemporalType::Duration: {
+      DumpDuration(os, value);
+      return;
+    }
+  }
+}
+}  // namespace
+
+void DumpPropertyValue(std::ostream *os, const storage::v3::PropertyValue &value) {
+  switch (value.type()) {
+    case storage::v3::PropertyValue::Type::Null:
+      *os << "Null";
+      return;
+    case storage::v3::PropertyValue::Type::Bool:
+      *os << (value.ValueBool() ? "true" : "false");
+      return;
+    case storage::v3::PropertyValue::Type::String:
+      *os << utils::Escape(value.ValueString());
+      return;
+    case storage::v3::PropertyValue::Type::Int:
+      *os << value.ValueInt();
+      return;
+    case storage::v3::PropertyValue::Type::Double:
+      DumpPreciseDouble(os, value.ValueDouble());
+      return;
+    case storage::v3::PropertyValue::Type::List: {
+      *os << "[";
+      const auto &list = value.ValueList();
+      utils::PrintIterable(*os, list, ", ", [](auto &os, const auto &item) { DumpPropertyValue(&os, item); });
+      *os << "]";
+      return;
+    }
+    case storage::v3::PropertyValue::Type::Map: {
+      *os << "{";
+      const auto &map = value.ValueMap();
+      utils::PrintIterable(*os, map, ", ", [](auto &os, const auto &kv) {
+        os << EscapeName(kv.first) << ": ";
+        DumpPropertyValue(&os, kv.second);
+      });
+      *os << "}";
+      return;
+    }
+    case storage::v3::PropertyValue::Type::TemporalData: {
+      DumpTemporalData(*os, value.ValueTemporalData());
+      return;
+    }
+  }
+}
+
+void DumpProperties(std::ostream *os, query::v2::DbAccessor *dba,
+                    const std::map<storage::v3::PropertyId, storage::v3::PropertyValue> &store,
+                    std::optional<int64_t> property_id = std::nullopt) {
+  *os << "{";
+  if (property_id) {
+    *os << kInternalPropertyId << ": " << *property_id;
+    if (store.size() > 0) *os << ", ";
+  }
+  utils::PrintIterable(*os, store, ", ", [&dba](auto &os, const auto &kv) {
+    os << EscapeName(dba->PropertyToName(kv.first)) << ": ";
+    DumpPropertyValue(&os, kv.second);
+  });
+  *os << "}";
+}
+
+void DumpVertex(std::ostream *os, query::v2::DbAccessor *dba, const query::v2::VertexAccessor &vertex) {
+  *os << "CREATE (";
+  *os << ":" << kInternalVertexLabel;
+  auto maybe_labels = vertex.Labels(storage::v3::View::OLD);
+  if (maybe_labels.HasError()) {
+    switch (maybe_labels.GetError()) {
+      case storage::v3::Error::DELETED_OBJECT:
+        throw query::v2::QueryRuntimeException("Trying to get labels from a deleted node.");
+      case storage::v3::Error::NONEXISTENT_OBJECT:
+        throw query::v2::QueryRuntimeException("Trying to get labels from a node that doesn't exist.");
+      case storage::v3::Error::SERIALIZATION_ERROR:
+      case storage::v3::Error::VERTEX_HAS_EDGES:
+      case storage::v3::Error::PROPERTIES_DISABLED:
+        throw query::v2::QueryRuntimeException("Unexpected error when getting labels.");
+    }
+  }
+  for (const auto &label : *maybe_labels) {
+    *os << ":" << EscapeName(dba->LabelToName(label));
+  }
+  *os << " ";
+  auto maybe_props = vertex.Properties(storage::v3::View::OLD);
+  if (maybe_props.HasError()) {
+    switch (maybe_props.GetError()) {
+      case storage::v3::Error::DELETED_OBJECT:
+        throw query::v2::QueryRuntimeException("Trying to get properties from a deleted object.");
+      case storage::v3::Error::NONEXISTENT_OBJECT:
+        throw query::v2::QueryRuntimeException("Trying to get properties from a node that doesn't exist.");
+      case storage::v3::Error::SERIALIZATION_ERROR:
+      case storage::v3::Error::VERTEX_HAS_EDGES:
+      case storage::v3::Error::PROPERTIES_DISABLED:
+        throw query::v2::QueryRuntimeException("Unexpected error when getting properties.");
+    }
+  }
+  DumpProperties(os, dba, *maybe_props, vertex.CypherId());
+  *os << ");";
+}
+
+void DumpEdge(std::ostream *os, query::v2::DbAccessor *dba, const query::v2::EdgeAccessor &edge) {
+  *os << "MATCH ";
+  *os << "(u:" << kInternalVertexLabel << "), ";
+  *os << "(v:" << kInternalVertexLabel << ")";
+  *os << " WHERE ";
+  *os << "u." << kInternalPropertyId << " = " << edge.From().CypherId();
+  *os << " AND ";
+  *os << "v." << kInternalPropertyId << " = " << edge.To().CypherId() << " ";
+  *os << "CREATE (u)-[";
+  *os << ":" << EscapeName(dba->EdgeTypeToName(edge.EdgeType()));
+  auto maybe_props = edge.Properties(storage::v3::View::OLD);
+  if (maybe_props.HasError()) {
+    switch (maybe_props.GetError()) {
+      case storage::v3::Error::DELETED_OBJECT:
+        throw query::v2::QueryRuntimeException("Trying to get properties from a deleted object.");
+      case storage::v3::Error::NONEXISTENT_OBJECT:
+        throw query::v2::QueryRuntimeException("Trying to get properties from an edge that doesn't exist.");
+      case storage::v3::Error::SERIALIZATION_ERROR:
+      case storage::v3::Error::VERTEX_HAS_EDGES:
+      case storage::v3::Error::PROPERTIES_DISABLED:
+        throw query::v2::QueryRuntimeException("Unexpected error when getting properties.");
+    }
+  }
+  if (maybe_props->size() > 0) {
+    *os << " ";
+    DumpProperties(os, dba, *maybe_props);
+  }
+  *os << "]->(v);";
+}
+
+void DumpLabelIndex(std::ostream *os, query::v2::DbAccessor *dba, const storage::v3::LabelId label) {
+  *os << "CREATE INDEX ON :" << EscapeName(dba->LabelToName(label)) << ";";
+}
+
+void DumpLabelPropertyIndex(std::ostream *os, query::v2::DbAccessor *dba, storage::v3::LabelId label,
+                            storage::v3::PropertyId property) {
+  *os << "CREATE INDEX ON :" << EscapeName(dba->LabelToName(label)) << "(" << EscapeName(dba->PropertyToName(property))
+      << ");";
+}
+
+void DumpExistenceConstraint(std::ostream *os, query::v2::DbAccessor *dba, storage::v3::LabelId label,
+                             storage::v3::PropertyId property) {
+  *os << "CREATE CONSTRAINT ON (u:" << EscapeName(dba->LabelToName(label)) << ") ASSERT EXISTS (u."
+      << EscapeName(dba->PropertyToName(property)) << ");";
+}
+
+void DumpUniqueConstraint(std::ostream *os, query::v2::DbAccessor *dba, storage::v3::LabelId label,
+                          const std::set<storage::v3::PropertyId> &properties) {
+  *os << "CREATE CONSTRAINT ON (u:" << EscapeName(dba->LabelToName(label)) << ") ASSERT ";
+  utils::PrintIterable(*os, properties, ", ", [&dba](auto &stream, const auto &property) {
+    stream << "u." << EscapeName(dba->PropertyToName(property));
+  });
+  *os << " IS UNIQUE;";
+}
+
+}  // namespace
+
+PullPlanDump::PullPlanDump(DbAccessor *dba)
+    : dba_(dba),
+      vertices_iterable_(dba->Vertices(storage::v3::View::OLD)),
+      pull_chunks_{// Dump all label indices
+                   CreateLabelIndicesPullChunk(),
+                   // Dump all label property indices
+                   CreateLabelPropertyIndicesPullChunk(),
+                   // Dump all existence constraints
+                   CreateExistenceConstraintsPullChunk(),
+                   // Dump all unique constraints
+                   CreateUniqueConstraintsPullChunk(),
+                   // Create internal index for faster edge creation
+                   CreateInternalIndexPullChunk(),
+                   // Dump all vertices
+                   CreateVertexPullChunk(),
+                   // Dump all edges
+                   CreateEdgePullChunk(),
+                   // Drop the internal index
+                   CreateDropInternalIndexPullChunk(),
+                   // Internal index cleanup
+                   CreateInternalIndexCleanupPullChunk()} {}
+
+bool PullPlanDump::Pull(AnyStream *stream, std::optional<int> n) {
+  // Iterate all functions that stream some results.
+  // Each function should return number of results it streamed after it
+  // finishes. If the function did not finish streaming all the results,
+  // std::nullopt should be returned because n results have already been sent.
+  while (current_chunk_index_ < pull_chunks_.size() && (!n || *n > 0)) {
+    const auto maybe_streamed_count = pull_chunks_[current_chunk_index_](stream, n);
+
+    if (!maybe_streamed_count) {
+      // n wasn't large enough to stream all the results from the current chunk
+      break;
+    }
+
+    if (n) {
+      // chunk finished streaming its results
+      // subtract number of results streamed in current pull
+      // so we know how many results we need to stream from future
+      // chunks.
+      *n -= *maybe_streamed_count;
+    }
+
+    ++current_chunk_index_;
+  }
+  return current_chunk_index_ == pull_chunks_.size();
+}
+
+PullPlanDump::PullChunk PullPlanDump::CreateLabelIndicesPullChunk() {
+  // Dump all label indices
+  return [this, global_index = 0U](AnyStream *stream, std::optional<int> n) mutable -> std::optional<size_t> {
+    // Delay the construction of indices vectors
+    if (!indices_info_) {
+      indices_info_.emplace(dba_->ListAllIndices());
+    }
+    const auto &label = indices_info_->label;
+
+    size_t local_counter = 0;
+    while (global_index < label.size() && (!n || local_counter < *n)) {
+      std::ostringstream os;
+      DumpLabelIndex(&os, dba_, label[global_index]);
+      stream->Result({TypedValue(os.str())});
+
+      ++global_index;
+      ++local_counter;
+    }
+
+    if (global_index == label.size()) {
+      return local_counter;
+    }
+
+    return std::nullopt;
+  };
+}
+
+PullPlanDump::PullChunk PullPlanDump::CreateLabelPropertyIndicesPullChunk() {
+  return [this, global_index = 0U](AnyStream *stream, std::optional<int> n) mutable -> std::optional<size_t> {
+    // Delay the construction of indices vectors
+    if (!indices_info_) {
+      indices_info_.emplace(dba_->ListAllIndices());
+    }
+    const auto &label_property = indices_info_->label_property;
+
+    size_t local_counter = 0;
+    while (global_index < label_property.size() && (!n || local_counter < *n)) {
+      std::ostringstream os;
+      const auto &label_property_index = label_property[global_index];
+      DumpLabelPropertyIndex(&os, dba_, label_property_index.first, label_property_index.second);
+      stream->Result({TypedValue(os.str())});
+
+      ++global_index;
+      ++local_counter;
+    }
+
+    if (global_index == label_property.size()) {
+      return local_counter;
+    }
+
+    return std::nullopt;
+  };
+}
+
+PullPlanDump::PullChunk PullPlanDump::CreateExistenceConstraintsPullChunk() {
+  return [this, global_index = 0U](AnyStream *stream, std::optional<int> n) mutable -> std::optional<size_t> {
+    // Delay the construction of constraint vectors
+    if (!constraints_info_) {
+      constraints_info_.emplace(dba_->ListAllConstraints());
+    }
+
+    const auto &existence = constraints_info_->existence;
+    size_t local_counter = 0;
+    while (global_index < existence.size() && (!n || local_counter < *n)) {
+      const auto &constraint = existence[global_index];
+      std::ostringstream os;
+      DumpExistenceConstraint(&os, dba_, constraint.first, constraint.second);
+      stream->Result({TypedValue(os.str())});
+
+      ++global_index;
+      ++local_counter;
+    }
+
+    if (global_index == existence.size()) {
+      return local_counter;
+    }
+
+    return std::nullopt;
+  };
+}
+
+PullPlanDump::PullChunk PullPlanDump::CreateUniqueConstraintsPullChunk() {
+  return [this, global_index = 0U](AnyStream *stream, std::optional<int> n) mutable -> std::optional<size_t> {
+    // Delay the construction of constraint vectors
+    if (!constraints_info_) {
+      constraints_info_.emplace(dba_->ListAllConstraints());
+    }
+
+    const auto &unique = constraints_info_->unique;
+    size_t local_counter = 0;
+    while (global_index < unique.size() && (!n || local_counter < *n)) {
+      const auto &constraint = unique[global_index];
+      std::ostringstream os;
+      DumpUniqueConstraint(&os, dba_, constraint.first, constraint.second);
+      stream->Result({TypedValue(os.str())});
+
+      ++global_index;
+      ++local_counter;
+    }
+
+    if (global_index == unique.size()) {
+      return local_counter;
+    }
+
+    return std::nullopt;
+  };
+}
+
+PullPlanDump::PullChunk PullPlanDump::CreateInternalIndexPullChunk() {
+  return [this](AnyStream *stream, std::optional<int>) mutable -> std::optional<size_t> {
+    if (vertices_iterable_.begin() != vertices_iterable_.end()) {
+      std::ostringstream os;
+      os << "CREATE INDEX ON :" << kInternalVertexLabel << "(" << kInternalPropertyId << ");";
+      stream->Result({TypedValue(os.str())});
+      internal_index_created_ = true;
+      return 1;
+    }
+    return 0;
+  };
+}
+
+PullPlanDump::PullChunk PullPlanDump::CreateVertexPullChunk() {
+  return [this, maybe_current_iter = std::optional<VertexAccessorIterableIterator>{}](
+             AnyStream *stream, std::optional<int> n) mutable -> std::optional<size_t> {
+    // Delay the call of begin() function
+    // If multiple begins are called before an iteration,
+    // one iteration will make the rest of iterators be in undefined
+    // states.
+    if (!maybe_current_iter) {
+      maybe_current_iter.emplace(vertices_iterable_.begin());
+    }
+
+    auto &current_iter{*maybe_current_iter};
+
+    size_t local_counter = 0;
+    while (current_iter != vertices_iterable_.end() && (!n || local_counter < *n)) {
+      std::ostringstream os;
+      DumpVertex(&os, dba_, *current_iter);
+      stream->Result({TypedValue(os.str())});
+      ++local_counter;
+      ++current_iter;
+    }
+    if (current_iter == vertices_iterable_.end()) {
+      return local_counter;
+    }
+
+    return std::nullopt;
+  };
+}
+
+PullPlanDump::PullChunk PullPlanDump::CreateEdgePullChunk() {
+  return [this, maybe_current_vertex_iter = std::optional<VertexAccessorIterableIterator>{},
+          // we need to save the iterable which contains list of accessor so
+          // our saved iterator is valid in the next run
+          maybe_edge_iterable = std::shared_ptr<EdgeAccessorIterable>{nullptr},
+          maybe_current_edge_iter = std::optional<EdgeAccessorIterableIterator>{}](
+             AnyStream *stream, std::optional<int> n) mutable -> std::optional<size_t> {
+    // Delay the call of begin() function
+    // If multiple begins are called before an iteration,
+    // one iteration will make the rest of iterators be in undefined
+    // states.
+    if (!maybe_current_vertex_iter) {
+      maybe_current_vertex_iter.emplace(vertices_iterable_.begin());
+    }
+
+    auto &current_vertex_iter{*maybe_current_vertex_iter};
+    size_t local_counter = 0U;
+    for (; current_vertex_iter != vertices_iterable_.end() && (!n || local_counter < *n); ++current_vertex_iter) {
+      const auto &vertex = *current_vertex_iter;
+      // If we have a saved iterable from a previous pull
+      // we need to use the same iterable
+      if (!maybe_edge_iterable) {
+        maybe_edge_iterable = std::make_shared<EdgeAccessorIterable>(vertex.OutEdges(storage::v3::View::OLD));
+      }
+      auto &maybe_edges = *maybe_edge_iterable;
+      MG_ASSERT(maybe_edges.HasValue(), "Invalid database state!");
+      auto current_edge_iter = maybe_current_edge_iter ? *maybe_current_edge_iter : maybe_edges->begin();
+      for (; current_edge_iter != maybe_edges->end() && (!n || local_counter < *n); ++current_edge_iter) {
+        std::ostringstream os;
+        DumpEdge(&os, dba_, *current_edge_iter);
+        stream->Result({TypedValue(os.str())});
+
+        ++local_counter;
+      }
+
+      if (current_edge_iter != maybe_edges->end()) {
+        maybe_current_edge_iter.emplace(current_edge_iter);
+        return std::nullopt;
+      }
+
+      maybe_current_edge_iter = std::nullopt;
+      maybe_edge_iterable = nullptr;
+    }
+
+    if (current_vertex_iter == vertices_iterable_.end()) {
+      return local_counter;
+    }
+
+    return std::nullopt;
+  };
+}
+
+PullPlanDump::PullChunk PullPlanDump::CreateDropInternalIndexPullChunk() {
+  return [this](AnyStream *stream, std::optional<int>) {
+    if (internal_index_created_) {
+      std::ostringstream os;
+      os << "DROP INDEX ON :" << kInternalVertexLabel << "(" << kInternalPropertyId << ");";
+      stream->Result({TypedValue(os.str())});
+      return 1;
+    }
+    return 0;
+  };
+}
+
+PullPlanDump::PullChunk PullPlanDump::CreateInternalIndexCleanupPullChunk() {
+  return [this](AnyStream *stream, std::optional<int>) {
+    if (internal_index_created_) {
+      std::ostringstream os;
+      os << "MATCH (u) REMOVE u:" << kInternalVertexLabel << ", u." << kInternalPropertyId << ";";
+      stream->Result({TypedValue(os.str())});
+      return 1;
+    }
+    return 0;
+  };
+}
+
+void DumpDatabaseToCypherQueries(query::v2::DbAccessor *dba, AnyStream *stream) { PullPlanDump(dba).Pull(stream, {}); }
+
+}  // namespace memgraph::query::v2

src/query/v2/dump.hpp

@@ -0,0 +1,66 @@
+// 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.
+
+#pragma once
+
+#include <ostream>
+
+#include "query/v2/db_accessor.hpp"
+#include "query/v2/stream.hpp"
+#include "storage/v3/storage.hpp"
+
+namespace memgraph::query::v2 {
+
+void DumpDatabaseToCypherQueries(query::v2::DbAccessor *dba, AnyStream *stream);
+
+struct PullPlanDump {
+  explicit PullPlanDump(query::v2::DbAccessor *dba);
+
+  /// Pull the dump results lazily
+  /// @return true if all results were returned, false otherwise
+  bool Pull(AnyStream *stream, std::optional<int> n);
+
+ private:
+  query::v2::DbAccessor *dba_ = nullptr;
+
+  std::optional<storage::v3::IndicesInfo> indices_info_ = std::nullopt;
+  std::optional<storage::v3::ConstraintsInfo> constraints_info_ = std::nullopt;
+
+  using VertexAccessorIterable = decltype(std::declval<query::v2::DbAccessor>().Vertices(storage::v3::View::OLD));
+  using VertexAccessorIterableIterator = decltype(std::declval<VertexAccessorIterable>().begin());
+
+  using EdgeAccessorIterable = decltype(std::declval<VertexAccessor>().OutEdges(storage::v3::View::OLD));
+  using EdgeAccessorIterableIterator = decltype(std::declval<EdgeAccessorIterable>().GetValue().begin());
+
+  VertexAccessorIterable vertices_iterable_;
+  bool internal_index_created_ = false;
+
+  size_t current_chunk_index_ = 0;
+
+  using PullChunk = std::function<std::optional<size_t>(AnyStream *stream, std::optional<int> n)>;
+  // We define every part of the dump query in a self contained function.
+  // Each functions is responsible of keeping track of its execution status.
+  // If a function did finish its execution, it should return number of results
+  // it streamed so we know how many rows should be pulled from the next
+  // function, otherwise std::nullopt is returned.
+  std::vector<PullChunk> pull_chunks_;
+
+  PullChunk CreateLabelIndicesPullChunk();
+  PullChunk CreateLabelPropertyIndicesPullChunk();
+  PullChunk CreateExistenceConstraintsPullChunk();
+  PullChunk CreateUniqueConstraintsPullChunk();
+  PullChunk CreateInternalIndexPullChunk();
+  PullChunk CreateVertexPullChunk();
+  PullChunk CreateEdgePullChunk();
+  PullChunk CreateDropInternalIndexPullChunk();
+  PullChunk CreateInternalIndexCleanupPullChunk();
+};
+}  // namespace memgraph::query::v2

src/query/v2/exceptions.hpp

@@ -0,0 +1,235 @@
+// 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.
+
+#pragma once
+
+#include "utils/exceptions.hpp"
+
+#include <fmt/format.h>
+
+namespace memgraph::query::v2 {
+
+/**
+ * @brief Base class of all query language related exceptions. All exceptions
+ * derived from this one will be interpreted as ClientError-s, i. e. if client
+ * executes same query again without making modifications to the database data,
+ * query will fail again.
+ */
+class QueryException : public utils::BasicException {
+  using utils::BasicException::BasicException;
+};
+
+class LexingException : public QueryException {
+ public:
+  using QueryException::QueryException;
+  LexingException() : QueryException("") {}
+};
+
+class SyntaxException : public QueryException {
+ public:
+  using QueryException::QueryException;
+  SyntaxException() : QueryException("") {}
+};
+
+// TODO: Figure out what information to put in exception.
+// Error reporting is tricky since we get stripped query and position of error
+// in original query is not same as position of error in stripped query. Most
+// correct approach would be to do semantic analysis with original query even
+// for already hashed queries, but that has obvious performance issues. Other
+// approach would be to report some of the semantic errors in runtime of the
+// query and only report line numbers of semantic errors (not position in the
+// line) if multiple line strings are not allowed by grammar. We could also
+// print whole line that contains error instead of specifying line number.
+class SemanticException : public QueryException {
+ public:
+  using QueryException::QueryException;
+  SemanticException() : QueryException("") {}
+};
+
+class UnboundVariableError : public SemanticException {
+ public:
+  explicit UnboundVariableError(const std::string &name) : SemanticException("Unbound variable: " + name + ".") {}
+};
+
+class RedeclareVariableError : public SemanticException {
+ public:
+  explicit RedeclareVariableError(const std::string &name) : SemanticException("Redeclaring variable: " + name + ".") {}
+};
+
+class TypeMismatchError : public SemanticException {
+ public:
+  TypeMismatchError(const std::string &name, const std::string &datum, const std::string &expected)
+      : SemanticException(fmt::format("Type mismatch: {} already defined as {}, expected {}.", name, datum, expected)) {
+  }
+};
+
+class UnprovidedParameterError : public QueryException {
+ public:
+  using QueryException::QueryException;
+};
+
+class ProfileInMulticommandTxException : public QueryException {
+ public:
+  using QueryException::QueryException;
+  ProfileInMulticommandTxException() : QueryException("PROFILE not allowed in multicommand transactions.") {}
+};
+
+class IndexInMulticommandTxException : public QueryException {
+ public:
+  using QueryException::QueryException;
+  IndexInMulticommandTxException() : QueryException("Index manipulation not allowed in multicommand transactions.") {}
+};
+
+class ConstraintInMulticommandTxException : public QueryException {
+ public:
+  using QueryException::QueryException;
+  ConstraintInMulticommandTxException()
+      : QueryException(
+            "Constraint manipulation not allowed in multicommand "
+            "transactions.") {}
+};
+
+class InfoInMulticommandTxException : public QueryException {
+ public:
+  using QueryException::QueryException;
+  InfoInMulticommandTxException() : QueryException("Info reporting not allowed in multicommand transactions.") {}
+};
+
+/**
+ * An exception for an illegal operation that can not be detected
+ * before the query starts executing over data.
+ */
+class QueryRuntimeException : public QueryException {
+ public:
+  using QueryException::QueryException;
+};
+
+// This one is inherited from BasicException and will be treated as
+// TransientError, i. e. client will be encouraged to retry execution because it
+// could succeed if executed again.
+class HintedAbortError : public utils::BasicException {
+ public:
+  using utils::BasicException::BasicException;
+  HintedAbortError()
+      : utils::BasicException(
+            "Transaction was asked to abort, most likely because it was "
+            "executing longer than time specified by "
+            "--query-execution-timeout-sec flag.") {}
+};
+
+class ExplicitTransactionUsageException : public QueryRuntimeException {
+ public:
+  using QueryRuntimeException::QueryRuntimeException;
+};
+
+/**
+ * An exception for serialization error
+ */
+class TransactionSerializationException : public QueryException {
+ public:
+  using QueryException::QueryException;
+  TransactionSerializationException()
+      : QueryException(
+            "Cannot resolve conflicting transactions. You can retry this transaction when the conflicting transaction "
+            "is finished") {}
+};
+
+class ReconstructionException : public QueryException {
+ public:
+  ReconstructionException()
+      : QueryException(
+            "Record invalid after WITH clause. Most likely deleted by a "
+            "preceeding DELETE.") {}
+};
+
+class RemoveAttachedVertexException : public QueryRuntimeException {
+ public:
+  RemoveAttachedVertexException()
+      : QueryRuntimeException(
+            "Failed to remove node because of it's existing "
+            "connections. Consider using DETACH DELETE.") {}
+};
+
+class UserModificationInMulticommandTxException : public QueryException {
+ public:
+  UserModificationInMulticommandTxException()
+      : QueryException("Authentication clause not allowed in multicommand transactions.") {}
+};
+
+class InvalidArgumentsException : public QueryException {
+ public:
+  InvalidArgumentsException(const std::string &argument_name, const std::string &message)
+      : QueryException(fmt::format("Invalid arguments sent: {} - {}", argument_name, message)) {}
+};
+
+class ReplicationModificationInMulticommandTxException : public QueryException {
+ public:
+  ReplicationModificationInMulticommandTxException()
+      : QueryException("Replication clause not allowed in multicommand transactions.") {}
+};
+
+class LockPathModificationInMulticommandTxException : public QueryException {
+ public:
+  LockPathModificationInMulticommandTxException()
+      : QueryException("Lock path query not allowed in multicommand transactions.") {}
+};
+
+class FreeMemoryModificationInMulticommandTxException : public QueryException {
+ public:
+  FreeMemoryModificationInMulticommandTxException()
+      : QueryException("Free memory query not allowed in multicommand transactions.") {}
+};
+
+class TriggerModificationInMulticommandTxException : public QueryException {
+ public:
+  TriggerModificationInMulticommandTxException()
+      : QueryException("Trigger queries not allowed in multicommand transactions.") {}
+};
+
+class StreamQueryInMulticommandTxException : public QueryException {
+ public:
+  StreamQueryInMulticommandTxException()
+      : QueryException("Stream queries are not allowed in multicommand transactions.") {}
+};
+
+class IsolationLevelModificationInMulticommandTxException : public QueryException {
+ public:
+  IsolationLevelModificationInMulticommandTxException()
+      : QueryException("Isolation level cannot be modified in multicommand transactions.") {}
+};
+
+class CreateSnapshotInMulticommandTxException final : public QueryException {
+ public:
+  CreateSnapshotInMulticommandTxException()
+      : QueryException("Snapshot cannot be created in multicommand transactions.") {}
+};
+
+class SettingConfigInMulticommandTxException final : public QueryException {
+ public:
+  SettingConfigInMulticommandTxException()
+      : QueryException("Settings cannot be changed or fetched in multicommand transactions.") {}
+};
+
+class VersionInfoInMulticommandTxException : public QueryException {
+ public:
+  VersionInfoInMulticommandTxException()
+      : QueryException("Version info query not allowed in multicommand transactions.") {}
+};
+
+/**
+ * An exception for an illegal operation that violates schema
+ */
+class SchemaViolationException : public QueryRuntimeException {
+ public:
+  using QueryRuntimeException::QueryRuntimeException;
+};
+
+}  // namespace memgraph::query::v2

src/query/v2/frontend/ast/ast_visitor.hpp

@@ -0,0 +1,134 @@
+// 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.
+
+#pragma once
+
+#include "utils/visitor.hpp"
+
+namespace memgraph::query::v2 {
+
+// Forward declares for Tree visitors.
+class CypherQuery;
+class SingleQuery;
+class CypherUnion;
+class NamedExpression;
+class Identifier;
+class PropertyLookup;
+class LabelsTest;
+class Aggregation;
+class Function;
+class Reduce;
+class Coalesce;
+class Extract;
+class All;
+class Single;
+class Any;
+class None;
+class ParameterLookup;
+class CallProcedure;
+class Create;
+class Match;
+class Return;
+class With;
+class Pattern;
+class NodeAtom;
+class EdgeAtom;
+class PrimitiveLiteral;
+class ListLiteral;
+class MapLiteral;
+class OrOperator;
+class XorOperator;
+class AndOperator;
+class NotOperator;
+class AdditionOperator;
+class SubtractionOperator;
+class MultiplicationOperator;
+class DivisionOperator;
+class ModOperator;
+class UnaryPlusOperator;
+class UnaryMinusOperator;
+class IsNullOperator;
+class NotEqualOperator;
+class EqualOperator;
+class LessOperator;
+class GreaterOperator;
+class LessEqualOperator;
+class GreaterEqualOperator;
+class InListOperator;
+class SubscriptOperator;
+class ListSlicingOperator;
+class IfOperator;
+class Delete;
+class Where;
+class SetProperty;
+class SetProperties;
+class SetLabels;
+class RemoveProperty;
+class RemoveLabels;
+class Merge;
+class Unwind;
+class AuthQuery;
+class ExplainQuery;
+class ProfileQuery;
+class IndexQuery;
+class InfoQuery;
+class ConstraintQuery;
+class RegexMatch;
+class DumpQuery;
+class ReplicationQuery;
+class LockPathQuery;
+class LoadCsv;
+class FreeMemoryQuery;
+class TriggerQuery;
+class IsolationLevelQuery;
+class CreateSnapshotQuery;
+class StreamQuery;
+class SettingQuery;
+class VersionQuery;
+class Foreach;
+class SchemaQuery;
+
+using TreeCompositeVisitor = utils::CompositeVisitor<
+    SingleQuery, CypherUnion, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator, AdditionOperator,
+    SubtractionOperator, MultiplicationOperator, DivisionOperator, ModOperator, NotEqualOperator, EqualOperator,
+    LessOperator, GreaterOperator, LessEqualOperator, GreaterEqualOperator, InListOperator, SubscriptOperator,
+    ListSlicingOperator, IfOperator, UnaryPlusOperator, UnaryMinusOperator, IsNullOperator, ListLiteral, MapLiteral,
+    PropertyLookup, LabelsTest, Aggregation, Function, Reduce, Coalesce, Extract, All, Single, Any, None, CallProcedure,
+    Create, Match, Return, With, Pattern, NodeAtom, EdgeAtom, Delete, Where, SetProperty, SetProperties, SetLabels,
+    RemoveProperty, RemoveLabels, Merge, Unwind, RegexMatch, LoadCsv, Foreach>;
+
+using TreeLeafVisitor = utils::LeafVisitor<Identifier, PrimitiveLiteral, ParameterLookup>;
+
+class HierarchicalTreeVisitor : public TreeCompositeVisitor, public TreeLeafVisitor {
+ public:
+  using TreeCompositeVisitor::PostVisit;
+  using TreeCompositeVisitor::PreVisit;
+  using TreeLeafVisitor::Visit;
+  using typename TreeLeafVisitor::ReturnType;
+};
+
+template <class TResult>
+class ExpressionVisitor
+    : public utils::Visitor<
+          TResult, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator, AdditionOperator,
+          SubtractionOperator, MultiplicationOperator, DivisionOperator, ModOperator, NotEqualOperator, EqualOperator,
+          LessOperator, GreaterOperator, LessEqualOperator, GreaterEqualOperator, InListOperator, SubscriptOperator,
+          ListSlicingOperator, IfOperator, UnaryPlusOperator, UnaryMinusOperator, IsNullOperator, ListLiteral,
+          MapLiteral, PropertyLookup, LabelsTest, Aggregation, Function, Reduce, Coalesce, Extract, All, Single, Any,
+          None, ParameterLookup, Identifier, PrimitiveLiteral, RegexMatch> {};
+
+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, SchemaQuery> {};
+
+}  // namespace memgraph::query::v2

src/query/v2/frontend/ast/cypher_main_visitor.hpp

@@ -0,0 +1,921 @@
+// 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.
+
+#pragma once
+
+#include <string>
+#include <unordered_set>
+#include <utility>
+
+#include <antlr4-runtime.h>
+
+#include "query/v2/frontend/ast/ast.hpp"
+#include "query/v2/frontend/opencypher/generated/MemgraphCypherBaseVisitor.h"
+#include "utils/exceptions.hpp"
+#include "utils/logging.hpp"
+
+namespace memgraph::query::v2::frontend {
+
+using antlropencypher::MemgraphCypher;
+
+struct ParsingContext {
+  bool is_query_cached = false;
+};
+
+class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
+ public:
+  explicit CypherMainVisitor(ParsingContext context, AstStorage *storage) : context_(context), storage_(storage) {}
+
+ private:
+  Expression *CreateBinaryOperatorByToken(size_t token, Expression *e1, Expression *e2) {
+    switch (token) {
+      case MemgraphCypher::OR:
+        return storage_->Create<OrOperator>(e1, e2);
+      case MemgraphCypher::XOR:
+        return storage_->Create<XorOperator>(e1, e2);
+      case MemgraphCypher::AND:
+        return storage_->Create<AndOperator>(e1, e2);
+      case MemgraphCypher::PLUS:
+        return storage_->Create<AdditionOperator>(e1, e2);
+      case MemgraphCypher::MINUS:
+        return storage_->Create<SubtractionOperator>(e1, e2);
+      case MemgraphCypher::ASTERISK:
+        return storage_->Create<MultiplicationOperator>(e1, e2);
+      case MemgraphCypher::SLASH:
+        return storage_->Create<DivisionOperator>(e1, e2);
+      case MemgraphCypher::PERCENT:
+        return storage_->Create<ModOperator>(e1, e2);
+      case MemgraphCypher::EQ:
+        return storage_->Create<EqualOperator>(e1, e2);
+      case MemgraphCypher::NEQ1:
+      case MemgraphCypher::NEQ2:
+        return storage_->Create<NotEqualOperator>(e1, e2);
+      case MemgraphCypher::LT:
+        return storage_->Create<LessOperator>(e1, e2);
+      case MemgraphCypher::GT:
+        return storage_->Create<GreaterOperator>(e1, e2);
+      case MemgraphCypher::LTE:
+        return storage_->Create<LessEqualOperator>(e1, e2);
+      case MemgraphCypher::GTE:
+        return storage_->Create<GreaterEqualOperator>(e1, e2);
+      default:
+        throw utils::NotYetImplemented("binary operator");
+    }
+  }
+
+  Expression *CreateUnaryOperatorByToken(size_t token, Expression *e) {
+    switch (token) {
+      case MemgraphCypher::NOT:
+        return storage_->Create<NotOperator>(e);
+      case MemgraphCypher::PLUS:
+        return storage_->Create<UnaryPlusOperator>(e);
+      case MemgraphCypher::MINUS:
+        return storage_->Create<UnaryMinusOperator>(e);
+      default:
+        throw utils::NotYetImplemented("unary operator");
+    }
+  }
+
+  auto ExtractOperators(std::vector<antlr4::tree::ParseTree *> &all_children,
+                        const std::vector<size_t> &allowed_operators) {
+    std::vector<size_t> operators;
+    for (auto *child : all_children) {
+      antlr4::tree::TerminalNode *operator_node = nullptr;
+      if ((operator_node = dynamic_cast<antlr4::tree::TerminalNode *>(child))) {
+        if (std::find(allowed_operators.begin(), allowed_operators.end(), operator_node->getSymbol()->getType()) !=
+            allowed_operators.end()) {
+          operators.push_back(operator_node->getSymbol()->getType());
+        }
+      }
+    }
+    return operators;
+  }
+
+  /**
+   * Convert opencypher's n-ary production to ast binary operators.
+   *
+   * @param _expressions Subexpressions of child for which we construct ast
+   * operators, for example expression6 if we want to create ast nodes for
+   * expression7.
+   */
+  template <typename TExpression>
+  Expression *LeftAssociativeOperatorExpression(std::vector<TExpression *> _expressions,
+                                                std::vector<antlr4::tree::ParseTree *> all_children,
+                                                const std::vector<size_t> &allowed_operators) {
+    DMG_ASSERT(_expressions.size(), "can't happen");
+    std::vector<Expression *> expressions;
+    auto operators = ExtractOperators(all_children, allowed_operators);
+
+    for (auto *expression : _expressions) {
+      expressions.push_back(std::any_cast<Expression *>(expression->accept(this)));
+    }
+
+    Expression *first_operand = expressions[0];
+    for (int i = 1; i < (int)expressions.size(); ++i) {
+      first_operand = CreateBinaryOperatorByToken(operators[i - 1], first_operand, expressions[i]);
+    }
+    return first_operand;
+  }
+
+  template <typename TExpression>
+  Expression *PrefixUnaryOperator(TExpression *_expression, std::vector<antlr4::tree::ParseTree *> all_children,
+                                  const std::vector<size_t> &allowed_operators) {
+    DMG_ASSERT(_expression, "can't happen");
+    auto operators = ExtractOperators(all_children, allowed_operators);
+
+    Expression *expression = std::any_cast<Expression *>(_expression->accept(this));
+    for (int i = (int)operators.size() - 1; i >= 0; --i) {
+      expression = CreateUnaryOperatorByToken(operators[i], expression);
+    }
+    return expression;
+  }
+
+  /**
+   * @return CypherQuery*
+   */
+  antlrcpp::Any visitCypherQuery(MemgraphCypher::CypherQueryContext *ctx) override;
+
+  /**
+   * @return IndexQuery*
+   */
+  antlrcpp::Any visitIndexQuery(MemgraphCypher::IndexQueryContext *ctx) override;
+
+  /**
+   * @return ExplainQuery*
+   */
+  antlrcpp::Any visitExplainQuery(MemgraphCypher::ExplainQueryContext *ctx) override;
+
+  /**
+   * @return ProfileQuery*
+   */
+  antlrcpp::Any visitProfileQuery(MemgraphCypher::ProfileQueryContext *ctx) override;
+
+  /**
+   * @return InfoQuery*
+   */
+  antlrcpp::Any visitInfoQuery(MemgraphCypher::InfoQueryContext *ctx) override;
+
+  /**
+   * @return Constraint
+   */
+  antlrcpp::Any visitConstraint(MemgraphCypher::ConstraintContext *ctx) override;
+
+  /**
+   * @return ConstraintQuery*
+   */
+  antlrcpp::Any visitConstraintQuery(MemgraphCypher::ConstraintQueryContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitAuthQuery(MemgraphCypher::AuthQueryContext *ctx) override;
+
+  /**
+   * @return DumpQuery*
+   */
+  antlrcpp::Any visitDumpQuery(MemgraphCypher::DumpQueryContext *ctx) override;
+
+  /**
+   * @return ReplicationQuery*
+   */
+  antlrcpp::Any visitReplicationQuery(MemgraphCypher::ReplicationQueryContext *ctx) override;
+
+  /**
+   * @return ReplicationQuery*
+   */
+  antlrcpp::Any visitSetReplicationRole(MemgraphCypher::SetReplicationRoleContext *ctx) override;
+
+  /**
+   * @return ReplicationQuery*
+   */
+  antlrcpp::Any visitShowReplicationRole(MemgraphCypher::ShowReplicationRoleContext *ctx) override;
+
+  /**
+   * @return ReplicationQuery*
+   */
+  antlrcpp::Any visitRegisterReplica(MemgraphCypher::RegisterReplicaContext *ctx) override;
+
+  /**
+   * @return ReplicationQuery*
+   */
+  antlrcpp::Any visitDropReplica(MemgraphCypher::DropReplicaContext *ctx) override;
+
+  /**
+   * @return ReplicationQuery*
+   */
+  antlrcpp::Any visitShowReplicas(MemgraphCypher::ShowReplicasContext *ctx) override;
+
+  /**
+   * @return LockPathQuery*
+   */
+  antlrcpp::Any visitLockPathQuery(MemgraphCypher::LockPathQueryContext *ctx) override;
+
+  /**
+   * @return LoadCsvQuery*
+   */
+  antlrcpp::Any visitLoadCsv(MemgraphCypher::LoadCsvContext *ctx) override;
+
+  /**
+   * @return FreeMemoryQuery*
+   */
+  antlrcpp::Any visitFreeMemoryQuery(MemgraphCypher::FreeMemoryQueryContext *ctx) override;
+
+  /**
+   * @return TriggerQuery*
+   */
+  antlrcpp::Any visitTriggerQuery(MemgraphCypher::TriggerQueryContext *ctx) override;
+
+  /**
+   * @return CreateTrigger*
+   */
+  antlrcpp::Any visitCreateTrigger(MemgraphCypher::CreateTriggerContext *ctx) override;
+
+  /**
+   * @return DropTrigger*
+   */
+  antlrcpp::Any visitDropTrigger(MemgraphCypher::DropTriggerContext *ctx) override;
+
+  /**
+   * @return ShowTriggers*
+   */
+  antlrcpp::Any visitShowTriggers(MemgraphCypher::ShowTriggersContext *ctx) override;
+
+  /**
+   * @return IsolationLevelQuery*
+   */
+  antlrcpp::Any visitIsolationLevelQuery(MemgraphCypher::IsolationLevelQueryContext *ctx) override;
+
+  /**
+   * @return CreateSnapshotQuery*
+   */
+  antlrcpp::Any visitCreateSnapshotQuery(MemgraphCypher::CreateSnapshotQueryContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitStreamQuery(MemgraphCypher::StreamQueryContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitCreateStream(MemgraphCypher::CreateStreamContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitConfigKeyValuePair(MemgraphCypher::ConfigKeyValuePairContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitConfigMap(MemgraphCypher::ConfigMapContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitKafkaCreateStream(MemgraphCypher::KafkaCreateStreamContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitKafkaCreateStreamConfig(MemgraphCypher::KafkaCreateStreamConfigContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitPulsarCreateStreamConfig(MemgraphCypher::PulsarCreateStreamConfigContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitPulsarCreateStream(MemgraphCypher::PulsarCreateStreamContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitCommonCreateStreamConfig(MemgraphCypher::CommonCreateStreamConfigContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitDropStream(MemgraphCypher::DropStreamContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitStartStream(MemgraphCypher::StartStreamContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitStartAllStreams(MemgraphCypher::StartAllStreamsContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitStopStream(MemgraphCypher::StopStreamContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitStopAllStreams(MemgraphCypher::StopAllStreamsContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitShowStreams(MemgraphCypher::ShowStreamsContext *ctx) override;
+
+  /**
+   * @return StreamQuery*
+   */
+  antlrcpp::Any visitCheckStream(MemgraphCypher::CheckStreamContext *ctx) override;
+
+  /**
+   * @return SettingQuery*
+   */
+  antlrcpp::Any visitSettingQuery(MemgraphCypher::SettingQueryContext *ctx) override;
+
+  /**
+   * @return SetSetting*
+   */
+  antlrcpp::Any visitSetSetting(MemgraphCypher::SetSettingContext *ctx) override;
+
+  /**
+   * @return ShowSetting*
+   */
+  antlrcpp::Any visitShowSetting(MemgraphCypher::ShowSettingContext *ctx) override;
+
+  /**
+   * @return ShowSettings*
+   */
+  antlrcpp::Any visitShowSettings(MemgraphCypher::ShowSettingsContext *ctx) override;
+
+  /**
+   * @return VersionQuery*
+   */
+  antlrcpp::Any visitVersionQuery(MemgraphCypher::VersionQueryContext *ctx) override;
+
+  /**
+   * @return CypherUnion*
+   */
+  antlrcpp::Any visitCypherUnion(MemgraphCypher::CypherUnionContext *ctx) override;
+
+  /**
+   * @return SingleQuery*
+   */
+  antlrcpp::Any visitSingleQuery(MemgraphCypher::SingleQueryContext *ctx) override;
+
+  /**
+   * @return Clause* or vector<Clause*>!!!
+   */
+  antlrcpp::Any visitClause(MemgraphCypher::ClauseContext *ctx) override;
+
+  /**
+   * @return Match*
+   */
+  antlrcpp::Any visitCypherMatch(MemgraphCypher::CypherMatchContext *ctx) override;
+
+  /**
+   * @return Create*
+   */
+  antlrcpp::Any visitCreate(MemgraphCypher::CreateContext *ctx) override;
+
+  /**
+   * @return CallProcedure*
+   */
+  antlrcpp::Any visitCallProcedure(MemgraphCypher::CallProcedureContext *ctx) override;
+
+  /**
+   * @return std::string
+   */
+  antlrcpp::Any visitUserOrRoleName(MemgraphCypher::UserOrRoleNameContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitCreateRole(MemgraphCypher::CreateRoleContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitDropRole(MemgraphCypher::DropRoleContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitShowRoles(MemgraphCypher::ShowRolesContext *ctx) override;
+
+  /**
+   * @return IndexQuery*
+   */
+  antlrcpp::Any visitCreateIndex(MemgraphCypher::CreateIndexContext *ctx) override;
+
+  /**
+   * @return DropIndex*
+   */
+  antlrcpp::Any visitDropIndex(MemgraphCypher::DropIndexContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitCreateUser(MemgraphCypher::CreateUserContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitSetPassword(MemgraphCypher::SetPasswordContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitDropUser(MemgraphCypher::DropUserContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitShowUsers(MemgraphCypher::ShowUsersContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitSetRole(MemgraphCypher::SetRoleContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitClearRole(MemgraphCypher::ClearRoleContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitGrantPrivilege(MemgraphCypher::GrantPrivilegeContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitDenyPrivilege(MemgraphCypher::DenyPrivilegeContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitRevokePrivilege(MemgraphCypher::RevokePrivilegeContext *ctx) override;
+
+  /**
+   * @return AuthQuery::Privilege
+   */
+  antlrcpp::Any visitPrivilege(MemgraphCypher::PrivilegeContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitShowPrivileges(MemgraphCypher::ShowPrivilegesContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitShowRoleForUser(MemgraphCypher::ShowRoleForUserContext *ctx) override;
+
+  /**
+   * @return AuthQuery*
+   */
+  antlrcpp::Any visitShowUsersForRole(MemgraphCypher::ShowUsersForRoleContext *ctx) override;
+
+  /**
+   * @return Return*
+   */
+  antlrcpp::Any visitCypherReturn(MemgraphCypher::CypherReturnContext *ctx) override;
+
+  /**
+   * @return Return*
+   */
+  antlrcpp::Any visitReturnBody(MemgraphCypher::ReturnBodyContext *ctx) override;
+
+  /**
+   * @return pair<bool, vector<NamedExpression*>> first member is true if
+   * asterisk was found in return
+   * expressions.
+   */
+  antlrcpp::Any visitReturnItems(MemgraphCypher::ReturnItemsContext *ctx) override;
+
+  /**
+   * @return vector<NamedExpression*>
+   */
+  antlrcpp::Any visitReturnItem(MemgraphCypher::ReturnItemContext *ctx) override;
+
+  /**
+   * @return vector<SortItem>
+   */
+  antlrcpp::Any visitOrder(MemgraphCypher::OrderContext *ctx) override;
+
+  /**
+   * @return SortItem
+   */
+  antlrcpp::Any visitSortItem(MemgraphCypher::SortItemContext *ctx) override;
+
+  /**
+   * @return NodeAtom*
+   */
+  antlrcpp::Any visitNodePattern(MemgraphCypher::NodePatternContext *ctx) override;
+
+  /**
+   * @return vector<LabelIx>
+   */
+  antlrcpp::Any visitNodeLabels(MemgraphCypher::NodeLabelsContext *ctx) override;
+
+  /**
+   * @return unordered_map<PropertyIx, Expression*>
+   */
+  antlrcpp::Any visitProperties(MemgraphCypher::PropertiesContext *ctx) override;
+
+  /**
+   * @return map<std::string, Expression*>
+   */
+  antlrcpp::Any visitMapLiteral(MemgraphCypher::MapLiteralContext *ctx) override;
+
+  /**
+   * @return vector<Expression*>
+   */
+  antlrcpp::Any visitListLiteral(MemgraphCypher::ListLiteralContext *ctx) override;
+
+  /**
+   * @return PropertyIx
+   */
+  antlrcpp::Any visitPropertyKeyName(MemgraphCypher::PropertyKeyNameContext *ctx) override;
+
+  /**
+   * @return string
+   */
+  antlrcpp::Any visitSymbolicName(MemgraphCypher::SymbolicNameContext *ctx) override;
+
+  /**
+   * @return vector<Pattern*>
+   */
+  antlrcpp::Any visitPattern(MemgraphCypher::PatternContext *ctx) override;
+
+  /**
+   * @return Pattern*
+   */
+  antlrcpp::Any visitPatternPart(MemgraphCypher::PatternPartContext *ctx) override;
+
+  /**
+   * @return Pattern*
+   */
+  antlrcpp::Any visitPatternElement(MemgraphCypher::PatternElementContext *ctx) override;
+
+  /**
+   * @return vector<pair<EdgeAtom*, NodeAtom*>>
+   */
+  antlrcpp::Any visitPatternElementChain(MemgraphCypher::PatternElementChainContext *ctx) override;
+
+  /**
+   *@return EdgeAtom*
+   */
+  antlrcpp::Any visitRelationshipPattern(MemgraphCypher::RelationshipPatternContext *ctx) override;
+
+  /**
+   * This should never be called. Everything is done directly in
+   * visitRelationshipPattern.
+   */
+  antlrcpp::Any visitRelationshipDetail(MemgraphCypher::RelationshipDetailContext *ctx) override;
+
+  /**
+   * This should never be called. Everything is done directly in
+   * visitRelationshipPattern.
+   */
+  antlrcpp::Any visitRelationshipLambda(MemgraphCypher::RelationshipLambdaContext *ctx) override;
+
+  /**
+   * @return vector<EdgeTypeIx>
+   */
+  antlrcpp::Any visitRelationshipTypes(MemgraphCypher::RelationshipTypesContext *ctx) override;
+
+  /**
+   * @return std::tuple<EdgeAtom::Type, int64_t, int64_t>.
+   */
+  antlrcpp::Any visitVariableExpansion(MemgraphCypher::VariableExpansionContext *ctx) override;
+
+  /**
+   * Top level expression, does nothing.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression(MemgraphCypher::ExpressionContext *ctx) override;
+
+  /**
+   * OR.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression12(MemgraphCypher::Expression12Context *ctx) override;
+
+  /**
+   * XOR.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression11(MemgraphCypher::Expression11Context *ctx) override;
+
+  /**
+   * AND.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression10(MemgraphCypher::Expression10Context *ctx) override;
+
+  /**
+   * NOT.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression9(MemgraphCypher::Expression9Context *ctx) override;
+
+  /**
+   * Comparisons.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression8(MemgraphCypher::Expression8Context *ctx) override;
+
+  /**
+   * Never call this. Everything related to generating code for comparison
+   * operators should be done in visitExpression8.
+   */
+  antlrcpp::Any visitPartialComparisonExpression(MemgraphCypher::PartialComparisonExpressionContext *ctx) override;
+
+  /**
+   * Addition and subtraction.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression7(MemgraphCypher::Expression7Context *ctx) override;
+
+  /**
+   * Multiplication, division, modding.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression6(MemgraphCypher::Expression6Context *ctx) override;
+
+  /**
+   * Power.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression5(MemgraphCypher::Expression5Context *ctx) override;
+
+  /**
+   * Unary minus and plus.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression4(MemgraphCypher::Expression4Context *ctx) override;
+
+  /**
+   * IS NULL, IS NOT NULL, STARTS WITH, END WITH, =~, ...
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression3a(MemgraphCypher::Expression3aContext *ctx) override;
+
+  /**
+   * Does nothing, everything is done in visitExpression3a.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitStringAndNullOperators(MemgraphCypher::StringAndNullOperatorsContext *ctx) override;
+
+  /**
+   * List indexing and slicing.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression3b(MemgraphCypher::Expression3bContext *ctx) override;
+
+  /**
+   * Does nothing, everything is done in visitExpression3b.
+   */
+  antlrcpp::Any visitListIndexingOrSlicing(MemgraphCypher::ListIndexingOrSlicingContext *ctx) override;
+
+  /**
+   * Node labels test.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression2a(MemgraphCypher::Expression2aContext *ctx) override;
+
+  /**
+   * Property lookup.
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitExpression2b(MemgraphCypher::Expression2bContext *ctx) override;
+
+  /**
+   * Literals, params, list comprehension...
+   *
+   * @return Expression*
+   */
+  antlrcpp::Any visitAtom(MemgraphCypher::AtomContext *ctx) override;
+
+  /**
+   * @return ParameterLookup*
+   */
+  antlrcpp::Any visitParameter(MemgraphCypher::ParameterContext *ctx) override;
+
+  /**
+   * @return Expression*
+   */
+  antlrcpp::Any visitParenthesizedExpression(MemgraphCypher::ParenthesizedExpressionContext *ctx) override;
+
+  /**
+   * @return Expression*
+   */
+  antlrcpp::Any visitFunctionInvocation(MemgraphCypher::FunctionInvocationContext *ctx) override;
+
+  /**
+   * @return string - uppercased
+   */
+  antlrcpp::Any visitFunctionName(MemgraphCypher::FunctionNameContext *ctx) override;
+
+  /**
+   * @return Expression*
+   */
+  antlrcpp::Any visitLiteral(MemgraphCypher::LiteralContext *ctx) override;
+
+  /**
+   * Convert escaped string from a query to unescaped utf8 string.
+   *
+   * @return string
+   */
+  antlrcpp::Any visitStringLiteral(const std::string &escaped);
+
+  /**
+   * @return bool
+   */
+  antlrcpp::Any visitBooleanLiteral(MemgraphCypher::BooleanLiteralContext *ctx) override;
+
+  /**
+   * @return TypedValue with either double or int
+   */
+  antlrcpp::Any visitNumberLiteral(MemgraphCypher::NumberLiteralContext *ctx) override;
+
+  /**
+   * @return int64_t
+   */
+  antlrcpp::Any visitIntegerLiteral(MemgraphCypher::IntegerLiteralContext *ctx) override;
+
+  /**
+   * @return double
+   */
+  antlrcpp::Any visitDoubleLiteral(MemgraphCypher::DoubleLiteralContext *ctx) override;
+
+  /**
+   * @return Delete*
+   */
+  antlrcpp::Any visitCypherDelete(MemgraphCypher::CypherDeleteContext *ctx) override;
+
+  /**
+   * @return Where*
+   */
+  antlrcpp::Any visitWhere(MemgraphCypher::WhereContext *ctx) override;
+
+  /**
+   * return vector<Clause*>
+   */
+  antlrcpp::Any visitSet(MemgraphCypher::SetContext *ctx) override;
+
+  /**
+   * @return Clause*
+   */
+  antlrcpp::Any visitSetItem(MemgraphCypher::SetItemContext *ctx) override;
+
+  /**
+   * return vector<Clause*>
+   */
+  antlrcpp::Any visitRemove(MemgraphCypher::RemoveContext *ctx) override;
+
+  /**
+   * @return Clause*
+   */
+  antlrcpp::Any visitRemoveItem(MemgraphCypher::RemoveItemContext *ctx) override;
+
+  /**
+   * @return PropertyLookup*
+   */
+  antlrcpp::Any visitPropertyExpression(MemgraphCypher::PropertyExpressionContext *ctx) override;
+
+  /**
+   * @return IfOperator*
+   */
+  antlrcpp::Any visitCaseExpression(MemgraphCypher::CaseExpressionContext *ctx) override;
+
+  /**
+   * Never call this. Ast generation for this production is done in
+   * @c visitCaseExpression.
+   */
+  antlrcpp::Any visitCaseAlternatives(MemgraphCypher::CaseAlternativesContext *ctx) override;
+
+  /**
+   * @return With*
+   */
+  antlrcpp::Any visitWith(MemgraphCypher::WithContext *ctx) override;
+
+  /**
+   * @return Merge*
+   */
+  antlrcpp::Any visitMerge(MemgraphCypher::MergeContext *ctx) override;
+
+  /**
+   * @return Unwind*
+   */
+  antlrcpp::Any visitUnwind(MemgraphCypher::UnwindContext *ctx) override;
+
+  /**
+   * Never call this. Ast generation for these expressions should be done by
+   * explicitly visiting the members of @c FilterExpressionContext.
+   */
+  antlrcpp::Any visitFilterExpression(MemgraphCypher::FilterExpressionContext *) override;
+
+  /**
+   * @return Foreach*
+   */
+  antlrcpp::Any visitForeach(MemgraphCypher::ForeachContext *ctx) override;
+
+  /**
+   * @return Schema*
+   */
+  antlrcpp::Any visitPropertyType(MemgraphCypher::PropertyTypeContext *ctx) override;
+
+  /**
+   * @return Schema*
+   */
+  antlrcpp::Any visitSchemaPropertyMap(MemgraphCypher::SchemaPropertyMapContext *ctx) override;
+
+  /**
+   * @return Schema*
+   */
+  antlrcpp::Any visitSchemaQuery(MemgraphCypher::SchemaQueryContext *ctx) override;
+
+  /**
+   * @return Schema*
+   */
+  antlrcpp::Any visitShowSchema(MemgraphCypher::ShowSchemaContext *ctx) override;
+
+  /**
+   * @return Schema*
+   */
+  antlrcpp::Any visitShowSchemas(MemgraphCypher::ShowSchemasContext *ctx) override;
+
+  /**
+   * @return Schema*
+   */
+  antlrcpp::Any visitCreateSchema(MemgraphCypher::CreateSchemaContext *ctx) override;
+
+  /**
+   * @return Schema*
+   */
+  antlrcpp::Any visitDropSchema(MemgraphCypher::DropSchemaContext *ctx) override;
+
+ public:
+  Query *query() { return query_; }
+  const static std::string kAnonPrefix;
+
+  struct QueryInfo {
+    bool is_cacheable{true};
+    bool has_load_csv{false};
+  };
+
+  const auto &GetQueryInfo() const { return query_info_; }
+
+ private:
+  LabelIx AddLabel(const std::string &name);
+  PropertyIx AddProperty(const std::string &name);
+  EdgeTypeIx AddEdgeType(const std::string &name);
+
+  ParsingContext context_;
+  AstStorage *storage_;
+
+  std::unordered_map<uint8_t, std::variant<Expression *, std::string, std::vector<std::string>,
+                                           std::unordered_map<Expression *, Expression *>>>
+      memory_;
+  // Set of identifiers from queries.
+  std::unordered_set<std::string> users_identifiers;
+  // Identifiers that user didn't name.
+  std::vector<Identifier **> anonymous_identifiers;
+  Query *query_ = nullptr;
+  // All return items which are not variables must be aliased in with.
+  // We use this variable in visitReturnItem to check if we are in with or
+  // return.
+  bool in_with_ = false;
+
+  QueryInfo query_info_;
+};
+}  // namespace memgraph::query::v2::frontend

src/query/v2/frontend/ast/pretty_print.cpp

@@ -0,0 +1,311 @@
+// 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 "query/v2/frontend/ast/pretty_print.hpp"
+
+#include <type_traits>
+
+#include "query/v2/frontend/ast/ast.hpp"
+#include "utils/algorithm.hpp"
+#include "utils/string.hpp"
+
+namespace memgraph::query::v2 {
+
+namespace {
+
+class ExpressionPrettyPrinter : public ExpressionVisitor<void> {
+ public:
+  explicit ExpressionPrettyPrinter(std::ostream *out);
+
+  // Unary operators
+  void Visit(NotOperator &op) override;
+  void Visit(UnaryPlusOperator &op) override;
+  void Visit(UnaryMinusOperator &op) override;
+  void Visit(IsNullOperator &op) override;
+
+  // Binary operators
+  void Visit(OrOperator &op) override;
+  void Visit(XorOperator &op) override;
+  void Visit(AndOperator &op) override;
+  void Visit(AdditionOperator &op) override;
+  void Visit(SubtractionOperator &op) override;
+  void Visit(MultiplicationOperator &op) override;
+  void Visit(DivisionOperator &op) override;
+  void Visit(ModOperator &op) override;
+  void Visit(NotEqualOperator &op) override;
+  void Visit(EqualOperator &op) override;
+  void Visit(LessOperator &op) override;
+  void Visit(GreaterOperator &op) override;
+  void Visit(LessEqualOperator &op) override;
+  void Visit(GreaterEqualOperator &op) override;
+  void Visit(InListOperator &op) override;
+  void Visit(SubscriptOperator &op) override;
+
+  // Other
+  void Visit(ListSlicingOperator &op) override;
+  void Visit(IfOperator &op) override;
+  void Visit(ListLiteral &op) override;
+  void Visit(MapLiteral &op) override;
+  void Visit(LabelsTest &op) override;
+  void Visit(Aggregation &op) override;
+  void Visit(Function &op) override;
+  void Visit(Reduce &op) override;
+  void Visit(Coalesce &op) override;
+  void Visit(Extract &op) override;
+  void Visit(All &op) override;
+  void Visit(Single &op) override;
+  void Visit(Any &op) override;
+  void Visit(None &op) override;
+  void Visit(Identifier &op) override;
+  void Visit(PrimitiveLiteral &op) override;
+  void Visit(PropertyLookup &op) override;
+  void Visit(ParameterLookup &op) override;
+  void Visit(NamedExpression &op) override;
+  void Visit(RegexMatch &op) override;
+
+ private:
+  std::ostream *out_;
+};
+
+// Declare all of the different `PrintObject` overloads upfront since they're
+// mutually recursive. Without this, overload resolution depends on the ordering
+// of the overloads within the source, which is quite fragile.
+
+template <typename T>
+void PrintObject(std::ostream *out, const T &arg);
+
+void PrintObject(std::ostream *out, const std::string &str);
+
+void PrintObject(std::ostream *out, Aggregation::Op op);
+
+void PrintObject(std::ostream *out, Expression *expr);
+
+void PrintObject(std::ostream *out, Identifier *expr);
+
+void PrintObject(std::ostream *out, const storage::v3::PropertyValue &value);
+
+template <typename T>
+void PrintObject(std::ostream *out, const std::vector<T> &vec);
+
+template <typename K, typename V>
+void PrintObject(std::ostream *out, const std::map<K, V> &map);
+
+template <typename T>
+void PrintObject(std::ostream *out, const T &arg) {
+  static_assert(!std::is_convertible<T, Expression *>::value,
+                "This overload shouldn't be called with pointers convertible "
+                "to Expression *. This means your other PrintObject overloads aren't "
+                "being called for certain AST nodes when they should (or perhaps such "
+                "overloads don't exist yet).");
+  *out << arg;
+}
+
+void PrintObject(std::ostream *out, const std::string &str) { *out << utils::Escape(str); }
+
+void PrintObject(std::ostream *out, Aggregation::Op op) { *out << Aggregation::OpToString(op); }
+
+void PrintObject(std::ostream *out, Expression *expr) {
+  if (expr) {
+    ExpressionPrettyPrinter printer{out};
+    expr->Accept(printer);
+  } else {
+    *out << "<null>";
+  }
+}
+
+void PrintObject(std::ostream *out, Identifier *expr) { PrintObject(out, static_cast<Expression *>(expr)); }
+
+void PrintObject(std::ostream *out, const storage::v3::PropertyValue &value) {
+  switch (value.type()) {
+    case storage::v3::PropertyValue::Type::Null:
+      *out << "null";
+      break;
+
+    case storage::v3::PropertyValue::Type::String:
+      PrintObject(out, value.ValueString());
+      break;
+
+    case storage::v3::PropertyValue::Type::Bool:
+      *out << (value.ValueBool() ? "true" : "false");
+      break;
+
+    case storage::v3::PropertyValue::Type::Int:
+      PrintObject(out, value.ValueInt());
+      break;
+
+    case storage::v3::PropertyValue::Type::Double:
+      PrintObject(out, value.ValueDouble());
+      break;
+
+    case storage::v3::PropertyValue::Type::List:
+      PrintObject(out, value.ValueList());
+      break;
+
+    case storage::v3::PropertyValue::Type::Map:
+      PrintObject(out, value.ValueMap());
+      break;
+    case storage::v3::PropertyValue::Type::TemporalData:
+      PrintObject(out, value.ValueTemporalData());
+      break;
+  }
+}
+
+template <typename T>
+void PrintObject(std::ostream *out, const std::vector<T> &vec) {
+  *out << "[";
+  utils::PrintIterable(*out, vec, ", ", [](auto &stream, const auto &item) { PrintObject(&stream, item); });
+  *out << "]";
+}
+
+template <typename K, typename V>
+void PrintObject(std::ostream *out, const std::map<K, V> &map) {
+  *out << "{";
+  utils::PrintIterable(*out, map, ", ", [](auto &stream, const auto &item) {
+    PrintObject(&stream, item.first);
+    stream << ": ";
+    PrintObject(&stream, item.second);
+  });
+  *out << "}";
+}
+
+template <typename T>
+void PrintOperatorArgs(std::ostream *out, const T &arg) {
+  *out << " ";
+  PrintObject(out, arg);
+  *out << ")";
+}
+
+template <typename T, typename... Ts>
+void PrintOperatorArgs(std::ostream *out, const T &arg, const Ts &...args) {
+  *out << " ";
+  PrintObject(out, arg);
+  PrintOperatorArgs(out, args...);
+}
+
+template <typename... Ts>
+void PrintOperator(std::ostream *out, const std::string &name, const Ts &...args) {
+  *out << "(" << name;
+  PrintOperatorArgs(out, args...);
+}
+
+ExpressionPrettyPrinter::ExpressionPrettyPrinter(std::ostream *out) : out_(out) {}
+
+#define UNARY_OPERATOR_VISIT(OP_NODE, OP_STR) \
+  void ExpressionPrettyPrinter::Visit(OP_NODE &op) { PrintOperator(out_, OP_STR, op.expression_); }
+
+UNARY_OPERATOR_VISIT(NotOperator, "Not");
+UNARY_OPERATOR_VISIT(UnaryPlusOperator, "+");
+UNARY_OPERATOR_VISIT(UnaryMinusOperator, "-");
+UNARY_OPERATOR_VISIT(IsNullOperator, "IsNull");
+
+#undef UNARY_OPERATOR_VISIT
+
+#define BINARY_OPERATOR_VISIT(OP_NODE, OP_STR) \
+  void ExpressionPrettyPrinter::Visit(OP_NODE &op) { PrintOperator(out_, OP_STR, op.expression1_, op.expression2_); }
+
+BINARY_OPERATOR_VISIT(OrOperator, "Or");
+BINARY_OPERATOR_VISIT(XorOperator, "Xor");
+BINARY_OPERATOR_VISIT(AndOperator, "And");
+BINARY_OPERATOR_VISIT(AdditionOperator, "+");
+BINARY_OPERATOR_VISIT(SubtractionOperator, "-");
+BINARY_OPERATOR_VISIT(MultiplicationOperator, "*");
+BINARY_OPERATOR_VISIT(DivisionOperator, "/");
+BINARY_OPERATOR_VISIT(ModOperator, "%");
+BINARY_OPERATOR_VISIT(NotEqualOperator, "!=");
+BINARY_OPERATOR_VISIT(EqualOperator, "==");
+BINARY_OPERATOR_VISIT(LessOperator, "<");
+BINARY_OPERATOR_VISIT(GreaterOperator, ">");
+BINARY_OPERATOR_VISIT(LessEqualOperator, "<=");
+BINARY_OPERATOR_VISIT(GreaterEqualOperator, ">=");
+BINARY_OPERATOR_VISIT(InListOperator, "In");
+BINARY_OPERATOR_VISIT(SubscriptOperator, "Subscript");
+
+#undef BINARY_OPERATOR_VISIT
+
+void ExpressionPrettyPrinter::Visit(ListSlicingOperator &op) {
+  PrintOperator(out_, "ListSlicing", op.list_, op.lower_bound_, op.upper_bound_);
+}
+
+void ExpressionPrettyPrinter::Visit(IfOperator &op) {
+  PrintOperator(out_, "If", op.condition_, op.then_expression_, op.else_expression_);
+}
+
+void ExpressionPrettyPrinter::Visit(ListLiteral &op) { PrintOperator(out_, "ListLiteral", op.elements_); }
+
+void ExpressionPrettyPrinter::Visit(MapLiteral &op) {
+  std::map<std::string, Expression *> map;
+  for (const auto &kv : op.elements_) {
+    map[kv.first.name] = kv.second;
+  }
+  PrintObject(out_, map);
+}
+
+void ExpressionPrettyPrinter::Visit(LabelsTest &op) { PrintOperator(out_, "LabelsTest", op.expression_); }
+
+void ExpressionPrettyPrinter::Visit(Aggregation &op) { PrintOperator(out_, "Aggregation", op.op_); }
+
+void ExpressionPrettyPrinter::Visit(Function &op) { PrintOperator(out_, "Function", op.function_name_, op.arguments_); }
+
+void ExpressionPrettyPrinter::Visit(Reduce &op) {
+  PrintOperator(out_, "Reduce", op.accumulator_, op.initializer_, op.identifier_, op.list_, op.expression_);
+}
+
+void ExpressionPrettyPrinter::Visit(Coalesce &op) { PrintOperator(out_, "Coalesce", op.expressions_); }
+
+void ExpressionPrettyPrinter::Visit(Extract &op) {
+  PrintOperator(out_, "Extract", op.identifier_, op.list_, op.expression_);
+}
+
+void ExpressionPrettyPrinter::Visit(All &op) {
+  PrintOperator(out_, "All", op.identifier_, op.list_expression_, op.where_->expression_);
+}
+
+void ExpressionPrettyPrinter::Visit(Single &op) {
+  PrintOperator(out_, "Single", op.identifier_, op.list_expression_, op.where_->expression_);
+}
+
+void ExpressionPrettyPrinter::Visit(Any &op) {
+  PrintOperator(out_, "Any", op.identifier_, op.list_expression_, op.where_->expression_);
+}
+
+void ExpressionPrettyPrinter::Visit(None &op) {
+  PrintOperator(out_, "None", op.identifier_, op.list_expression_, op.where_->expression_);
+}
+
+void ExpressionPrettyPrinter::Visit(Identifier &op) { PrintOperator(out_, "Identifier", op.name_); }
+
+void ExpressionPrettyPrinter::Visit(PrimitiveLiteral &op) { PrintObject(out_, op.value_); }
+
+void ExpressionPrettyPrinter::Visit(PropertyLookup &op) {
+  PrintOperator(out_, "PropertyLookup", op.expression_, op.property_.name);
+}
+
+void ExpressionPrettyPrinter::Visit(ParameterLookup &op) { PrintOperator(out_, "ParameterLookup", op.token_position_); }
+
+void ExpressionPrettyPrinter::Visit(NamedExpression &op) {
+  PrintOperator(out_, "NamedExpression", op.name_, op.expression_);
+}
+
+void ExpressionPrettyPrinter::Visit(RegexMatch &op) { PrintOperator(out_, "=~", op.string_expr_, op.regex_); }
+
+}  // namespace
+
+void PrintExpression(Expression *expr, std::ostream *out) {
+  ExpressionPrettyPrinter printer{out};
+  expr->Accept(printer);
+}
+
+void PrintExpression(NamedExpression *expr, std::ostream *out) {
+  ExpressionPrettyPrinter printer{out};
+  expr->Accept(printer);
+}
+
+}  // namespace memgraph::query::v2

src/query/v2/frontend/ast/pretty_print.hpp

@@ -0,0 +1,23 @@
+// 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.
+
+#pragma once
+
+#include <iostream>
+
+#include "query/v2/frontend/ast/ast.hpp"
+
+namespace memgraph::query::v2 {
+
+void PrintExpression(Expression *expr, std::ostream *out);
+void PrintExpression(NamedExpression *expr, std::ostream *out);
+
+}  // namespace memgraph::query::v2

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

@@ -0,0 +1,391 @@
+/*
+ * Copyright (c) 2015-2016 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * 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.
+ */
+
+parser grammar Cypher;
+
+options { tokenVocab=CypherLexer; }
+
+cypher : statement ';'? EOF ;
+
+statement : query ;
+
+query : cypherQuery
+      | indexQuery
+      | explainQuery
+      | profileQuery
+      | infoQuery
+      | constraintQuery
+      ;
+
+constraintQuery : ( CREATE | DROP ) CONSTRAINT ON constraint ;
+
+constraint : '(' nodeName=variable ':' labelName ')' ASSERT EXISTS '(' constraintPropertyList ')'
+           | '(' nodeName=variable ':' labelName ')' ASSERT constraintPropertyList IS UNIQUE
+           | '(' nodeName=variable ':' labelName ')' ASSERT '(' constraintPropertyList ')' IS NODE KEY
+           ;
+
+constraintPropertyList : variable propertyLookup ( ',' variable propertyLookup )* ;
+
+storageInfo : STORAGE INFO ;
+
+indexInfo : INDEX INFO ;
+
+constraintInfo : CONSTRAINT INFO ;
+
+infoQuery : SHOW ( storageInfo | indexInfo | constraintInfo ) ;
+
+explainQuery : EXPLAIN cypherQuery ;
+
+profileQuery : PROFILE cypherQuery ;
+
+cypherQuery : singleQuery ( cypherUnion )* ( queryMemoryLimit )? ;
+
+indexQuery : createIndex | dropIndex;
+
+singleQuery : clause ( clause )* ;
+
+cypherUnion : ( UNION ALL singleQuery )
+            | ( UNION singleQuery )
+            ;
+
+clause : cypherMatch
+       | unwind
+       | merge
+       | create
+       | set
+       | cypherDelete
+       | remove
+       | with
+       | cypherReturn
+       | callProcedure
+       ;
+
+cypherMatch : OPTIONAL? MATCH pattern where? ;
+
+unwind : UNWIND expression AS variable ;
+
+merge : MERGE patternPart ( mergeAction )* ;
+
+mergeAction : ( ON MATCH set )
+            | ( ON CREATE set )
+            ;
+
+create : CREATE pattern ;
+
+set : SET setItem ( ',' setItem )* ;
+
+setItem : ( propertyExpression '=' expression )
+        | ( variable '=' expression )
+        | ( variable '+=' expression )
+        | ( variable nodeLabels )
+        ;
+
+cypherDelete : DETACH? DELETE expression ( ',' expression )* ;
+
+remove : REMOVE removeItem ( ',' removeItem )* ;
+
+removeItem : ( variable nodeLabels )
+           | propertyExpression
+           ;
+
+with : WITH ( DISTINCT )? returnBody ( where )? ;
+
+cypherReturn : RETURN ( DISTINCT )? returnBody ;
+
+callProcedure : CALL procedureName '(' ( expression ( ',' expression )* )? ')' ( procedureMemoryLimit )? ( yieldProcedureResults )? ;
+
+procedureName : symbolicName ( '.' symbolicName )* ;
+
+yieldProcedureResults : YIELD ( '*' | ( procedureResult ( ',' procedureResult )* ) ) ;
+
+memoryLimit : MEMORY ( UNLIMITED | LIMIT literal ( MB | KB ) ) ;
+
+queryMemoryLimit : QUERY memoryLimit ;
+
+procedureMemoryLimit : PROCEDURE memoryLimit ;
+
+procedureResult : ( variable AS variable ) | variable ;
+
+returnBody : returnItems ( order )? ( skip )? ( limit )? ;
+
+returnItems : ( '*' ( ',' returnItem )* )
+            | ( returnItem ( ',' returnItem )* )
+            ;
+
+returnItem : ( expression AS variable )
+           | expression
+           ;
+
+order : ORDER BY sortItem ( ',' sortItem )* ;
+
+skip : L_SKIP expression ;
+
+limit : LIMIT expression ;
+
+sortItem : expression ( ASCENDING | ASC | DESCENDING | DESC )? ;
+
+where : WHERE expression ;
+
+pattern : patternPart ( ',' patternPart )* ;
+
+patternPart : ( variable '=' anonymousPatternPart )
+            | anonymousPatternPart
+            ;
+
+anonymousPatternPart : patternElement ;
+
+patternElement : ( nodePattern ( patternElementChain )* )
+               | ( '(' patternElement ')' )
+               ;
+
+nodePattern : '(' ( variable )? ( nodeLabels )? ( properties )? ')' ;
+
+patternElementChain : relationshipPattern nodePattern ;
+
+relationshipPattern : ( leftArrowHead dash ( relationshipDetail )? dash rightArrowHead )
+                    | ( leftArrowHead dash ( relationshipDetail )? dash )
+                    | ( dash ( relationshipDetail )? dash rightArrowHead )
+                    | ( dash ( relationshipDetail )? dash )
+                    ;
+
+leftArrowHead : '<' | LeftArrowHeadPart ;
+rightArrowHead : '>' | RightArrowHeadPart ;
+dash : '-' | DashPart ;
+
+relationshipDetail : '[' ( name=variable )? ( relationshipTypes )? ( variableExpansion )?  properties ']'
+                   | '[' ( name=variable )? ( relationshipTypes )? ( variableExpansion )? relationshipLambda ( total_weight=variable )? (relationshipLambda )? ']'
+                   | '[' ( name=variable )? ( relationshipTypes )? ( variableExpansion )? (properties )* ( relationshipLambda total_weight=variable )? (relationshipLambda )? ']';
+
+relationshipLambda: '(' traversed_edge=variable ',' traversed_node=variable '|' expression ')';
+
+variableExpansion : '*' (BFS | WSHORTEST)? ( expression )? ( '..' ( expression )? )? ;
+
+properties : mapLiteral
+           | parameter
+           ;
+
+relationshipTypes : ':' relTypeName ( '|' ':'? relTypeName )* ;
+
+nodeLabels : nodeLabel ( nodeLabel )* ;
+
+nodeLabel : ':' labelName ;
+
+labelName : symbolicName ;
+
+relTypeName : symbolicName ;
+
+expression : expression12 ;
+
+expression12 : expression11 ( OR expression11 )* ;
+
+expression11 : expression10 ( XOR expression10 )* ;
+
+expression10 : expression9 ( AND expression9 )* ;
+
+expression9 : ( NOT )* expression8 ;
+
+expression8 : expression7 ( partialComparisonExpression )* ;
+
+expression7 : expression6 ( ( '+' expression6 ) | ( '-' expression6 ) )* ;
+
+expression6 : expression5 ( ( '*' expression5 ) | ( '/' expression5 ) | ( '%' expression5 ) )* ;
+
+expression5 : expression4 ( '^' expression4 )* ;
+
+expression4 : ( ( '+' | '-' ) )* expression3a ;
+
+expression3a : expression3b ( stringAndNullOperators )* ;
+
+stringAndNullOperators : ( ( ( ( '=~' ) | ( IN ) | ( STARTS WITH ) | ( ENDS WITH ) | ( CONTAINS ) ) expression3b) | ( IS CYPHERNULL ) | ( IS NOT CYPHERNULL ) ) ;
+
+expression3b : expression2a ( listIndexingOrSlicing )* ;
+
+listIndexingOrSlicing : ( '[' expression ']' )
+                      | ( '[' lower_bound=expression? '..' upper_bound=expression? ']' )
+                      ;
+
+expression2a : expression2b ( nodeLabels )? ;
+
+expression2b : atom ( propertyLookup )* ;
+
+atom : literal
+     | parameter
+     | caseExpression
+     | ( COUNT '(' '*' ')' )
+     | listComprehension
+     | patternComprehension
+     | ( FILTER '(' filterExpression ')' )
+     | ( EXTRACT '(' extractExpression ')' )
+     | ( REDUCE '(' reduceExpression ')' )
+     | ( COALESCE '(' expression ( ',' expression )* ')' )
+     | ( ALL '(' filterExpression ')' )
+     | ( ANY '(' filterExpression ')' )
+     | ( NONE '(' filterExpression ')' )
+     | ( SINGLE '(' filterExpression ')' )
+     | relationshipsPattern
+     | parenthesizedExpression
+     | functionInvocation
+     | variable
+     ;
+
+literal : numberLiteral
+        | StringLiteral
+        | booleanLiteral
+        | CYPHERNULL
+        | mapLiteral
+        | listLiteral
+        ;
+
+booleanLiteral : TRUE
+               | FALSE
+               ;
+
+listLiteral : '[' ( expression ( ',' expression )* )? ']' ;
+
+partialComparisonExpression : ( '=' expression7 )
+                            | ( '<>' expression7 )
+                            | ( '!=' expression7 )
+                            | ( '<' expression7 )
+                            | ( '>' expression7 )
+                            | ( '<=' expression7 )
+                            | ( '>=' expression7 )
+                            ;
+
+parenthesizedExpression : '(' expression ')' ;
+
+relationshipsPattern : nodePattern ( patternElementChain )+ ;
+
+filterExpression : idInColl ( where )? ;
+
+reduceExpression : accumulator=variable '=' initial=expression ',' idInColl '|' expression ;
+
+extractExpression : idInColl '|' expression ;
+
+idInColl : variable IN expression ;
+
+functionInvocation : functionName '(' ( DISTINCT )? ( expression ( ',' expression )* )? ')' ;
+
+functionName : symbolicName ( '.' symbolicName )* ;
+
+listComprehension : '[' filterExpression ( '|' expression )? ']' ;
+
+patternComprehension : '[' ( variable '=' )? relationshipsPattern ( WHERE expression )? '|' expression ']' ;
+
+propertyLookup : '.' ( propertyKeyName ) ;
+
+caseExpression : ( ( CASE ( caseAlternatives )+ ) | ( CASE test=expression ( caseAlternatives )+ ) ) ( ELSE else_expression=expression )? END ;
+
+caseAlternatives : WHEN when_expression=expression THEN then_expression=expression ;
+
+variable : symbolicName ;
+
+numberLiteral : doubleLiteral
+              | integerLiteral
+              ;
+
+mapLiteral : '{' ( propertyKeyName ':' expression ( ',' propertyKeyName ':' expression )* )? '}' ;
+
+parameter : '$' ( symbolicName | DecimalLiteral ) ;
+
+propertyExpression : atom ( propertyLookup )+ ;
+
+propertyKeyName : symbolicName ;
+
+integerLiteral : DecimalLiteral
+               | OctalLiteral
+               | HexadecimalLiteral
+               ;
+
+createIndex : CREATE INDEX ON ':' labelName ( '(' propertyKeyName ')' )? ;
+
+dropIndex : DROP INDEX ON ':' labelName ( '(' propertyKeyName ')' )? ;
+
+doubleLiteral : FloatingLiteral ;
+
+cypherKeyword : ALL
+              | AND
+              | ANY
+              | AS
+              | ASC
+              | ASCENDING
+              | ASSERT
+              | BFS
+              | BY
+              | CALL
+              | CASE
+              | CONSTRAINT
+              | CONTAINS
+              | COUNT
+              | CREATE
+              | CYPHERNULL
+              | DELETE
+              | DESC
+              | DESCENDING
+              | DETACH
+              | DISTINCT
+              | ELSE
+              | END
+              | ENDS
+              | EXISTS
+              | EXPLAIN
+              | EXTRACT
+              | FALSE
+              | FILTER
+              | IN
+              | INDEX
+              | INFO
+              | IS
+              | KEY
+              | LIMIT
+              | L_SKIP
+              | MATCH
+              | MERGE
+              | NODE
+              | NONE
+              | NOT
+              | ON
+              | OPTIONAL
+              | OR
+              | ORDER
+              | PROCEDURE
+              | PROFILE
+              | QUERY
+              | REDUCE
+              | REMOVE
+              | RETURN
+              | SET
+              | SHOW
+              | SINGLE
+              | STARTS
+              | STORAGE
+              | THEN
+              | TRUE
+              | UNION
+              | UNIQUE
+              | UNWIND
+              | WHEN
+              | WHERE
+              | WITH
+              | WSHORTEST
+              | XOR
+              | YIELD
+              ;
+
+symbolicName : UnescapedSymbolicName
+             | EscapedSymbolicName
+             | cypherKeyword
+             ;

src/query/v2/frontend/opencypher/grammar/CypherLexer.g4

@@ -0,0 +1,208 @@
+/*
+ * When changing this grammar make sure to update constants in
+ * src/query/frontend/stripped_lexer_constants.hpp (kKeywords, kSpecialTokens
+ * and bitsets) if needed.
+ */
+
+lexer grammar CypherLexer ;
+
+import UnicodeCategories ;
+
+/* Skip whitespace and comments. */
+Skipped              : ( Whitespace | Comment ) -> skip ;
+
+fragment Whitespace  : '\u0020'
+                     | [\u0009-\u000D]
+                     | [\u001C-\u001F]
+                     | '\u1680' | '\u180E'
+                     | [\u2000-\u200A]
+                     | '\u2028' | '\u2029'
+                     | '\u205F'
+                     | '\u3000'
+                     | '\u00A0'
+                     | '\u202F'
+                     ;
+
+fragment Comment     : '/*' .*? '*/'
+                     | '//' ~[\r\n]*
+                     ;
+
+/* Special symbols. */
+LPAREN    : '(' ;
+RPAREN    : ')' ;
+LBRACK    : '[' ;
+RBRACK    : ']' ;
+LBRACE    : '{' ;
+RBRACE    : '}' ;
+
+COMMA     : ',' ;
+DOT       : '.' ;
+DOTS      : '..' ;
+COLON     : ':' ;
+SEMICOLON : ';' ;
+DOLLAR    : '$' ;
+PIPE      : '|' ;
+
+EQ        : '=' ;
+LT        : '<' ;
+GT        : '>' ;
+LTE       : '<=' ;
+GTE       : '>=' ;
+NEQ1      : '<>' ;
+NEQ2      : '!=' ;
+SIM       : '=~' ;
+
+PLUS      : '+' ;
+MINUS     : '-' ;
+ASTERISK  : '*' ;
+SLASH     : '/' ;
+PERCENT   : '%' ;
+CARET     : '^' ;
+PLUS_EQ   : '+=' ;
+
+/* Some random unicode characters that can be used to draw arrows. */
+LeftArrowHeadPart  : '⟨' | '〈' | '﹤' | '＜' ;
+RightArrowHeadPart : '⟩' | '〉' | '﹥' | '＞' ;
+DashPart           : '­' | '‐' | '‑' | '‒' | '–' | '—' | '―'
+                   | '−' | '﹘' | '﹣' | '－'
+                   ;
+
+/* Cypher reserved words. */
+ALL            : A L L ;
+AND            : A N D ;
+ANY            : A N Y ;
+AS             : A S ;
+ASC            : A S C ;
+ASCENDING      : A S C E N D I N G ;
+ASSERT         : A S S E R T ;
+BFS            : B F S ;
+BY             : B Y ;
+CALL           : C A L L ;
+CASE           : C A S E ;
+COALESCE       : C O A L E S C E ;
+CONSTRAINT     : C O N S T R A I N T ;
+CONTAINS       : C O N T A I N S ;
+COUNT          : C O U N T ;
+CREATE         : C R E A T E ;
+CYPHERNULL     : N U L L ;
+DELETE         : D E L E T E ;
+DESC           : D E S C ;
+DESCENDING     : D E S C E N D I N G ;
+DETACH         : D E T A C H ;
+DISTINCT       : D I S T I N C T ;
+DROP           : D R O P ;
+ELSE           : E L S E ;
+END            : E N D ;
+ENDS           : E N D S ;
+EXISTS         : E X I S T S ;
+EXPLAIN        : E X P L A I N ;
+EXTRACT        : E X T R A C T ;
+FALSE          : F A L S E ;
+FILTER         : F I L T E R ;
+IN             : I N ;
+INDEX          : I N D E X ;
+INFO           : I N F O ;
+IS             : I S ;
+KB             : K B ;
+KEY            : K E Y ;
+LIMIT          : L I M I T ;
+L_SKIP         : S K I P ;
+MATCH          : M A T C H ;
+MB             : M B ;
+MEMORY         : M E M O R Y ;
+MERGE          : M E R G E ;
+NODE           : N O D E ;
+NONE           : N O N E ;
+NOT            : N O T ;
+ON             : O N ;
+OPTIONAL       : O P T I O N A L ;
+OR             : O R ;
+ORDER          : O R D E R ;
+PROCEDURE      : P R O C E D U R E ;
+PROFILE        : P R O F I L E ;
+QUERY          : Q U E R Y ;
+REDUCE         : R E D U C E ;
+REMOVE         : R E M O V E ;
+RETURN         : R E T U R N ;
+SET            : S E T ;
+SHOW           : S H O W ;
+SINGLE         : S I N G L E ;
+STARTS         : S T A R T S ;
+STORAGE        : S T O R A G E ;
+THEN           : T H E N ;
+TRUE           : T R U E ;
+UNION          : U N I O N ;
+UNIQUE         : U N I Q U E ;
+UNLIMITED      : U N L I M I T E D ;
+UNWIND         : U N W I N D ;
+WHEN           : W H E N ;
+WHERE          : W H E R E ;
+WITH           : W I T H ;
+WSHORTEST      : W S H O R T E S T ;
+XOR            : X O R ;
+YIELD          : Y I E L D ;
+
+/* Double and single quoted string literals. */
+StringLiteral : '"'  ( ~[\\"] | EscapeSequence )* '"'
+              | '\'' ( ~[\\'] | EscapeSequence )* '\''
+              ;
+
+fragment EscapeSequence : '\\' ( B | F | N | R | T | '\\' | '\'' | '"' )
+                        | '\\u' HexDigit HexDigit HexDigit HexDigit
+                        | '\\U' HexDigit HexDigit HexDigit HexDigit
+                                HexDigit HexDigit HexDigit HexDigit
+                        ;
+
+/* Number literals. */
+DecimalLiteral     : '0' | NonZeroDigit ( DecDigit )* ;
+OctalLiteral       : '0' ( OctDigit )+ ;
+HexadecimalLiteral : '0x' ( HexDigit )+ ;
+FloatingLiteral    : DecDigit* '.' DecDigit+ ( E '-'? DecDigit+ )?
+                   | DecDigit+ ( '.' DecDigit* )? ( E '-'? DecDigit+ )
+                   | DecDigit+ ( E '-'? DecDigit+ )
+                   ;
+
+fragment NonZeroDigit : [1-9] ;
+fragment DecDigit     : [0-9] ;
+fragment OctDigit     : [0-7] ;
+fragment HexDigit     : [0-9] | [a-f] | [A-F] ;
+
+/* Symbolic names. */
+UnescapedSymbolicName : IdentifierStart ( IdentifierPart )* ;
+EscapedSymbolicName   : ( '`' ~[`]* '`' )+ ;
+
+/**
+ * Based on the unicode identifier and pattern syntax
+ * (http://www.unicode.org/reports/tr31/)
+ * and extended with a few characters.
+ */
+IdentifierStart : ID_Start    | Pc ;
+IdentifierPart  : ID_Continue | Sc ;
+
+/* Hack for case-insensitive reserved words */
+fragment A : 'A' | 'a' ;
+fragment B : 'B' | 'b' ;
+fragment C : 'C' | 'c' ;
+fragment D : 'D' | 'd' ;
+fragment E : 'E' | 'e' ;
+fragment F : 'F' | 'f' ;
+fragment G : 'G' | 'g' ;
+fragment H : 'H' | 'h' ;
+fragment I : 'I' | 'i' ;
+fragment J : 'J' | 'j' ;
+fragment K : 'K' | 'k' ;
+fragment L : 'L' | 'l' ;
+fragment M : 'M' | 'm' ;
+fragment N : 'N' | 'n' ;
+fragment O : 'O' | 'o' ;
+fragment P : 'P' | 'p' ;
+fragment Q : 'Q' | 'q' ;
+fragment R : 'R' | 'r' ;
+fragment S : 'S' | 's' ;
+fragment T : 'T' | 't' ;
+fragment U : 'U' | 'u' ;
+fragment V : 'V' | 'v' ;
+fragment W : 'W' | 'w' ;
+fragment X : 'X' | 'x' ;
+fragment Y : 'Y' | 'y' ;
+fragment Z : 'Z' | 'z' ;

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

@@ -0,0 +1,399 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/* Memgraph specific part of Cypher grammar with enterprise features. */
+
+parser grammar MemgraphCypher ;
+
+options { tokenVocab=MemgraphCypherLexer; }
+
+import Cypher ;
+
+memgraphCypherKeyword : cypherKeyword
+                      | AFTER
+                      | ALTER
+                      | ASYNC
+                      | AUTH
+                      | BAD
+                      | BATCH_INTERVAL
+                      | BATCH_LIMIT
+                      | BATCH_SIZE
+                      | BEFORE
+                      | BOOTSTRAP_SERVERS
+                      | CHECK
+                      | CLEAR
+                      | COMMIT
+                      | COMMITTED
+                      | CONFIG
+                      | CONFIGS
+                      | CONSUMER_GROUP
+                      | CREDENTIALS
+                      | CSV
+                      | DATA
+                      | DELIMITER
+                      | DATABASE
+                      | DENY
+                      | DROP
+                      | DUMP
+                      | EXECUTE
+                      | FREE
+                      | FROM
+                      | FOR
+                      | FOREACH
+                      | GLOBAL
+                      | GRANT
+                      | HEADER
+                      | IDENTIFIED
+                      | ISOLATION
+                      | KAFKA
+                      | LEVEL
+                      | LOAD
+                      | LOCK
+                      | MAIN
+                      | MODE
+                      | NEXT
+                      | NO
+                      | PASSWORD
+                      | PULSAR
+                      | PORT
+                      | PRIVILEGES
+                      | READ
+                      | REGISTER
+                      | REPLICA
+                      | REPLICAS
+                      | REPLICATION
+                      | REVOKE
+                      | ROLE
+                      | ROLES
+                      | QUOTE
+                      | SCHEMA
+                      | SCHEMAS
+                      | SESSION
+                      | SETTING
+                      | SETTINGS
+                      | SNAPSHOT
+                      | START
+                      | STATS
+                      | STREAM
+                      | STREAMS
+                      | SYNC
+                      | TIMEOUT
+                      | TO
+                      | TOPICS
+                      | TRANSACTION
+                      | TRANSFORM
+                      | TRIGGER
+                      | TRIGGERS
+                      | UNCOMMITTED
+                      | UNLOCK
+                      | UPDATE
+                      | USER
+                      | USERS
+                      | VERSION
+                      ;
+
+symbolicName : UnescapedSymbolicName
+             | EscapedSymbolicName
+             | memgraphCypherKeyword
+             ;
+
+query : cypherQuery
+      | indexQuery
+      | explainQuery
+      | profileQuery
+      | infoQuery
+      | constraintQuery
+      | authQuery
+      | dumpQuery
+      | replicationQuery
+      | lockPathQuery
+      | freeMemoryQuery
+      | triggerQuery
+      | isolationLevelQuery
+      | createSnapshotQuery
+      | streamQuery
+      | settingQuery
+      | versionQuery
+      | schemaQuery
+      ;
+
+authQuery : createRole
+          | dropRole
+          | showRoles
+          | createUser
+          | setPassword
+          | dropUser
+          | showUsers
+          | setRole
+          | clearRole
+          | grantPrivilege
+          | denyPrivilege
+          | revokePrivilege
+          | showPrivileges
+          | showRoleForUser
+          | showUsersForRole
+          ;
+
+replicationQuery : setReplicationRole
+                 | showReplicationRole
+                 | registerReplica
+                 | dropReplica
+                 | showReplicas
+                 ;
+
+triggerQuery : createTrigger
+             | dropTrigger
+             | showTriggers
+             ;
+
+clause : cypherMatch
+       | unwind
+       | merge
+       | create
+       | set
+       | cypherDelete
+       | remove
+       | with
+       | cypherReturn
+       | callProcedure
+       | loadCsv
+       | foreach
+       ;
+
+updateClause : set
+             | remove
+             | create
+             | merge
+             | cypherDelete
+             | foreach
+             ;
+
+foreach :  FOREACH '(' variable IN expression '|' updateClause+  ')' ;
+
+streamQuery : checkStream
+            | createStream
+            | dropStream
+            | startStream
+            | startAllStreams
+            | stopStream
+            | stopAllStreams
+            | showStreams
+            ;
+
+settingQuery : setSetting
+             | showSetting
+             | showSettings
+             ;
+
+schemaQuery : showSchema
+            | showSchemas
+            | createSchema
+            | dropSchema
+            ;
+
+loadCsv : LOAD CSV FROM csvFile ( WITH | NO ) HEADER
+         ( IGNORE BAD ) ?
+         ( DELIMITER delimiter ) ?
+         ( QUOTE quote ) ?
+         AS rowVar ;
+
+csvFile : literal ;
+
+delimiter : literal ;
+
+quote : literal ;
+
+rowVar : variable ;
+
+userOrRoleName : symbolicName ;
+
+createRole : CREATE ROLE role=userOrRoleName ;
+
+dropRole   : DROP ROLE role=userOrRoleName ;
+
+showRoles  : SHOW ROLES ;
+
+createUser : CREATE USER user=userOrRoleName
+             ( IDENTIFIED BY password=literal )? ;
+
+setPassword : SET PASSWORD FOR user=userOrRoleName TO password=literal;
+
+dropUser : DROP USER user=userOrRoleName ;
+
+showUsers : SHOW USERS ;
+
+setRole : SET ROLE FOR user=userOrRoleName TO role=userOrRoleName;
+
+clearRole : CLEAR ROLE FOR user=userOrRoleName ;
+
+grantPrivilege : GRANT ( ALL PRIVILEGES | privileges=privilegeList ) TO userOrRole=userOrRoleName ;
+
+denyPrivilege : DENY ( ALL PRIVILEGES | privileges=privilegeList ) TO userOrRole=userOrRoleName ;
+
+revokePrivilege : REVOKE ( ALL PRIVILEGES | privileges=privilegeList ) FROM userOrRole=userOrRoleName ;
+
+privilege : CREATE
+          | DELETE
+          | MATCH
+          | MERGE
+          | SET
+          | REMOVE
+          | INDEX
+          | STATS
+          | AUTH
+          | CONSTRAINT
+          | DUMP
+          | REPLICATION
+          | READ_FILE
+          | FREE_MEMORY
+          | TRIGGER
+          | CONFIG
+          | DURABILITY
+          | STREAM
+          | MODULE_READ
+          | MODULE_WRITE
+          | WEBSOCKET
+          | SCHEMA
+          ;
+
+privilegeList : privilege ( ',' privilege )* ;
+
+showPrivileges : SHOW PRIVILEGES FOR userOrRole=userOrRoleName ;
+
+showRoleForUser : SHOW ROLE FOR user=userOrRoleName ;
+
+showUsersForRole : SHOW USERS FOR role=userOrRoleName ;
+
+dumpQuery: DUMP DATABASE ;
+
+setReplicationRole  : SET REPLICATION ROLE TO ( MAIN | REPLICA )
+                      ( WITH PORT port=literal ) ? ;
+
+showReplicationRole : SHOW REPLICATION ROLE ;
+
+replicaName : symbolicName ;
+
+socketAddress : literal ;
+
+registerReplica : REGISTER REPLICA replicaName ( SYNC | ASYNC )
+                TO socketAddress ;
+
+dropReplica : DROP REPLICA replicaName ;
+
+showReplicas  : SHOW REPLICAS ;
+
+lockPathQuery : ( LOCK | UNLOCK ) DATA DIRECTORY ;
+
+freeMemoryQuery : FREE MEMORY ;
+
+triggerName : symbolicName ;
+
+triggerStatement : .*? ;
+
+emptyVertex : '(' ')' ;
+
+emptyEdge : dash dash rightArrowHead ;
+
+createTrigger : CREATE TRIGGER triggerName ( ON ( emptyVertex | emptyEdge ) ? ( CREATE | UPDATE | DELETE ) ) ?
+              ( AFTER | BEFORE ) COMMIT EXECUTE triggerStatement ;
+
+dropTrigger : DROP TRIGGER triggerName ;
+
+showTriggers : SHOW TRIGGERS ;
+
+isolationLevel : SNAPSHOT ISOLATION | READ COMMITTED | READ UNCOMMITTED ;
+
+isolationLevelScope : GLOBAL | SESSION | NEXT ;
+
+isolationLevelQuery : SET isolationLevelScope TRANSACTION ISOLATION LEVEL isolationLevel ;
+
+createSnapshotQuery : CREATE SNAPSHOT ;
+
+streamName : symbolicName ;
+
+symbolicNameWithMinus : symbolicName ( MINUS symbolicName )* ;
+
+symbolicNameWithDotsAndMinus: symbolicNameWithMinus ( DOT symbolicNameWithMinus )* ;
+
+symbolicTopicNames : symbolicNameWithDotsAndMinus ( COMMA symbolicNameWithDotsAndMinus )* ;
+
+topicNames : symbolicTopicNames | literal ;
+
+commonCreateStreamConfig : TRANSFORM transformationName=procedureName
+                         | BATCH_INTERVAL batchInterval=literal
+                         | BATCH_SIZE batchSize=literal
+                         ;
+
+createStream : kafkaCreateStream | pulsarCreateStream ;
+
+configKeyValuePair : literal ':' literal ;
+
+configMap : '{' ( configKeyValuePair ( ',' configKeyValuePair )* )? '}' ;
+
+kafkaCreateStreamConfig : TOPICS topicNames
+                        | CONSUMER_GROUP consumerGroup=symbolicNameWithDotsAndMinus
+                        | BOOTSTRAP_SERVERS bootstrapServers=literal
+                        | CONFIGS configsMap=configMap
+                        | CREDENTIALS credentialsMap=configMap
+                        | commonCreateStreamConfig
+                        ;
+
+kafkaCreateStream : CREATE KAFKA STREAM streamName ( kafkaCreateStreamConfig ) * ;
+
+
+pulsarCreateStreamConfig : TOPICS topicNames
+                         | SERVICE_URL serviceUrl=literal
+                         | commonCreateStreamConfig
+                         ;
+
+pulsarCreateStream : CREATE PULSAR STREAM streamName ( pulsarCreateStreamConfig ) * ;
+
+dropStream : DROP STREAM streamName ;
+
+startStream : START STREAM streamName ( BATCH_LIMIT batchLimit=literal ) ? ( TIMEOUT timeout=literal ) ? ;
+
+startAllStreams : START ALL STREAMS ;
+
+stopStream : STOP STREAM streamName ;
+
+stopAllStreams : STOP ALL STREAMS ;
+
+showStreams : SHOW STREAMS ;
+
+checkStream : CHECK STREAM streamName ( BATCH_LIMIT batchLimit=literal ) ? ( TIMEOUT timeout=literal ) ? ;
+
+settingName : literal ;
+
+settingValue : literal ;
+
+setSetting : SET DATABASE SETTING settingName TO settingValue ;
+
+showSetting : SHOW DATABASE SETTING settingName ;
+
+showSettings : SHOW DATABASE SETTINGS ;
+
+versionQuery : SHOW VERSION ;
+
+showSchema : SHOW SCHEMA ON ':' labelName ;
+
+showSchemas : SHOW SCHEMAS ;
+
+propertyType : symbolicName ;
+
+propertyKeyTypePair : propertyKeyName propertyType ;
+
+schemaPropertyMap : '(' propertyKeyTypePair ( ',' propertyKeyTypePair )* ')' ;
+
+createSchema : CREATE SCHEMA ON ':' labelName schemaPropertyMap ;
+
+dropSchema : DROP SCHEMA ON ':' labelName ;

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

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2021 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.
+ */
+
+/* Memgraph specific Cypher reserved words used for enterprise features. */
+
+/*
+ * When changing this grammar make sure to update constants in
+ * src/query/frontend/stripped_lexer_constants.hpp (kKeywords, kSpecialTokens
+ * and bitsets) if needed.
+ */
+
+lexer grammar MemgraphCypherLexer ;
+
+import CypherLexer ;
+
+UNDERSCORE : '_' ;
+
+AFTER               : A F T E R ;
+ALTER               : A L T E R ;
+ASYNC               : A S Y N C ;
+AUTH                : A U T H ;
+BAD                 : B A D ;
+BATCH_INTERVAL      : B A T C H UNDERSCORE I N T E R V A L ;
+BATCH_LIMIT         : B A T C H UNDERSCORE L I M I T ;
+BATCH_SIZE          : B A T C H UNDERSCORE S I Z E ;
+BEFORE              : B E F O R E ;
+BOOTSTRAP_SERVERS   : B O O T S T R A P UNDERSCORE S E R V E R S ;
+CHECK               : C H E C K ;
+CLEAR               : C L E A R ;
+COMMIT              : C O M M I T ;
+COMMITTED           : C O M M I T T E D ;
+CONFIG              : C O N F I G ;
+CONFIGS             : C O N F I G S;
+CONSUMER_GROUP      : C O N S U M E R UNDERSCORE G R O U P ;
+CREDENTIALS         : C R E D E N T I A L S ;
+CSV                 : C S V ;
+DATA                : D A T A ;
+DELIMITER           : D E L I M I T E R ;
+DATABASE            : D A T A B A S E ;
+DENY                : D E N Y ;
+DIRECTORY           : D I R E C T O R Y ;
+DROP                : D R O P ;
+DUMP                : D U M P ;
+DURABILITY          : D U R A B I L I T Y ;
+EXECUTE             : E X E C U T E ;
+FOR                 : F O R ;
+FOREACH             : F O R E A C H;
+FREE                : F R E E ;
+FREE_MEMORY         : F R E E UNDERSCORE M E M O R Y ;
+FROM                : F R O M ;
+GLOBAL              : G L O B A L ;
+GRANT               : G R A N T ;
+GRANTS              : G R A N T S ;
+HEADER              : H E A D E R ;
+IDENTIFIED          : I D E N T I F I E D ;
+IGNORE              : I G N O R E ;
+ISOLATION           : I S O L A T I O N ;
+KAFKA               : K A F K A ;
+LEVEL               : L E V E L ;
+LOAD                : L O A D ;
+LOCK                : L O C K ;
+MAIN                : M A I N ;
+MODE                : M O D E ;
+MODULE_READ         : M O D U L E UNDERSCORE R E A D ;
+MODULE_WRITE        : M O D U L E UNDERSCORE W R I T E ;
+NEXT                : N E X T ;
+NO                  : N O ;
+PASSWORD            : P A S S W O R D ;
+PORT                : P O R T ;
+PRIVILEGES          : P R I V I L E G E S ;
+PULSAR              : P U L S A R ;
+READ                : R E A D ;
+READ_FILE           : R E A D UNDERSCORE F I L E ;
+REGISTER            : R E G I S T E R ;
+REPLICA             : R E P L I C A ;
+REPLICAS            : R E P L I C A S ;
+REPLICATION         : R E P L I C A T I O N ;
+REVOKE              : R E V O K E ;
+ROLE                : R O L E ;
+ROLES               : R O L E S ;
+QUOTE               : Q U O T E ;
+SCHEMA              : S C H E M A ;
+SCHEMAS             : S C H E M A S ;
+SERVICE_URL         : S E R V I C E UNDERSCORE U R L ;
+SESSION             : S E S S I O N ;
+SETTING             : S E T T I N G ;
+SETTINGS            : S E T T I N G S ;
+SNAPSHOT            : S N A P S H O T ;
+START               : S T A R T ;
+STATS               : S T A T S ;
+STOP                : S T O P ;
+STREAM              : S T R E A M ;
+STREAMS             : S T R E A M S ;
+SYNC                : S Y N C ;
+TIMEOUT             : T I M E O U T ;
+TO                  : T O ;
+TOPICS              : T O P I C S;
+TRANSACTION         : T R A N S A C T I O N ;
+TRANSFORM           : T R A N S F O R M ;
+TRIGGER             : T R I G G E R ;
+TRIGGERS            : T R I G G E R S ;
+UNCOMMITTED         : U N C O M M I T T E D ;
+UNLOCK              : U N L O C K ;
+UPDATE              : U P D A T E ;
+USER                : U S E R ;
+USERS               : U S E R S ;
+VERSION             : V E R S I O N ;
+WEBSOCKET           : W E B S O C K E T ;

src/query/v2/frontend/opencypher/parser.hpp

@@ -0,0 +1,68 @@
+// 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.
+
+#pragma once
+
+#include <string>
+
+#include "antlr4-runtime.h"
+#include "query/v2/exceptions.hpp"
+#include "query/v2/frontend/opencypher/generated/MemgraphCypher.h"
+#include "query/v2/frontend/opencypher/generated/MemgraphCypherLexer.h"
+
+namespace memgraph::query::v2::frontend::opencypher {
+
+/**
+ * Generates openCypher AST
+ * This thing must me a class since parser.cypher() returns pointer and there is
+ * no way for us to get ownership over the object.
+ */
+class Parser {
+ public:
+  /**
+   * @param query incoming query that has to be compiled into query plan
+   *        the first step is to generate AST
+   */
+  Parser(const std::string query) : query_(std::move(query)) {
+    parser_.removeErrorListeners();
+    parser_.addErrorListener(&error_listener_);
+    tree_ = parser_.cypher();
+    if (parser_.getNumberOfSyntaxErrors()) {
+      throw query::v2::SyntaxException(error_listener_.error_);
+    }
+  }
+
+  auto tree() { return tree_; }
+
+ private:
+  class FirstMessageErrorListener : public antlr4::BaseErrorListener {
+    void syntaxError(antlr4::Recognizer *, antlr4::Token *, size_t line, size_t position, const std::string &message,
+                     std::exception_ptr) override {
+      if (error_.empty()) {
+        error_ = "line " + std::to_string(line) + ":" + std::to_string(position + 1) + " " + message;
+      }
+    }
+
+   public:
+    std::string error_;
+  };
+
+  FirstMessageErrorListener error_listener_;
+  std::string query_;
+  antlr4::ANTLRInputStream input_{query_};
+  antlropencypher::MemgraphCypherLexer lexer_{&input_};
+  antlr4::CommonTokenStream tokens_{&lexer_};
+
+  // generate ast
+  antlropencypher::MemgraphCypher parser_{&tokens_};
+  antlr4::tree::ParseTree *tree_ = nullptr;
+};
+}  // namespace memgraph::query::v2::frontend::opencypher

src/query/v2/frontend/parsing.cpp

@@ -0,0 +1,184 @@
+// 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 "query/v2/frontend/parsing.hpp"
+
+#include <cctype>
+#include <codecvt>
+#include <locale>
+#include <stdexcept>
+
+#include "query/v2/exceptions.hpp"
+#include "utils/logging.hpp"
+#include "utils/string.hpp"
+
+namespace memgraph::query::v2::frontend {
+
+int64_t ParseIntegerLiteral(const std::string &s) {
+  try {
+    // Not really correct since long long can have a bigger range than int64_t.
+    return static_cast<int64_t>(std::stoll(s, 0, 0));
+  } catch (const std::out_of_range &) {
+    throw SemanticException("Integer literal exceeds 64 bits.");
+  }
+}
+
+std::string ParseStringLiteral(const std::string &s) {
+  // These functions is declared as lambda since its semantics is highly
+  // specific for this conxtext and shouldn't be used elsewhere.
+  auto EncodeEscapedUnicodeCodepointUtf32 = [](const std::string &s, int &i) {
+    const int kLongUnicodeLength = 8;
+    int j = i + 1;
+    while (j < static_cast<int>(s.size()) - 1 && j < i + kLongUnicodeLength + 1 && isxdigit(s[j])) {
+      ++j;
+    }
+    if (j - i == kLongUnicodeLength + 1) {
+      char32_t t = stoi(s.substr(i + 1, kLongUnicodeLength), 0, 16);
+      i += kLongUnicodeLength;
+      std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
+      return converter.to_bytes(t);
+    }
+    throw SyntaxException(
+        "Expected 8 hex digits as unicode codepoint started with \\U. "
+        "Use \\u for 4 hex digits format.");
+  };
+  auto EncodeEscapedUnicodeCodepointUtf16 = [](const std::string &s, int &i) {
+    const int kShortUnicodeLength = 4;
+    int j = i + 1;
+    while (j < static_cast<int>(s.size()) - 1 && j < i + kShortUnicodeLength + 1 && isxdigit(s[j])) {
+      ++j;
+    }
+    if (j - i >= kShortUnicodeLength + 1) {
+      char16_t t = stoi(s.substr(i + 1, kShortUnicodeLength), 0, 16);
+      if (t >= 0xD800 && t <= 0xDBFF) {
+        // t is high surrogate pair. Expect one more utf16 codepoint.
+        j = i + kShortUnicodeLength + 1;
+        if (j >= static_cast<int>(s.size()) - 1 || s[j] != '\\') {
+          throw SemanticException("Invalid UTF codepoint.");
+        }
+        ++j;
+        if (j >= static_cast<int>(s.size()) - 1 || (s[j] != 'u' && s[j] != 'U')) {
+          throw SemanticException("Invalid UTF codepoint.");
+        }
+        ++j;
+        int k = j;
+        while (k < static_cast<int>(s.size()) - 1 && k < j + kShortUnicodeLength && isxdigit(s[k])) {
+          ++k;
+        }
+        if (k != j + kShortUnicodeLength) {
+          throw SemanticException("Invalid UTF codepoint.");
+        }
+        char16_t surrogates[3] = {t, static_cast<char16_t>(stoi(s.substr(j, kShortUnicodeLength), 0, 16)), 0};
+        i += kShortUnicodeLength + 2 + kShortUnicodeLength;
+        std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> converter;
+        return converter.to_bytes(surrogates);
+      } else {
+        i += kShortUnicodeLength;
+        std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> converter;
+        return converter.to_bytes(t);
+      }
+    }
+    throw SyntaxException(
+        "Expected 4 hex digits as unicode codepoint started with \\u. "
+        "Use \\U for 8 hex digits format.");
+  };
+
+  std::string unescaped;
+  bool escape = false;
+
+  // First and last char is quote, we don't need to look at them.
+  for (int i = 1; i < static_cast<int>(s.size()) - 1; ++i) {
+    if (escape) {
+      switch (s[i]) {
+        case '\\':
+          unescaped += '\\';
+          break;
+        case '\'':
+          unescaped += '\'';
+          break;
+        case '"':
+          unescaped += '"';
+          break;
+        case 'B':
+        case 'b':
+          unescaped += '\b';
+          break;
+        case 'F':
+        case 'f':
+          unescaped += '\f';
+          break;
+        case 'N':
+        case 'n':
+          unescaped += '\n';
+          break;
+        case 'R':
+        case 'r':
+          unescaped += '\r';
+          break;
+        case 'T':
+        case 't':
+          unescaped += '\t';
+          break;
+        case 'U':
+          try {
+            unescaped += EncodeEscapedUnicodeCodepointUtf32(s, i);
+          } catch (const std::range_error &) {
+            throw SemanticException("Invalid UTF codepoint.");
+          }
+          break;
+        case 'u':
+          try {
+            unescaped += EncodeEscapedUnicodeCodepointUtf16(s, i);
+          } catch (const std::range_error &) {
+            throw SemanticException("Invalid UTF codepoint.");
+          }
+          break;
+        default:
+          // This should never happen, except grammar changes and we don't
+          // notice change in this production.
+          DLOG_FATAL("can't happen");
+          throw std::exception();
+      }
+      escape = false;
+    } else if (s[i] == '\\') {
+      escape = true;
+    } else {
+      unescaped += s[i];
+    }
+  }
+  return unescaped;
+}
+
+double ParseDoubleLiteral(const std::string &s) {
+  try {
+    return utils::ParseDouble(s);
+  } catch (const utils::BasicException &) {
+    throw SemanticException("Couldn't parse string to double.");
+  }
+}
+
+std::string ParseParameter(const std::string &s) {
+  DMG_ASSERT(s[0] == '$', "Invalid string passed as parameter name");
+  if (s[1] != '`') return s.substr(1);
+  // If parameter name is escaped symbolic name then symbolic name should be
+  // unescaped and leading and trailing backquote should be removed.
+  DMG_ASSERT(s.size() > 3U && s.back() == '`', "Invalid string passed as parameter name");
+  std::string out;
+  for (int i = 2; i < static_cast<int>(s.size()) - 1; ++i) {
+    if (s[i] == '`') {
+      ++i;
+    }
+    out.push_back(s[i]);
+  }
+  return out;
+}
+
+}  // namespace memgraph::query::v2::frontend

src/query/v2/frontend/parsing.hpp

@@ -0,0 +1,27 @@
+// 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.
+
+/// @file
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+namespace memgraph::query::v2::frontend {
+
+// These are the functions for parsing literals and parameter names from
+// opencypher query.
+int64_t ParseIntegerLiteral(const std::string &s);
+std::string ParseStringLiteral(const std::string &s);
+double ParseDoubleLiteral(const std::string &s);
+std::string ParseParameter(const std::string &s);
+
+}  // namespace memgraph::query::v2::frontend

src/query/v2/frontend/semantic/required_privileges.cpp

@@ -0,0 +1,154 @@
+// 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 "query/v2/frontend/ast/ast.hpp"
+#include "query/v2/frontend/ast/ast_visitor.hpp"
+#include "query/v2/procedure/module.hpp"
+#include "utils/memory.hpp"
+
+namespace memgraph::query::v2 {
+
+class PrivilegeExtractor : public QueryVisitor<void>, public HierarchicalTreeVisitor {
+ public:
+  using HierarchicalTreeVisitor::PostVisit;
+  using HierarchicalTreeVisitor::PreVisit;
+  using HierarchicalTreeVisitor::Visit;
+  using QueryVisitor<void>::Visit;
+
+  std::vector<AuthQuery::Privilege> privileges() { return privileges_; }
+
+  void Visit(IndexQuery &) override { AddPrivilege(AuthQuery::Privilege::INDEX); }
+
+  void Visit(AuthQuery &) override { AddPrivilege(AuthQuery::Privilege::AUTH); }
+
+  void Visit(ExplainQuery &query) override { query.cypher_query_->Accept(*this); }
+
+  void Visit(ProfileQuery &query) override { query.cypher_query_->Accept(*this); }
+
+  void Visit(InfoQuery &info_query) override {
+    switch (info_query.info_type_) {
+      case InfoQuery::InfoType::INDEX:
+        // TODO: This should be INDEX | STATS, but we don't have support for
+        // *or* with privileges.
+        AddPrivilege(AuthQuery::Privilege::INDEX);
+        break;
+      case InfoQuery::InfoType::STORAGE:
+        AddPrivilege(AuthQuery::Privilege::STATS);
+        break;
+      case InfoQuery::InfoType::CONSTRAINT:
+        // TODO: This should be CONSTRAINT | STATS, but we don't have support
+        // for *or* with privileges.
+        AddPrivilege(AuthQuery::Privilege::CONSTRAINT);
+        break;
+    }
+  }
+
+  void Visit(ConstraintQuery &constraint_query) override { AddPrivilege(AuthQuery::Privilege::CONSTRAINT); }
+
+  void Visit(CypherQuery &query) override {
+    query.single_query_->Accept(*this);
+    for (auto *cypher_union : query.cypher_unions_) {
+      cypher_union->Accept(*this);
+    }
+  }
+
+  void Visit(DumpQuery &dump_query) override { AddPrivilege(AuthQuery::Privilege::DUMP); }
+
+  void Visit(LockPathQuery &lock_path_query) override { AddPrivilege(AuthQuery::Privilege::DURABILITY); }
+
+  void Visit(FreeMemoryQuery &free_memory_query) override { AddPrivilege(AuthQuery::Privilege::FREE_MEMORY); }
+
+  void Visit(TriggerQuery &trigger_query) override { AddPrivilege(AuthQuery::Privilege::TRIGGER); }
+
+  void Visit(StreamQuery &stream_query) override { AddPrivilege(AuthQuery::Privilege::STREAM); }
+
+  void Visit(ReplicationQuery &replication_query) override { AddPrivilege(AuthQuery::Privilege::REPLICATION); }
+
+  void Visit(IsolationLevelQuery &isolation_level_query) override { AddPrivilege(AuthQuery::Privilege::CONFIG); }
+
+  void Visit(CreateSnapshotQuery &create_snapshot_query) override { AddPrivilege(AuthQuery::Privilege::DURABILITY); }
+
+  void Visit(SettingQuery & /*setting_query*/) override { AddPrivilege(AuthQuery::Privilege::CONFIG); }
+
+  void Visit(VersionQuery & /*version_query*/) override { AddPrivilege(AuthQuery::Privilege::STATS); }
+
+  void Visit(SchemaQuery & /*schema_query*/) override { AddPrivilege(AuthQuery::Privilege::SCHEMA); }
+
+  bool PreVisit(Create & /*unused*/) override {
+    AddPrivilege(AuthQuery::Privilege::CREATE);
+    return false;
+  }
+  bool PreVisit(CallProcedure &procedure) override {
+    const auto maybe_proc =
+        procedure::FindProcedure(procedure::gModuleRegistry, procedure.procedure_name_, utils::NewDeleteResource());
+    if (maybe_proc && maybe_proc->second->info.required_privilege) {
+      AddPrivilege(*maybe_proc->second->info.required_privilege);
+    }
+    return false;
+  }
+  bool PreVisit(Delete & /*unused*/) override {
+    AddPrivilege(AuthQuery::Privilege::DELETE);
+    return false;
+  }
+  bool PreVisit(Match & /*unused*/) override {
+    AddPrivilege(AuthQuery::Privilege::MATCH);
+    return false;
+  }
+  bool PreVisit(Merge & /*unused*/) override {
+    AddPrivilege(AuthQuery::Privilege::MERGE);
+    return false;
+  }
+  bool PreVisit(SetProperty & /*unused*/) override {
+    AddPrivilege(AuthQuery::Privilege::SET);
+    return false;
+  }
+  bool PreVisit(SetProperties & /*unused*/) override {
+    AddPrivilege(AuthQuery::Privilege::SET);
+    return false;
+  }
+  bool PreVisit(SetLabels & /*unused*/) override {
+    AddPrivilege(AuthQuery::Privilege::SET);
+    return false;
+  }
+  bool PreVisit(RemoveProperty & /*unused*/) override {
+    AddPrivilege(AuthQuery::Privilege::REMOVE);
+    return false;
+  }
+  bool PreVisit(RemoveLabels & /*unused*/) override {
+    AddPrivilege(AuthQuery::Privilege::REMOVE);
+    return false;
+  }
+  bool PreVisit(LoadCsv & /*unused*/) override {
+    AddPrivilege(AuthQuery::Privilege::READ_FILE);
+    return false;
+  }
+
+  bool Visit(Identifier & /*unused*/) override { return true; }
+  bool Visit(PrimitiveLiteral & /*unused*/) override { return true; }
+  bool Visit(ParameterLookup & /*unused*/) override { return true; }
+
+ private:
+  void AddPrivilege(AuthQuery::Privilege privilege) {
+    if (!utils::Contains(privileges_, privilege)) {
+      privileges_.push_back(privilege);
+    }
+  }
+
+  std::vector<AuthQuery::Privilege> privileges_;
+};
+
+std::vector<AuthQuery::Privilege> GetRequiredPrivileges(Query *query) {
+  PrivilegeExtractor extractor;
+  query->Accept(extractor);
+  return extractor.privileges();
+}
+
+}  // namespace memgraph::query::v2

src/query/v2/frontend/semantic/required_privileges.hpp

@@ -0,0 +1,18 @@
+// 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.
+
+#pragma once
+
+#include "query/v2/frontend/ast/ast.hpp"
+
+namespace memgraph::query::v2 {
+std::vector<AuthQuery::Privilege> GetRequiredPrivileges(Query *query);
+}  // namespace memgraph::query::v2

src/query/v2/frontend/semantic/symbol.lcp

@@ -0,0 +1,89 @@
+;; 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.
+
+#>cpp
+#pragma once
+
+#include <string>
+
+#include "utils/typeinfo.hpp"
+cpp<#
+
+(lcp:namespace memgraph)
+(lcp:namespace query)
+(lcp:namespace v2)
+
+(lcp:define-class symbol ()
+  ((name "std::string" :scope :public)
+   (position :int64_t :scope :public)
+   (user-declared :bool :initval "true" :scope :public)
+   (type "Type" :initval "Type::ANY" :scope :public)
+   (token-position :int64_t :initval "-1" :scope :public))
+  (:public
+    ;; This is similar to TypedValue::Type, but this has `Any` type.
+    ;; TODO: Make a better Type structure which can store a generic List.
+    (lcp:define-enum type (any vertex edge path number edge-list)
+      (:serialize))
+    #>cpp
+    // 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_; }
+    cpp<#)
+  (:serialize (:slk)))
+
+(lcp:pop-namespace) ;; v2
+(lcp:pop-namespace) ;; query
+(lcp:pop-namespace) ;; memgraph
+
+#>cpp
+namespace std {
+
+template <>
+struct hash<memgraph::query::v2::Symbol> {
+  size_t operator()(const memgraph::query::v2::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
+
+cpp<#

src/query/v2/frontend/semantic/symbol_generator.cpp

@@ -0,0 +1,625 @@
+// 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.
+
+// Copyright 2017 Memgraph
+//
+// Created by Teon Banek on 24-03-2017
+
+#include "query/v2/frontend/semantic/symbol_generator.hpp"
+
+#include <algorithm>
+#include <optional>
+#include <ranges>
+#include <unordered_set>
+#include <variant>
+
+#include "query/v2/frontend/ast/ast.hpp"
+#include "query/v2/frontend/ast/ast_visitor.hpp"
+#include "utils/algorithm.hpp"
+#include "utils/logging.hpp"
+
+namespace memgraph::query::v2 {
+
+namespace {
+std::unordered_map<std::string, Identifier *> GeneratePredefinedIdentifierMap(
+    const std::vector<Identifier *> &predefined_identifiers) {
+  std::unordered_map<std::string, Identifier *> identifier_map;
+  for (const auto &identifier : predefined_identifiers) {
+    identifier_map.emplace(identifier->name_, identifier);
+  }
+
+  return identifier_map;
+}
+}  // namespace
+
+SymbolGenerator::SymbolGenerator(SymbolTable *symbol_table, const std::vector<Identifier *> &predefined_identifiers)
+    : symbol_table_(symbol_table),
+      predefined_identifiers_{GeneratePredefinedIdentifierMap(predefined_identifiers)},
+      scopes_(1, Scope()) {}
+
+std::optional<Symbol> SymbolGenerator::FindSymbolInScope(const std::string &name, const Scope &scope,
+                                                         Symbol::Type type) {
+  if (auto it = scope.symbols.find(name); it != scope.symbols.end()) {
+    const auto &symbol = it->second;
+    // Unless we have `ANY` type, check that types match.
+    if (type != Symbol::Type::ANY && symbol.type() != Symbol::Type::ANY && type != symbol.type()) {
+      throw TypeMismatchError(name, Symbol::TypeToString(symbol.type()), Symbol::TypeToString(type));
+    }
+    return symbol;
+  }
+  return std::nullopt;
+}
+
+auto SymbolGenerator::CreateSymbol(const std::string &name, bool user_declared, Symbol::Type type, int token_position) {
+  auto symbol = symbol_table_->CreateSymbol(name, user_declared, type, token_position);
+  scopes_.back().symbols[name] = symbol;
+  return symbol;
+}
+
+auto SymbolGenerator::GetOrCreateSymbolLocalScope(const std::string &name, bool user_declared, Symbol::Type type) {
+  auto &scope = scopes_.back();
+  if (auto maybe_symbol = FindSymbolInScope(name, scope, type); maybe_symbol) {
+    return *maybe_symbol;
+  }
+  return CreateSymbol(name, user_declared, type);
+}
+
+auto SymbolGenerator::GetOrCreateSymbol(const std::string &name, bool user_declared, Symbol::Type type) {
+  // NOLINTNEXTLINE
+  for (auto scope = scopes_.rbegin(); scope != scopes_.rend(); ++scope) {
+    if (auto maybe_symbol = FindSymbolInScope(name, *scope, type); maybe_symbol) {
+      return *maybe_symbol;
+    }
+  }
+  return CreateSymbol(name, user_declared, type);
+}
+
+void SymbolGenerator::VisitReturnBody(ReturnBody &body, Where *where) {
+  auto &scope = scopes_.back();
+  for (auto &expr : body.named_expressions) {
+    expr->Accept(*this);
+  }
+  std::vector<Symbol> user_symbols;
+  if (body.all_identifiers) {
+    // Carry over user symbols because '*' appeared.
+    for (const auto &sym_pair : scope.symbols) {
+      if (!sym_pair.second.user_declared()) {
+        continue;
+      }
+      user_symbols.emplace_back(sym_pair.second);
+    }
+    if (user_symbols.empty()) {
+      throw SemanticException("There are no variables in scope to use for '*'.");
+    }
+  }
+  // WITH/RETURN clause removes declarations of all the previous variables and
+  // declares only those established through named expressions. New declarations
+  // must not be visible inside named expressions themselves.
+  bool removed_old_names = false;
+  if ((!where && body.order_by.empty()) || scope.has_aggregation) {
+    // WHERE and ORDER BY need to see both the old and new symbols, unless we
+    // have an aggregation. Therefore, we can clear the symbols immediately if
+    // there is neither ORDER BY nor WHERE, or we have an aggregation.
+    scope.symbols.clear();
+    removed_old_names = true;
+  }
+  // Create symbols for named expressions.
+  std::unordered_set<std::string> new_names;
+  for (const auto &user_sym : user_symbols) {
+    new_names.insert(user_sym.name());
+    scope.symbols[user_sym.name()] = user_sym;
+  }
+  for (auto &named_expr : body.named_expressions) {
+    const auto &name = named_expr->name_;
+    if (!new_names.insert(name).second) {
+      throw SemanticException("Multiple results with the same name '{}' are not allowed.", name);
+    }
+    // An improvement would be to infer the type of the expression, so that the
+    // new symbol would have a more specific type.
+    named_expr->MapTo(CreateSymbol(name, true, Symbol::Type::ANY, named_expr->token_position_));
+  }
+  scope.in_order_by = true;
+  for (const auto &order_pair : body.order_by) {
+    order_pair.expression->Accept(*this);
+  }
+  scope.in_order_by = false;
+  if (body.skip) {
+    scope.in_skip = true;
+    body.skip->Accept(*this);
+    scope.in_skip = false;
+  }
+  if (body.limit) {
+    scope.in_limit = true;
+    body.limit->Accept(*this);
+    scope.in_limit = false;
+  }
+  if (where) where->Accept(*this);
+  if (!removed_old_names) {
+    // We have an ORDER BY or WHERE, but no aggregation, which means we didn't
+    // clear the old symbols, so do it now. We cannot just call clear, because
+    // we've added new symbols.
+    for (auto sym_it = scope.symbols.begin(); sym_it != scope.symbols.end();) {
+      if (new_names.find(sym_it->first) == new_names.end()) {
+        sym_it = scope.symbols.erase(sym_it);
+      } else {
+        sym_it++;
+      }
+    }
+  }
+  scopes_.back().has_aggregation = false;
+}
+
+// Query
+
+bool SymbolGenerator::PreVisit(SingleQuery &) {
+  prev_return_names_ = curr_return_names_;
+  curr_return_names_.clear();
+  return true;
+}
+
+// Union
+
+bool SymbolGenerator::PreVisit(CypherUnion &) {
+  scopes_.back() = Scope();
+  return true;
+}
+
+bool SymbolGenerator::PostVisit(CypherUnion &cypher_union) {
+  if (prev_return_names_ != curr_return_names_) {
+    throw SemanticException("All subqueries in an UNION must have the same column names.");
+  }
+
+  // create new symbols for the result of the union
+  for (const auto &name : curr_return_names_) {
+    auto symbol = CreateSymbol(name, false);
+    cypher_union.union_symbols_.push_back(symbol);
+  }
+
+  return true;
+}
+
+// Clauses
+
+bool SymbolGenerator::PreVisit(Create &) {
+  scopes_.back().in_create = true;
+  return true;
+}
+bool SymbolGenerator::PostVisit(Create &) {
+  scopes_.back().in_create = false;
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(CallProcedure &call_proc) {
+  for (auto *expr : call_proc.arguments_) {
+    expr->Accept(*this);
+  }
+  return false;
+}
+
+bool SymbolGenerator::PostVisit(CallProcedure &call_proc) {
+  for (auto *ident : call_proc.result_identifiers_) {
+    if (HasSymbolLocalScope(ident->name_)) {
+      throw RedeclareVariableError(ident->name_);
+    }
+    ident->MapTo(CreateSymbol(ident->name_, true));
+  }
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(LoadCsv &load_csv) { return false; }
+
+bool SymbolGenerator::PostVisit(LoadCsv &load_csv) {
+  if (HasSymbolLocalScope(load_csv.row_var_->name_)) {
+    throw RedeclareVariableError(load_csv.row_var_->name_);
+  }
+  load_csv.row_var_->MapTo(CreateSymbol(load_csv.row_var_->name_, true));
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(Return &ret) {
+  auto &scope = scopes_.back();
+  scope.in_return = true;
+  VisitReturnBody(ret.body_);
+  scope.in_return = false;
+  return false;  // We handled the traversal ourselves.
+}
+
+bool SymbolGenerator::PostVisit(Return &) {
+  for (const auto &name_symbol : scopes_.back().symbols) curr_return_names_.insert(name_symbol.first);
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(With &with) {
+  auto &scope = scopes_.back();
+  scope.in_with = true;
+  VisitReturnBody(with.body_, with.where_);
+  scope.in_with = false;
+  return false;  // We handled the traversal ourselves.
+}
+
+bool SymbolGenerator::PreVisit(Where &) {
+  scopes_.back().in_where = true;
+  return true;
+}
+bool SymbolGenerator::PostVisit(Where &) {
+  scopes_.back().in_where = false;
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(Merge &) {
+  scopes_.back().in_merge = true;
+  return true;
+}
+bool SymbolGenerator::PostVisit(Merge &) {
+  scopes_.back().in_merge = false;
+  return true;
+}
+
+bool SymbolGenerator::PostVisit(Unwind &unwind) {
+  const auto &name = unwind.named_expression_->name_;
+  if (HasSymbolLocalScope(name)) {
+    throw RedeclareVariableError(name);
+  }
+  unwind.named_expression_->MapTo(CreateSymbol(name, true));
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(Match &) {
+  scopes_.back().in_match = true;
+  return true;
+}
+bool SymbolGenerator::PostVisit(Match &) {
+  auto &scope = scopes_.back();
+  scope.in_match = false;
+  // Check variables in property maps after visiting Match, so that they can
+  // reference symbols out of bind order.
+  for (auto &ident : scope.identifiers_in_match) {
+    if (!HasSymbolLocalScope(ident->name_) && !ConsumePredefinedIdentifier(ident->name_))
+      throw UnboundVariableError(ident->name_);
+    ident->MapTo(scope.symbols[ident->name_]);
+  }
+  scope.identifiers_in_match.clear();
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(Foreach &for_each) {
+  const auto &name = for_each.named_expression_->name_;
+  scopes_.emplace_back(Scope());
+  scopes_.back().in_foreach = true;
+  for_each.named_expression_->MapTo(
+      CreateSymbol(name, true, Symbol::Type::ANY, for_each.named_expression_->token_position_));
+  return true;
+}
+bool SymbolGenerator::PostVisit([[maybe_unused]] Foreach &for_each) {
+  scopes_.pop_back();
+  return true;
+}
+
+// Expressions
+
+SymbolGenerator::ReturnType SymbolGenerator::Visit(Identifier &ident) {
+  auto &scope = scopes_.back();
+  if (scope.in_skip || scope.in_limit) {
+    throw SemanticException("Variables are not allowed in {}.", scope.in_skip ? "SKIP" : "LIMIT");
+  }
+  Symbol symbol;
+  if (scope.in_pattern && !(scope.in_node_atom || scope.visiting_edge)) {
+    // If we are in the pattern, and outside of a node or an edge, the
+    // identifier is the pattern name.
+    symbol = GetOrCreateSymbolLocalScope(ident.name_, ident.user_declared_, Symbol::Type::PATH);
+  } else if (scope.in_pattern && scope.in_pattern_atom_identifier) {
+    //  Patterns used to create nodes and edges cannot redeclare already
+    //  established bindings. Declaration only happens in single node
+    //  patterns and in edge patterns. OpenCypher example,
+    //  `MATCH (n) CREATE (n)` should throw an error that `n` is already
+    //  declared. While `MATCH (n) CREATE (n) -[:R]-> (n)` is allowed,
+    //  since `n` now references the bound node instead of declaring it.
+    if ((scope.in_create_node || scope.in_create_edge) && HasSymbolLocalScope(ident.name_)) {
+      throw RedeclareVariableError(ident.name_);
+    }
+    auto type = Symbol::Type::VERTEX;
+    if (scope.visiting_edge) {
+      // Edge referencing is not allowed (like in Neo4j):
+      // `MATCH (n) - [r] -> (n) - [r] -> (n) RETURN r` is not allowed.
+      if (HasSymbolLocalScope(ident.name_)) {
+        throw RedeclareVariableError(ident.name_);
+      }
+      type = scope.visiting_edge->IsVariable() ? Symbol::Type::EDGE_LIST : Symbol::Type::EDGE;
+    }
+    symbol = GetOrCreateSymbolLocalScope(ident.name_, ident.user_declared_, type);
+  } else if (scope.in_pattern && !scope.in_pattern_atom_identifier && scope.in_match) {
+    if (scope.in_edge_range && scope.visiting_edge->identifier_->name_ == ident.name_) {
+      // Prevent variable path bounds to reference the identifier which is bound
+      // by the variable path itself.
+      throw UnboundVariableError(ident.name_);
+    }
+    // Variables in property maps or bounds of variable length path during MATCH
+    // can reference symbols bound later in the same MATCH. We collect them
+    // here, so that they can be checked after visiting Match.
+    scope.identifiers_in_match.emplace_back(&ident);
+  } else {
+    // Everything else references a bound symbol.
+    if (!HasSymbol(ident.name_) && !ConsumePredefinedIdentifier(ident.name_)) throw UnboundVariableError(ident.name_);
+    symbol = GetOrCreateSymbol(ident.name_, ident.user_declared_, Symbol::Type::ANY);
+  }
+  ident.MapTo(symbol);
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(Aggregation &aggr) {
+  auto &scope = scopes_.back();
+  // Check if the aggregation can be used in this context. This check should
+  // probably move to a separate phase, which checks if the query is well
+  // formed.
+  if ((!scope.in_return && !scope.in_with) || scope.in_order_by || scope.in_skip || scope.in_limit || scope.in_where) {
+    throw SemanticException("Aggregation functions are only allowed in WITH and RETURN.");
+  }
+  if (scope.in_aggregation) {
+    throw SemanticException(
+        "Using aggregation functions inside aggregation functions is not "
+        "allowed.");
+  }
+  if (scope.num_if_operators) {
+    // Neo allows aggregations here and produces very interesting behaviors.
+    // To simplify implementation at this moment we decided to completely
+    // disallow aggregations inside of the CASE.
+    // However, in some cases aggregation makes perfect sense, for example:
+    //    CASE count(n) WHEN 10 THEN "YES" ELSE "NO" END.
+    // TODO: Rethink of allowing aggregations in some parts of the CASE
+    // construct.
+    throw SemanticException("Using aggregation functions inside of CASE is not allowed.");
+  }
+  // Create a virtual symbol for aggregation result.
+  // Currently, we only have aggregation operators which return numbers.
+  auto aggr_name = Aggregation::OpToString(aggr.op_) + std::to_string(aggr.symbol_pos_);
+  aggr.MapTo(CreateSymbol(aggr_name, false, Symbol::Type::NUMBER));
+  scope.in_aggregation = true;
+  scope.has_aggregation = true;
+  return true;
+}
+
+bool SymbolGenerator::PostVisit(Aggregation &) {
+  scopes_.back().in_aggregation = false;
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(IfOperator &) {
+  ++scopes_.back().num_if_operators;
+  return true;
+}
+
+bool SymbolGenerator::PostVisit(IfOperator &) {
+  --scopes_.back().num_if_operators;
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(All &all) {
+  all.list_expression_->Accept(*this);
+  VisitWithIdentifiers(all.where_->expression_, {all.identifier_});
+  return false;
+}
+
+bool SymbolGenerator::PreVisit(Single &single) {
+  single.list_expression_->Accept(*this);
+  VisitWithIdentifiers(single.where_->expression_, {single.identifier_});
+  return false;
+}
+
+bool SymbolGenerator::PreVisit(Any &any) {
+  any.list_expression_->Accept(*this);
+  VisitWithIdentifiers(any.where_->expression_, {any.identifier_});
+  return false;
+}
+
+bool SymbolGenerator::PreVisit(None &none) {
+  none.list_expression_->Accept(*this);
+  VisitWithIdentifiers(none.where_->expression_, {none.identifier_});
+  return false;
+}
+
+bool SymbolGenerator::PreVisit(Reduce &reduce) {
+  reduce.initializer_->Accept(*this);
+  reduce.list_->Accept(*this);
+  VisitWithIdentifiers(reduce.expression_, {reduce.accumulator_, reduce.identifier_});
+  return false;
+}
+
+bool SymbolGenerator::PreVisit(Extract &extract) {
+  extract.list_->Accept(*this);
+  VisitWithIdentifiers(extract.expression_, {extract.identifier_});
+  return false;
+}
+
+// Pattern and its subparts.
+
+bool SymbolGenerator::PreVisit(Pattern &pattern) {
+  auto &scope = scopes_.back();
+  scope.in_pattern = true;
+  if ((scope.in_create || scope.in_merge) && pattern.atoms_.size() == 1U) {
+    MG_ASSERT(utils::IsSubtype(*pattern.atoms_[0], NodeAtom::kType), "Expected a single NodeAtom in Pattern");
+    scope.in_create_node = true;
+  }
+  return true;
+}
+
+bool SymbolGenerator::PostVisit(Pattern &) {
+  auto &scope = scopes_.back();
+  scope.in_pattern = false;
+  scope.in_create_node = false;
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(NodeAtom &node_atom) {
+  auto &scope = scopes_.back();
+  auto check_node_semantic = [&node_atom, &scope, this](const bool props_or_labels) {
+    const auto &node_name = node_atom.identifier_->name_;
+    if ((scope.in_create || scope.in_merge) && props_or_labels && HasSymbolLocalScope(node_name)) {
+      throw SemanticException("Cannot create node '" + node_name +
+                              "' with labels or properties, because it is already declared.");
+    }
+    scope.in_pattern_atom_identifier = true;
+    node_atom.identifier_->Accept(*this);
+    scope.in_pattern_atom_identifier = false;
+  };
+
+  scope.in_node_atom = true;
+  if (auto *properties = std::get_if<std::unordered_map<PropertyIx, Expression *>>(&node_atom.properties_)) {
+    bool props_or_labels = !properties->empty() || !node_atom.labels_.empty();
+
+    check_node_semantic(props_or_labels);
+    for (auto kv : *properties) {
+      kv.second->Accept(*this);
+    }
+
+    return false;
+  }
+  auto &properties_parameter = std::get<ParameterLookup *>(node_atom.properties_);
+  bool props_or_labels = !properties_parameter || !node_atom.labels_.empty();
+
+  check_node_semantic(props_or_labels);
+  properties_parameter->Accept(*this);
+  return false;
+}
+
+bool SymbolGenerator::PostVisit(NodeAtom &) {
+  scopes_.back().in_node_atom = false;
+  return true;
+}
+
+bool SymbolGenerator::PreVisit(EdgeAtom &edge_atom) {
+  auto &scope = scopes_.back();
+  scope.visiting_edge = &edge_atom;
+  if (scope.in_create || scope.in_merge) {
+    scope.in_create_edge = true;
+    if (edge_atom.edge_types_.size() != 1U) {
+      throw SemanticException(
+          "A single relationship type must be specified "
+          "when creating an edge.");
+    }
+    if (scope.in_create &&  // Merge allows bidirectionality
+        edge_atom.direction_ == EdgeAtom::Direction::BOTH) {
+      throw SemanticException(
+          "Bidirectional relationship are not supported "
+          "when creating an edge");
+    }
+    if (edge_atom.IsVariable()) {
+      throw SemanticException(
+          "Variable length relationships are not supported when creating an "
+          "edge.");
+    }
+  }
+  if (auto *properties = std::get_if<std::unordered_map<PropertyIx, Expression *>>(&edge_atom.properties_)) {
+    for (auto kv : *properties) {
+      kv.second->Accept(*this);
+    }
+  } else {
+    std::get<ParameterLookup *>(edge_atom.properties_)->Accept(*this);
+  }
+  if (edge_atom.IsVariable()) {
+    scope.in_edge_range = true;
+    if (edge_atom.lower_bound_) {
+      edge_atom.lower_bound_->Accept(*this);
+    }
+    if (edge_atom.upper_bound_) {
+      edge_atom.upper_bound_->Accept(*this);
+    }
+    scope.in_edge_range = false;
+    scope.in_pattern = false;
+    if (edge_atom.filter_lambda_.expression) {
+      VisitWithIdentifiers(edge_atom.filter_lambda_.expression,
+                           {edge_atom.filter_lambda_.inner_edge, edge_atom.filter_lambda_.inner_node});
+    } else {
+      // Create inner symbols, but don't bind them in scope, since they are to
+      // be used in the missing filter expression.
+      auto *inner_edge = edge_atom.filter_lambda_.inner_edge;
+      inner_edge->MapTo(symbol_table_->CreateSymbol(inner_edge->name_, inner_edge->user_declared_, Symbol::Type::EDGE));
+      auto *inner_node = edge_atom.filter_lambda_.inner_node;
+      inner_node->MapTo(
+          symbol_table_->CreateSymbol(inner_node->name_, inner_node->user_declared_, Symbol::Type::VERTEX));
+    }
+    if (edge_atom.weight_lambda_.expression) {
+      VisitWithIdentifiers(edge_atom.weight_lambda_.expression,
+                           {edge_atom.weight_lambda_.inner_edge, edge_atom.weight_lambda_.inner_node});
+    }
+    scope.in_pattern = true;
+  }
+  scope.in_pattern_atom_identifier = true;
+  edge_atom.identifier_->Accept(*this);
+  scope.in_pattern_atom_identifier = false;
+  if (edge_atom.total_weight_) {
+    if (HasSymbolLocalScope(edge_atom.total_weight_->name_)) {
+      throw RedeclareVariableError(edge_atom.total_weight_->name_);
+    }
+    edge_atom.total_weight_->MapTo(GetOrCreateSymbolLocalScope(
+        edge_atom.total_weight_->name_, edge_atom.total_weight_->user_declared_, Symbol::Type::NUMBER));
+  }
+  return false;
+}
+
+bool SymbolGenerator::PostVisit(EdgeAtom &) {
+  auto &scope = scopes_.back();
+  scope.visiting_edge = nullptr;
+  scope.in_create_edge = false;
+  return true;
+}
+
+void SymbolGenerator::VisitWithIdentifiers(Expression *expr, const std::vector<Identifier *> &identifiers) {
+  auto &scope = scopes_.back();
+  std::vector<std::pair<std::optional<Symbol>, Identifier *>> prev_symbols;
+  // Collect previous symbols if they exist.
+  for (const auto &identifier : identifiers) {
+    std::optional<Symbol> prev_symbol;
+    auto prev_symbol_it = scope.symbols.find(identifier->name_);
+    if (prev_symbol_it != scope.symbols.end()) {
+      prev_symbol = prev_symbol_it->second;
+    }
+    identifier->MapTo(CreateSymbol(identifier->name_, identifier->user_declared_));
+    prev_symbols.emplace_back(prev_symbol, identifier);
+  }
+  // Visit the expression with the new symbols bound.
+  expr->Accept(*this);
+  // Restore back to previous symbols.
+  for (const auto &prev : prev_symbols) {
+    const auto &prev_symbol = prev.first;
+    const auto &identifier = prev.second;
+    if (prev_symbol) {
+      scope.symbols[identifier->name_] = *prev_symbol;
+    } else {
+      scope.symbols.erase(identifier->name_);
+    }
+  }
+}
+
+bool SymbolGenerator::HasSymbol(const std::string &name) const {
+  return std::ranges::any_of(scopes_, [&name](const auto &scope) { return scope.symbols.contains(name); });
+}
+
+bool SymbolGenerator::HasSymbolLocalScope(const std::string &name) const {
+  return scopes_.back().symbols.contains(name);
+}
+
+bool SymbolGenerator::ConsumePredefinedIdentifier(const std::string &name) {
+  auto it = predefined_identifiers_.find(name);
+
+  if (it == predefined_identifiers_.end()) {
+    return false;
+  }
+
+  // we can only use the predefined identifier in a single scope so we remove it after creating
+  // a symbol for it
+  auto &identifier = it->second;
+  MG_ASSERT(!identifier->user_declared_, "Predefined symbols cannot be user declared!");
+  identifier->MapTo(CreateSymbol(identifier->name_, identifier->user_declared_));
+  predefined_identifiers_.erase(it);
+  return true;
+}
+
+}  // namespace memgraph::query::v2