Throw exception not assert

.github/workflows/diff.yaml

@@ -130,7 +130,7 @@ jobs:
           source /opt/toolchain-v4/activate
 
           # Restrict clang-tidy results only to the modified parts
-          git diff -U0 ${{ env.BASE_BRANCH }}... -- src | ./tools/github/clang-tidy/clang-tidy-diff.py -p 1 -j $THREADS -extra-arg="-DMG_CLANG_TIDY_CHECK" -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
@@ -171,7 +171,7 @@ jobs:
 
           # Run leftover CTest tests (all except unit and benchmark tests).
           cd build
-          ctest -E "(memgraph__unit|memgraph__benchmark|memgraph__simulation)" --output-on-failure
+          ctest -E "(memgraph__unit|memgraph__benchmark)" --output-on-failure
 
       - name: Run drivers tests
         run: |
@@ -262,15 +262,6 @@ 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.

.github/workflows/full_clang_tidy.yaml

@@ -39,7 +39,7 @@ jobs:
           source /opt/toolchain-v4/activate
 
           # The results are also written to standard output in order to retain them in the logs
-          ./tools/github/clang-tidy/run-clang-tidy.py -p build -j $THREADS -extra-arg="-DMG_CLANG_TIDY_CHECK" -clang-tidy-binary=/opt/toolchain-v4/bin/clang-tidy "$PWD/src/*" |
+          ./tools/github/clang-tidy/run-clang-tidy.py -p build -j $THREADS -clang-tidy-binary=/opt/toolchain-v4/bin/clang-tidy "$PWD/src/*" |
             tee ./build/full_clang_tidy_output.txt
 
       - name: Summarize clang-tidy results

.gitignore

@@ -24,7 +24,6 @@ cmake/DownloadProject/
 dist/
 src/query/frontend/opencypher/generated/
 src/query/v2/frontend/opencypher/generated/
-src/parser/opencypher/generated
 tags
 ve/
 ve3/
@@ -54,7 +53,6 @@ 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/storage/v3/bindings/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
@@ -62,15 +60,12 @@ 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/expr/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/parser/opencypher/generated
-src/expr/semantic/symbol.hpp
 src/raft/log_entry.hpp
 src/raft/raft_rpc_messages.hpp
 src/raft/snapshot_metadata.hpp

src/CMakeLists.txt

@@ -5,7 +5,6 @@ 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)
@@ -18,9 +17,6 @@ add_subdirectory(query/v2)
 add_subdirectory(slk)
 add_subdirectory(rpc)
 add_subdirectory(auth)
-add_subdirectory(parser)
-add_subdirectory(expr)
-add_subdirectory(coordinator)
 
 if (MG_ENTERPRISE)
   add_subdirectory(audit)
@@ -37,13 +33,13 @@ include_directories(${CMAKE_CURRENT_BINARY_DIR})
 # Memgraph Single Node v2 Executable
 # ----------------------------------------------------------------------------
 set(mg_single_node_v2_sources
-    glue/communication.cpp
+    glue/v2/communication.cpp
     memgraph.cpp
-    glue/auth.cpp
+    glue/v2/auth.cpp
 )
 
 set(mg_single_node_v2_libs stdc++fs Threads::Threads
-    telemetry_lib mg-query mg-communication mg-memory mg-utils mg-auth mg-license mg-settings)
+    telemetry_lib mg-query-v2 mg-communication mg-memory mg-utils mg-auth mg-license mg-settings)
 if (MG_ENTERPRISE)
   # These are enterprise subsystems
   set(mg_single_node_v2_libs ${mg_single_node_v2_libs} mg-audit)
@@ -128,7 +124,7 @@ install(CODE "file(MAKE_DIRECTORY \$ENV{DESTDIR}/var/log/memgraph
 # ----------------------------------------------------------------------------
 
 add_executable(mg_import_csv mg_import_csv.cpp)
-target_link_libraries(mg_import_csv mg-storage-v2)
+target_link_libraries(mg_import_csv mg-storage-v3)
 
 # Strip the executable in release build.
 if (lower_build_type STREQUAL "release")

src/audit/CMakeLists.txt

@@ -5,4 +5,4 @@ find_package(gflags REQUIRED)
 
 add_library(mg-audit STATIC ${audit_src_files})
 target_link_libraries(mg-audit json gflags fmt::fmt)
-target_link_libraries(mg-audit mg-utils mg-storage-v2)
+target_link_libraries(mg-audit mg-utils mg-storage-v3)

src/coordinator/CMakeLists.txt

@@ -1,9 +0,0 @@
-set(coordinator_src_files
-    coordinator.cpp
-    shard_map.cpp)
-
-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 mg-storage-v3)

src/coordinator/coordinator.cpp

@@ -1,129 +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 <coordinator/coordinator.hpp>
-
-namespace memgraph::coordinator {
-
-CoordinatorWriteResponses Coordinator::ApplyWrite(HeartbeatRequest &&heartbeat_request) {
-  spdlog::info("Coordinator handling HeartbeatRequest");
-
-  // add this storage engine to any under-replicated shards that it is not already a part of
-
-  auto initializing_rsms_for_shard_manager =
-      shard_map_.AssignShards(heartbeat_request.from_storage_manager, heartbeat_request.initialized_rsms);
-
-  return HeartbeatResponse{
-      .shards_to_initialize = initializing_rsms_for_shard_manager,
-  };
-}
-
-CoordinatorWriteResponses Coordinator::ApplyWrite(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 = Hlc{
-      .logical_id = ++highest_allocated_timestamp_,
-      // TODO(tyler) probably pass some more context to the Coordinator here
-      // so that we can use our wall clock and enforce monotonicity.
-      // .coordinator_wall_clock = io_.Now(),
-  };
-
-  // Allways return fresher shard_map for now.
-  res.fresher_shard_map = std::make_optional(shard_map_);
-
-  return res;
-}
-
-CoordinatorWriteResponses Coordinator::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.
-CoordinatorWriteResponses Coordinator::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_id,
-                                        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.
-CoordinatorWriteResponses Coordinator::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.
-CoordinatorWriteResponses Coordinator::ApplyWrite(
-    DeregisterStorageEngineRequest && /* register_storage_engine_request */) {
-  DeregisterStorageEngineResponse res{};
-  // TODO
-
-  return res;
-}
-
-CoordinatorWriteResponses Coordinator::ApplyWrite(InitializeLabelRequest &&initialize_label_request) {
-  InitializeLabelResponse res{};
-
-  std::optional<LabelId> new_label_id = shard_map_.InitializeNewLabel(
-      initialize_label_request.label_name, initialize_label_request.schema, initialize_label_request.replication_factor,
-      initialize_label_request.last_shard_map_version);
-
-  if (new_label_id) {
-    res.new_label_id = new_label_id.value();
-    res.fresher_shard_map = std::nullopt;
-    res.success = true;
-  } else {
-    res.fresher_shard_map = shard_map_;
-    res.success = false;
-  }
-
-  return res;
-}
-
-CoordinatorWriteResponses Coordinator::ApplyWrite(AllocatePropertyIdsRequest &&allocate_property_ids_request) {
-  AllocatePropertyIdsResponse res{};
-
-  auto property_ids = shard_map_.AllocatePropertyIds(allocate_property_ids_request.property_names);
-
-  res.property_ids = property_ids;
-
-  return res;
-}
-
-}  // namespace memgraph::coordinator

src/coordinator/coordinator.hpp

@@ -1,196 +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 <optional>
-#include <set>
-#include <string>
-#include <unordered_set>
-#include <variant>
-#include <vector>
-
-#include <boost/uuid/uuid.hpp>
-
-#include <coordinator/hybrid_logical_clock.hpp>
-#include <coordinator/shard_map.hpp>
-#include <io/simulator/simulator.hpp>
-#include <io/time.hpp>
-#include <io/transport.hpp>
-#include <storage/v3/id_types.hpp>
-#include <storage/v3/schemas.hpp>
-
-namespace memgraph::coordinator {
-
-using memgraph::io::Address;
-using memgraph::storage::v3::LabelId;
-using memgraph::storage::v3::PropertyId;
-using memgraph::storage::v3::SchemaProperty;
-using SimT = memgraph::io::simulator::SimulatorTransport;
-using PrimaryKey = std::vector<PropertyValue>;
-
-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 AllocatePropertyIdsRequest {
-  std::vector<std::string> property_names;
-};
-
-struct AllocatePropertyIdsResponse {
-  std::map<std::string, PropertyId> property_ids;
-};
-
-struct SplitShardRequest {
-  Hlc previous_shard_map_version;
-  LabelId label_id;
-  PrimaryKey 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;
-  std::vector<SchemaProperty> schema;
-  size_t replication_factor;
-  Hlc last_shard_map_version;
-};
-
-struct InitializeLabelResponse {
-  bool success;
-  LabelId new_label_id;
-  std::optional<ShardMap> fresher_shard_map;
-};
-
-struct HeartbeatRequest {
-  Address from_storage_manager;
-  std::set<boost::uuids::uuid> initialized_rsms;
-};
-
-struct HeartbeatResponse {
-  std::vector<ShardToInitialize> shards_to_initialize;
-};
-
-using CoordinatorWriteRequests =
-    std::variant<HlcRequest, AllocateEdgeIdBatchRequest, SplitShardRequest, RegisterStorageEngineRequest,
-                 DeregisterStorageEngineRequest, InitializeLabelRequest, AllocatePropertyIdsRequest, HeartbeatRequest>;
-using CoordinatorWriteResponses = std::variant<HlcResponse, AllocateEdgeIdBatchResponse, SplitShardResponse,
-                                               RegisterStorageEngineResponse, DeregisterStorageEngineResponse,
-                                               InitializeLabelResponse, AllocatePropertyIdsResponse, HeartbeatResponse>;
-
-using CoordinatorReadRequests = std::variant<GetShardMapRequest>;
-using CoordinatorReadResponses = std::variant<GetShardMapResponse>;
-
-class Coordinator {
- public:
-  explicit Coordinator(ShardMap sm) : shard_map_{std::move(sm)} {}
-
-  // NOLINTNEXTLINE(readability-convert-member-functions-to-static
-  CoordinatorReadResponses Read(CoordinatorReadRequests requests) {
-    return std::visit([&](auto &&request) { return HandleRead(std::forward<decltype(request)>(request)); },
-                      std::move(requests));  // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
-  }
-
-  // NOLINTNEXTLINE(readability-convert-member-functions-to-static
-  CoordinatorWriteResponses Apply(CoordinatorWriteRequests requests) {
-    return std::visit([&](auto &&request) mutable { return ApplyWrite(std::forward<decltype(request)>(request)); },
-                      std::move(requests));
-  }
-
- private:
-  ShardMap shard_map_;
-  uint64_t highest_allocated_timestamp_;
-
-  /// Query engines need to periodically request batches of unique edge IDs.
-  uint64_t highest_allocated_edge_id_;
-
-  CoordinatorReadResponses HandleRead(GetShardMapRequest && /* get_shard_map_request */) {
-    GetShardMapResponse res;
-    res.shard_map = shard_map_;
-    return res;
-  }
-
-  CoordinatorWriteResponses ApplyWrite(HeartbeatRequest &&heartbeat_request);
-
-  CoordinatorWriteResponses ApplyWrite(HlcRequest &&hlc_request);
-
-  CoordinatorWriteResponses ApplyWrite(AllocateEdgeIdBatchRequest &&ahr);
-
-  /// 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.
-  CoordinatorWriteResponses ApplyWrite(SplitShardRequest &&split_shard_request);
-
-  /// This adds the provided storage engine to the standby storage engine pool,
-  /// which can be used to rebalance storage over time.
-  static CoordinatorWriteResponses ApplyWrite(RegisterStorageEngineRequest && /* register_storage_engine_request */);
-
-  /// This begins the process of draining the provided storage engine from all raft
-  /// clusters that it might be participating in.
-  static CoordinatorWriteResponses ApplyWrite(DeregisterStorageEngineRequest && /* register_storage_engine_request */);
-
-  CoordinatorWriteResponses ApplyWrite(InitializeLabelRequest &&initialize_label_request);
-
-  CoordinatorWriteResponses ApplyWrite(AllocatePropertyIdsRequest &&allocate_property_ids_request);
-};
-
-}  // namespace memgraph::coordinator

src/coordinator/coordinator_client.hpp

@@ -1,24 +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 "coordinator/coordinator.hpp"
-#include "io/rsm/rsm_client.hpp"
-
-namespace memgraph::coordinator {
-
-using memgraph::io::rsm::RsmClient;
-
-template <typename IoImpl>
-using CoordinatorClient = RsmClient<IoImpl, CoordinatorWriteRequests, CoordinatorWriteResponses,
-                                    CoordinatorReadRequests, CoordinatorReadResponses>;
-}  // namespace memgraph::coordinator

src/coordinator/coordinator_rsm.hpp

@@ -1,23 +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 "coordinator/coordinator.hpp"
-#include "io/rsm/raft.hpp"
-
-namespace memgraph::coordinator {
-
-template <typename IoImpl>
-using CoordinatorRsm = memgraph::io::rsm::Raft<IoImpl, Coordinator, CoordinatorWriteRequests, CoordinatorWriteResponses,
-                                               CoordinatorReadRequests, CoordinatorReadResponses>;
-
-}  // namespace memgraph::coordinator

src/coordinator/hybrid_logical_clock.hpp

@@ -1,36 +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 <compare>
-
-#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;
-
-  auto operator<=>(const Hlc &other) const { return logical_id <=> other.logical_id; }
-
-  bool operator==(const Hlc &other) const = default;
-  bool operator<(const Hlc &other) const = default;
-  bool operator==(const uint64_t other) const { return logical_id == other; }
-  bool operator<(const uint64_t other) const { return logical_id < other; }
-  bool operator>=(const uint64_t other) const { return logical_id >= other; }
-};
-
-}  // namespace memgraph::coordinator

src/coordinator/shard_map.cpp

@@ -1,90 +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 "coordinator/shard_map.hpp"
-#include "storage/v3/temporal.hpp"
-
-namespace memgraph::coordinator {
-
-using memgraph::common::SchemaType;
-using memgraph::storage::v3::TemporalData;
-using memgraph::storage::v3::TemporalType;
-
-PrimaryKey SchemaToMinKey(const std::vector<SchemaProperty> &schema) {
-  PrimaryKey ret{};
-
-  const int64_t min_int = std::numeric_limits<int64_t>::min();
-
-  const TemporalData date{TemporalType::Date, min_int};
-  const TemporalData local_time{TemporalType::LocalTime, min_int};
-  const TemporalData local_date_time{TemporalType::LocalDateTime, min_int};
-  const TemporalData duration{TemporalType::Duration, min_int};
-
-  for (const auto &schema_property : schema) {
-    switch (schema_property.type) {
-      case SchemaType::BOOL:
-        ret.emplace_back(PropertyValue(false));
-        break;
-      case SchemaType::INT:
-        ret.emplace_back(PropertyValue(min_int));
-        break;
-      case SchemaType::STRING:
-        ret.emplace_back(PropertyValue(""));
-        break;
-      case SchemaType::DATE:
-        ret.emplace_back(PropertyValue(date));
-        break;
-      case SchemaType::LOCALTIME:
-        ret.emplace_back(PropertyValue(local_time));
-        break;
-      case SchemaType::LOCALDATETIME:
-        ret.emplace_back(PropertyValue(local_date_time));
-        break;
-      case SchemaType::DURATION:
-        ret.emplace_back(PropertyValue(duration));
-        break;
-    }
-  }
-
-  return ret;
-}
-
-std::optional<LabelId> ShardMap::InitializeNewLabel(std::string label_name, std::vector<SchemaProperty> schema,
-                                                    size_t replication_factor, Hlc last_shard_map_version) {
-  if (shard_map_version != last_shard_map_version || labels.contains(label_name)) {
-    return std::nullopt;
-  }
-
-  const LabelId label_id = LabelId::FromUint(++max_label_id);
-
-  labels.emplace(std::move(label_name), label_id);
-
-  PrimaryKey initial_key = SchemaToMinKey(schema);
-  Shard empty_shard = {};
-
-  Shards shards = {
-      {initial_key, empty_shard},
-  };
-
-  LabelSpace label_space{
-      .schema = std::move(schema),
-      .shards = shards,
-      .replication_factor = replication_factor,
-  };
-
-  label_spaces.emplace(label_id, label_space);
-
-  IncrementShardMapVersion();
-
-  return label_id;
-}
-
-}  // namespace memgraph::coordinator

src/coordinator/shard_map.hpp

@@ -1,276 +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 <limits>
-#include <map>
-#include <set>
-#include <vector>
-
-#include <boost/uuid/uuid.hpp>
-#include <boost/uuid/uuid_generators.hpp>
-
-#include "common/types.hpp"
-#include "coordinator/hybrid_logical_clock.hpp"
-#include "io/address.hpp"
-#include "storage/v3/config.hpp"
-#include "storage/v3/id_types.hpp"
-#include "storage/v3/property_value.hpp"
-#include "storage/v3/schemas.hpp"
-#include "storage/v3/temporal.hpp"
-
-namespace memgraph::coordinator {
-
-using memgraph::io::Address;
-using memgraph::storage::v3::Config;
-using memgraph::storage::v3::LabelId;
-using memgraph::storage::v3::PropertyId;
-using memgraph::storage::v3::PropertyValue;
-using memgraph::storage::v3::SchemaProperty;
-
-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;
-  friend bool operator<(const AddressAndStatus &lhs, const AddressAndStatus &rhs) { return lhs.address < rhs.address; }
-};
-
-using PrimaryKey = std::vector<PropertyValue>;
-using Shard = std::vector<AddressAndStatus>;
-using Shards = std::map<PrimaryKey, Shard>;
-using LabelName = std::string;
-using PropertyName = std::string;
-using PropertyMap = std::map<PropertyName, PropertyId>;
-
-struct ShardToInitialize {
-  boost::uuids::uuid uuid;
-  LabelId label_id;
-  PrimaryKey min_key;
-  std::optional<PrimaryKey> max_key;
-  Config config;
-};
-
-PrimaryKey SchemaToMinKey(const std::vector<SchemaProperty> &schema);
-
-struct LabelSpace {
-  std::vector<SchemaProperty> schema;
-  std::map<PrimaryKey, Shard> shards;
-  size_t replication_factor;
-};
-
-struct ShardMap {
-  Hlc shard_map_version;
-  uint64_t max_property_id;
-  std::map<PropertyName, PropertyId> properties;
-  uint64_t max_label_id;
-  std::map<LabelName, LabelId> labels;
-  std::map<LabelId, LabelSpace> label_spaces;
-  std::map<LabelId, std::vector<SchemaProperty>> schemas;
-
-  Shards GetShards(const LabelName &label) {
-    const auto id = labels.at(label);
-    auto &shards = label_spaces.at(id).shards;
-    return 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; }
-
-  // Returns the shard UUIDs that have been assigned but not yet acknowledged for this storage manager
-  std::vector<ShardToInitialize> AssignShards(Address storage_manager, std::set<boost::uuids::uuid> initialized) {
-    std::vector<ShardToInitialize> ret{};
-
-    bool mutated = false;
-
-    for (auto &[label_id, label_space] : label_spaces) {
-      for (auto &[low_key, shard] : label_space.shards) {
-        // TODO(tyler) avoid these triple-nested loops by having the heartbeat include better info
-        bool machine_contains_shard = false;
-
-        for (auto &aas : shard) {
-          if (initialized.contains(aas.address.unique_id)) {
-            spdlog::info("marking shard as full consensus participant: {}", aas.address.unique_id);
-            aas.status = Status::CONSENSUS_PARTICIPANT;
-            machine_contains_shard = true;
-          } else {
-            const bool same_machine = aas.address.last_known_ip == storage_manager.last_known_ip &&
-                                      aas.address.last_known_port == storage_manager.last_known_port;
-            if (same_machine) {
-              machine_contains_shard = true;
-              ret.push_back(ShardToInitialize{
-                  .uuid = aas.address.unique_id,
-                  .label_id = label_id,
-                  .min_key = low_key,
-                  .max_key = std::nullopt,
-                  .config = Config{},
-              });
-            }
-          }
-        }
-
-        if (!machine_contains_shard && shard.size() < label_space.replication_factor) {
-          Address address = storage_manager;
-
-          // TODO(tyler) use deterministic UUID so that coordinators don't diverge here
-          address.unique_id = boost::uuids::uuid{boost::uuids::random_generator()()},
-
-          ret.push_back(ShardToInitialize{
-              .uuid = address.unique_id,
-              .label_id = label_id,
-              .min_key = low_key,
-              .max_key = std::nullopt,
-              .config = Config{},
-          });
-
-          AddressAndStatus aas = {
-              .address = address,
-              .status = Status::INITIALIZING,
-          };
-
-          shard.emplace_back(aas);
-        }
-      }
-    }
-
-    if (mutated) {
-      IncrementShardMapVersion();
-    }
-
-    return ret;
-  }
-
-  bool SplitShard(Hlc previous_shard_map_version, LabelId label_id, const PrimaryKey &key) {
-    if (previous_shard_map_version != shard_map_version) {
-      return false;
-    }
-
-    auto &label_space = label_spaces.at(label_id);
-    auto &shards_in_map = label_space.shards;
-
-    MG_ASSERT(!shards_in_map.empty());
-    MG_ASSERT(!shards_in_map.contains(key));
-    MG_ASSERT(label_spaces.contains(label_id));
-
-    // Finding the Shard that the new PrimaryKey should map to.
-    auto prev = std::prev(shards_in_map.upper_bound(key));
-    Shard duplicated_shard = prev->second;
-
-    // Apply the split
-    shards_in_map[key] = duplicated_shard;
-
-    return true;
-  }
-
-  std::optional<LabelId> InitializeNewLabel(std::string label_name, std::vector<SchemaProperty> schema,
-                                            size_t replication_factor, Hlc last_shard_map_version);
-
-  void AddServer(Address server_address) {
-    // Find a random place for the server to plug in
-  }
-
-  LabelId GetLabelId(const std::string &label) const { return labels.at(label); }
-
-  Shards GetShardsForRange(const LabelName &label_name, const PrimaryKey &start_key, const PrimaryKey &end_key) const {
-    MG_ASSERT(start_key <= end_key);
-    MG_ASSERT(labels.contains(label_name));
-
-    LabelId label_id = labels.at(label_name);
-
-    const auto &label_space = label_spaces.at(label_id);
-
-    const auto &shards_for_label = label_space.shards;
-
-    MG_ASSERT(shards_for_label.begin()->first <= start_key,
-              "the ShardMap must always contain a minimal key that is less than or equal to any requested key");
-
-    auto it = std::prev(shards_for_label.upper_bound(start_key));
-    const auto end_it = shards_for_label.upper_bound(end_key);
-
-    Shards shards{};
-
-    std::copy(it, end_it, std::inserter(shards, shards.end()));
-
-    return shards;
-  }
-
-  Shard GetShardForKey(const LabelName &label_name, const PrimaryKey &key) const {
-    MG_ASSERT(labels.contains(label_name));
-
-    LabelId label_id = labels.at(label_name);
-
-    const auto &label_space = label_spaces.at(label_id);
-
-    MG_ASSERT(label_space.shards.begin()->first <= key,
-              "the ShardMap must always contain a minimal key that is less than or equal to any requested key");
-
-    return std::prev(label_space.shards.upper_bound(key))->second;
-  }
-
-  Shard GetShardForKey(const LabelId &label_id, const PrimaryKey &key) const {
-    MG_ASSERT(label_spaces.contains(label_id));
-
-    const auto &label_space = label_spaces.at(label_id);
-
-    MG_ASSERT(label_space.shards.begin()->first <= key,
-              "the ShardMap must always contain a minimal key that is less than or equal to any requested key");
-
-    return std::prev(label_space.shards.upper_bound(key))->second;
-  }
-
-  PropertyMap AllocatePropertyIds(const std::vector<PropertyName> &new_properties) {
-    PropertyMap ret{};
-
-    bool mutated = false;
-
-    for (const auto &property_name : new_properties) {
-      if (properties.contains(property_name)) {
-        auto property_id = properties.at(property_name);
-        ret.emplace(property_name, property_id);
-      } else {
-        mutated = true;
-
-        const PropertyId property_id = PropertyId::FromUint(++max_property_id);
-        ret.emplace(property_name, property_id);
-        properties.emplace(property_name, property_id);
-      }
-    }
-
-    if (mutated) {
-      IncrementShardMapVersion();
-    }
-
-    return ret;
-  }
-
-  std::optional<PropertyId> GetPropertyId(const std::string &property_name) const {
-    if (properties.contains(property_name)) {
-      return properties.at(property_name);
-    }
-
-    return std::nullopt;
-  }
-};
-
-}  // namespace memgraph::coordinator

src/expr/CMakeLists.txt

@@ -1,20 +0,0 @@
-define_add_lcp(add_lcp_expr lcp_expr_cpp_files generated_lcp_expr_files)
-
-add_lcp_expr(semantic/symbol.lcp)
-
-add_custom_target(generate_lcp_expr DEPENDS ${generated_lcp_expr_files})
-
-set(mg_expr_sources
-    ${lcp_expr_cpp_files}
-    parsing.cpp)
-
-find_package(Boost REQUIRED)
-
-add_library(mg-expr STATIC ${mg_expr_sources})
-add_dependencies(mg-expr generate_lcp_expr)
-target_include_directories(mg-expr PUBLIC ${CMAKE_SOURCE_DIR}/include)
-target_include_directories(mg-expr PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
-target_include_directories(mg-expr PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/ast)
-target_include_directories(mg-expr PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/interpret)
-target_include_directories(mg-expr PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/semantic)
-target_link_libraries(mg-expr cppitertools Boost::headers mg-utils mg-parser)

src/expr/ast.hpp

@@ -1,35 +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
-
-#ifndef MG_AST_INCLUDE_PATH
-#ifdef MG_CLANG_TIDY_CHECK
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define MG_AST_INCLUDE_PATH "query/v2/frontend/ast/ast.hpp"
-#else
-#error Missing AST include path
-#endif
-#endif
-
-#ifndef MG_INJECTED_NAMESPACE_NAME
-#ifdef MG_CLANG_TIDY_CHECK
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define MG_INJECTED_NAMESPACE_NAME memgraph::query::v2
-#else
-#error Missing AST namespace
-#endif
-#endif
-
-#include MG_AST_INCLUDE_PATH
-
-namespace memgraph::expr {
-using namespace MG_INJECTED_NAMESPACE_NAME;  // NOLINT(google-build-using-namespace)
-}  // namespace memgraph::expr

src/expr/ast/pretty_print.hpp

@@ -1,271 +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 <iostream>
-#include <type_traits>
-
-#include "expr/ast.hpp"
-#include "expr/typed_value.hpp"
-#include "utils/algorithm.hpp"
-#include "utils/logging.hpp"
-#include "utils/string.hpp"
-
-namespace memgraph::expr {
-namespace detail {
-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;
-}
-
-inline void PrintObject(std::ostream *out, const std::string &str) { *out << utils::Escape(str); }
-
-inline void PrintObject(std::ostream *out, Aggregation::Op op) { *out << Aggregation::OpToString(op); }
-
-inline void PrintObject(std::ostream *out, Expression *expr);
-
-inline void PrintObject(std::ostream *out, Identifier *expr) { PrintObject(out, static_cast<Expression *>(expr)); }
-
-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 T>
-void PrintObject(std::ostream *out, const std::vector<T, utils::Allocator<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 PrintObject(std::ostream *out, const utils::pmr::map<utils::pmr::string, T> &map) {
-  *out << "{";
-  utils::PrintIterable(*out, map, ", ", [](auto &stream, const auto &item) {
-    PrintObject(&stream, item.first);
-    stream << ": ";
-    PrintObject(&stream, item.second);
-  });
-  *out << "}";
-}
-
-template <typename T1, typename T2, typename T3>
-inline void PrintObject(std::ostream *out, const TypedValueT<T1, T2, T3> &value) {
-  using TypedValue = TypedValueT<T1, T2, T3>;
-  switch (value.type()) {
-    case TypedValue::Type::Null:
-      *out << "null";
-      break;
-    case TypedValue::Type::String:
-      PrintObject(out, value.ValueString());
-      break;
-    case TypedValue::Type::Bool:
-      *out << (value.ValueBool() ? "true" : "false");
-      break;
-    case TypedValue::Type::Int:
-      PrintObject(out, value.ValueInt());
-      break;
-    case TypedValue::Type::Double:
-      PrintObject(out, value.ValueDouble());
-      break;
-    case TypedValue::Type::List:
-      PrintObject(out, value.ValueList());
-      break;
-    case TypedValue::Type::Map:
-      PrintObject(out, value.ValueMap());
-      break;
-    case TypedValue::Type::Date:
-      PrintObject(out, value.ValueDate());
-      break;
-    case TypedValue::Type::Duration:
-      PrintObject(out, value.ValueDuration());
-      break;
-    case TypedValue::Type::LocalTime:
-      PrintObject(out, value.ValueLocalTime());
-      break;
-    case TypedValue::Type::LocalDateTime:
-      PrintObject(out, value.ValueLocalDateTime());
-      break;
-    default:
-      MG_ASSERT(false, "PrintObject(std::ostream *out, const TypedValue &value) should not reach here");
-  }
-}
-
-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...);
-}
-}  // namespace detail
-
-class ExpressionPrettyPrinter : public ExpressionVisitor<void> {
- public:
-  explicit ExpressionPrettyPrinter(std::ostream *out) : out_(out) {}
-
-  // Unary operators
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define UNARY_OPERATOR_VISIT(OP_NODE, OP_STR)      \
-  /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \
-  void Visit(OP_NODE &op) override { detail::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
-
-  // Binary operators
-// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define BINARY_OPERATOR_VISIT(OP_NODE, OP_STR)     \
-  /* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \
-  void Visit(OP_NODE &op) override { detail::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
-
-  // Other
-  void Visit(ListSlicingOperator &op) override {
-    detail::PrintOperator(out_, "ListSlicing", op.list_, op.lower_bound_, op.upper_bound_);
-  }
-
-  void Visit(IfOperator &op) override {
-    detail::PrintOperator(out_, "If", op.condition_, op.then_expression_, op.else_expression_);
-  }
-
-  void Visit(ListLiteral &op) override { detail::PrintOperator(out_, "ListLiteral", op.elements_); }
-
-  void Visit(MapLiteral &op) override {
-    std::map<std::string, Expression *> map;
-    for (const auto &kv : op.elements_) {
-      map[kv.first.name] = kv.second;
-    }
-    detail::PrintObject(out_, map);
-  }
-
-  void Visit(LabelsTest &op) override { detail::PrintOperator(out_, "LabelsTest", op.expression_); }
-
-  void Visit(Aggregation &op) override { detail::PrintOperator(out_, "Aggregation", op.op_); }
-
-  void Visit(Function &op) override { detail::PrintOperator(out_, "Function", op.function_name_, op.arguments_); }
-
-  void Visit(Reduce &op) override {
-    detail::PrintOperator(out_, "Reduce", op.accumulator_, op.initializer_, op.identifier_, op.list_, op.expression_);
-  }
-
-  void Visit(Coalesce &op) override { detail::PrintOperator(out_, "Coalesce", op.expressions_); }
-
-  void Visit(Extract &op) override { detail::PrintOperator(out_, "Extract", op.identifier_, op.list_, op.expression_); }
-
-  void Visit(All &op) override {
-    detail::PrintOperator(out_, "All", op.identifier_, op.list_expression_, op.where_->expression_);
-  }
-
-  void Visit(Single &op) override {
-    detail::PrintOperator(out_, "Single", op.identifier_, op.list_expression_, op.where_->expression_);
-  }
-
-  void Visit(Any &op) override {
-    detail::PrintOperator(out_, "Any", op.identifier_, op.list_expression_, op.where_->expression_);
-  }
-
-  void Visit(None &op) override {
-    detail::PrintOperator(out_, "None", op.identifier_, op.list_expression_, op.where_->expression_);
-  }
-
-  void Visit(Identifier &op) override { detail::PrintOperator(out_, "Identifier", op.name_); }
-
-  void Visit(PrimitiveLiteral &op) override { detail::PrintObject(out_, op.value_); }
-
-  void Visit(PropertyLookup &op) override {
-    detail::PrintOperator(out_, "PropertyLookup", op.expression_, op.property_.name);
-  }
-
-  void Visit(ParameterLookup &op) override { detail::PrintOperator(out_, "ParameterLookup", op.token_position_); }
-
-  void Visit(NamedExpression &op) override { detail::PrintOperator(out_, "NamedExpression", op.name_, op.expression_); }
-
-  void Visit(RegexMatch &op) override { detail::PrintOperator(out_, "=~", op.string_expr_, op.regex_); }
-
- private:
-  std::ostream *out_;
-};
-
-namespace detail {
-inline void PrintObject(std::ostream *out, Expression *expr) {
-  if (expr) {
-    ExpressionPrettyPrinter printer{out};
-    expr->Accept(printer);
-  } else {
-    *out << "<null>";
-  }
-}
-}  // namespace detail
-
-inline void PrintExpression(Expression *expr, std::ostream *out) {
-  ExpressionPrettyPrinter printer{out};
-  expr->Accept(printer);
-}
-
-inline void PrintExpression(NamedExpression *expr, std::ostream *out) {
-  ExpressionPrettyPrinter printer{out};
-  expr->Accept(printer);
-}
-}  // namespace memgraph::expr

src/expr/exceptions.hpp

@@ -1,52 +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 "utils/exceptions.hpp"
-
-namespace memgraph::expr {
-
-class SyntaxException : public utils::BasicException {
- public:
-  using utils::BasicException::BasicException;
-  SyntaxException() : SyntaxException("") {}
-};
-
-class SemanticException : public utils::BasicException {
- public:
-  using utils::BasicException::BasicException;
-  SemanticException() : BasicException("") {}
-};
-
-class ExpressionRuntimeException : public utils::BasicException {
- public:
-  using utils::BasicException::BasicException;
-};
-
-class RedeclareVariableError : public SemanticException {
- public:
-  explicit RedeclareVariableError(const std::string &name) : SemanticException("Redeclaring variable: " + name + ".") {}
-};
-
-class UnboundVariableError : public SemanticException {
- public:
-  explicit UnboundVariableError(const std::string &name) : SemanticException("Unbound 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)) {
-  }
-};
-
-}  // namespace memgraph::expr

src/expr/semantic/symbol_generator.hpp

@@ -1,712 +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.
-
-// Copyright 2017 Memgraph
-//
-// Created by Teon Banek on 11-03-2017
-
-#pragma once
-
-#include <algorithm>
-#include <optional>
-#include <ranges>
-#include <unordered_map>
-#include <unordered_set>
-#include <variant>
-#include <vector>
-
-#include "expr/ast.hpp"
-#include "expr/ast/ast_visitor.hpp"
-#include "expr/exceptions.hpp"
-#include "expr/semantic/symbol_table.hpp"
-
-namespace memgraph::expr {
-namespace detail {
-inline 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 detail
-
-/// Visits the AST and generates symbols for variables.
-///
-/// During the process of symbol generation, simple semantic checks are
-/// performed. Such as, redeclaring a variable or conflicting expectations of
-/// variable types.
-class SymbolGenerator : public HierarchicalTreeVisitor {
- public:
-  explicit SymbolGenerator(SymbolTable *symbol_table, const std::vector<Identifier *> &predefined_identifiers)
-      : symbol_table_(symbol_table),
-        predefined_identifiers_{detail::GeneratePredefinedIdentifierMap(predefined_identifiers)},
-        scopes_(1, Scope()) {}
-
-  using HierarchicalTreeVisitor::PostVisit;
-  using HierarchicalTreeVisitor::PreVisit;
-  using HierarchicalTreeVisitor::Visit;
-  using typename HierarchicalTreeVisitor::ReturnType;
-
-  // Query
-  bool PreVisit(SingleQuery & /*unused*/) override {
-    prev_return_names_ = curr_return_names_;
-    curr_return_names_.clear();
-    return true;
-  }
-
-  // Union
-  bool PreVisit(CypherUnion & /*unused*/) override {
-    scopes_.back() = Scope();
-    return true;
-  }
-
-  bool PostVisit(CypherUnion &cypher_union) override {
-    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 PreVisit(Create & /*unused*/) override {
-    scopes_.back().in_create = true;
-    return true;
-  }
-
-  bool PostVisit(Create & /*unused*/) override {
-    scopes_.back().in_create = false;
-    return true;
-  }
-
-  bool PreVisit(CallProcedure &call_proc) override {
-    for (auto *expr : call_proc.arguments_) {
-      expr->Accept(*this);
-    }
-    return false;
-  }
-
-  bool PostVisit(CallProcedure &call_proc) override {
-    for (auto *ident : call_proc.result_identifiers_) {
-      if (HasSymbolLocalScope(ident->name_)) {
-        throw RedeclareVariableError(ident->name_);
-      }
-      ident->MapTo(CreateSymbol(ident->name_, true));
-    }
-    return true;
-  }
-
-  bool PreVisit(LoadCsv & /*unused*/) override { return false; }
-
-  bool PostVisit(LoadCsv &load_csv) override {
-    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 PreVisit(Return &ret) override {
-    auto &scope = scopes_.back();
-    scope.in_return = true;
-    VisitReturnBody(ret.body_);
-    scope.in_return = false;
-    return false;  // We handled the traversal ourselves.
-  }
-
-  bool PostVisit(Return & /*unused*/) override {
-    for (const auto &name_symbol : scopes_.back().symbols) curr_return_names_.insert(name_symbol.first);
-    return true;
-  }
-
-  bool PreVisit(With &with) override {
-    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 PreVisit(Where & /*unused*/) override {
-    scopes_.back().in_where = true;
-    return true;
-  }
-
-  bool PostVisit(Where & /*unused*/) override {
-    scopes_.back().in_where = false;
-    return true;
-  }
-
-  bool PreVisit(Merge & /*unused*/) override {
-    scopes_.back().in_merge = true;
-    return true;
-  }
-
-  bool PostVisit(Merge & /*unused*/) override {
-    scopes_.back().in_merge = false;
-    return true;
-  }
-
-  bool PostVisit(Unwind &unwind) override {
-    const auto &name = unwind.named_expression_->name_;
-    if (HasSymbolLocalScope(name)) {
-      throw RedeclareVariableError(name);
-    }
-    unwind.named_expression_->MapTo(CreateSymbol(name, true));
-    return true;
-  }
-
-  bool PreVisit(Match & /*unused*/) override {
-    scopes_.back().in_match = true;
-    return true;
-  }
-
-  bool PostVisit(Match & /*unused*/) override {
-    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 PreVisit(Foreach &for_each) override {
-    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 PostVisit(Foreach & /*unused*/) override {
-    scopes_.pop_back();
-    return true;
-  }
-
-  // Expressions
-  ReturnType Visit(Identifier &ident) override {
-    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;
-  }
-
-  ReturnType Visit(PrimitiveLiteral & /*unused*/) override { return true; }
-
-  ReturnType Visit(ParameterLookup & /*unused*/) override { return true; }
-
-  bool PreVisit(Aggregation &aggr) override {
-    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 PostVisit(Aggregation & /*unused*/) override {
-    scopes_.back().in_aggregation = false;
-    return true;
-  }
-
-  bool PreVisit(IfOperator & /*unused*/) override {
-    ++scopes_.back().num_if_operators;
-    return true;
-  }
-
-  bool PostVisit(IfOperator & /*unused*/) override {
-    --scopes_.back().num_if_operators;
-    return true;
-  }
-
-  bool PreVisit(All &all) override {
-    all.list_expression_->Accept(*this);
-    VisitWithIdentifiers(all.where_->expression_, {all.identifier_});
-    return false;
-  }
-
-  bool PreVisit(Single &single) override {
-    single.list_expression_->Accept(*this);
-    VisitWithIdentifiers(single.where_->expression_, {single.identifier_});
-    return false;
-  }
-
-  bool PreVisit(Any &any) override {
-    any.list_expression_->Accept(*this);
-    VisitWithIdentifiers(any.where_->expression_, {any.identifier_});
-    return false;
-  }
-
-  bool PreVisit(None &none) override {
-    none.list_expression_->Accept(*this);
-    VisitWithIdentifiers(none.where_->expression_, {none.identifier_});
-    return false;
-  }
-
-  bool PreVisit(Reduce &reduce) override {
-    reduce.initializer_->Accept(*this);
-    reduce.list_->Accept(*this);
-    VisitWithIdentifiers(reduce.expression_, {reduce.accumulator_, reduce.identifier_});
-    return false;
-  }
-
-  bool PreVisit(Extract &extract) override {
-    extract.list_->Accept(*this);
-    VisitWithIdentifiers(extract.expression_, {extract.identifier_});
-    return false;
-  }
-
-  // Pattern and its subparts.
-  bool PreVisit(Pattern &pattern) override {
-    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 PostVisit(Pattern & /*unused*/) override {
-    auto &scope = scopes_.back();
-    scope.in_pattern = false;
-    scope.in_create_node = false;
-    return true;
-  }
-
-  bool PreVisit(NodeAtom &node_atom) override {
-    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 PostVisit(NodeAtom & /*unused*/) override {
-    scopes_.back().in_node_atom = false;
-    return true;
-  }
-
-  bool PreVisit(EdgeAtom &edge_atom) override {
-    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 PostVisit(EdgeAtom & /*unused*/) override {
-    auto &scope = scopes_.back();
-    scope.visiting_edge = nullptr;
-    scope.in_create_edge = false;
-    return true;
-  }
-
- private:
-  // Scope stores the state of where we are when visiting the AST and a map of
-  // names to symbols.
-  struct Scope {
-    bool in_pattern{false};
-    bool in_merge{false};
-    bool in_create{false};
-    // in_create_node is true if we are creating or merging *only* a node.
-    // Therefore, it is *not* equivalent to (in_create || in_merge) &&
-    // in_node_atom.
-    bool in_create_node{false};
-    // True if creating an edge;
-    // shortcut for (in_create || in_merge) && visiting_edge.
-    bool in_create_edge{false};
-    bool in_node_atom{false};
-    EdgeAtom *visiting_edge{nullptr};
-    bool in_aggregation{false};
-    bool in_return{false};
-    bool in_with{false};
-    bool in_skip{false};
-    bool in_limit{false};
-    bool in_order_by{false};
-    bool in_where{false};
-    bool in_match{false};
-    bool in_foreach{false};
-    // True when visiting a pattern atom (node or edge) identifier, which can be
-    // reused or created in the pattern itself.
-    bool in_pattern_atom_identifier{false};
-    // True when visiting range bounds of a variable path.
-    bool in_edge_range{false};
-    // True if the return/with contains an aggregation in any named expression.
-    bool has_aggregation{false};
-    // Map from variable names to symbols.
-    std::map<std::string, Symbol> symbols;
-    // Identifiers found in property maps of patterns or as variable length path
-    // bounds in a single Match clause. They need to be checked after visiting
-    // Match. Identifiers created by naming vertices, edges and paths are *not*
-    // stored in here.
-    std::vector<Identifier *> identifiers_in_match;
-    // Number of nested IfOperators.
-    int num_if_operators{0};
-  };
-
-  inline static std::optional<Symbol> 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;
-  }
-
-  bool HasSymbol(const std::string &name) const {
-    return std::ranges::any_of(scopes_, [&name](const auto &scope) { return scope.symbols.contains(name); });
-  }
-
-  bool HasSymbolLocalScope(const std::string &name) const { return scopes_.back().symbols.contains(name); }
-
-  // @return true if it added a predefined identifier with that name
-  bool 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;
-  }
-
-  // Returns a freshly generated symbol. Previous mapping of the same name to a
-  // different symbol is replaced with the new one.
-  Symbol CreateSymbol(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY,
-                      int token_position = -1) {
-    auto symbol = symbol_table_->CreateSymbol(name, user_declared, type, token_position);
-    scopes_.back().symbols[name] = symbol;
-    return symbol;
-  }
-
-  Symbol GetOrCreateSymbol(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY) {
-    // 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);
-  }
-
-  // Returns the symbol by name. If the mapping already exists, checks if the
-  // types match. Otherwise, returns a new symbol.
-  Symbol GetOrCreateSymbolLocalScope(const std::string &name, bool user_declared,
-                                     Symbol::Type type = Symbol::Type::ANY) {
-    auto &scope = scopes_.back();
-    if (auto maybe_symbol = FindSymbolInScope(name, scope, type); maybe_symbol) {
-      return *maybe_symbol;
-    }
-    return CreateSymbol(name, user_declared, type);
-  }
-
-  void VisitReturnBody(ReturnBody &body, Where *where = nullptr) {
-    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;
-  }
-
-  void 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_);
-      }
-    }
-  }
-
-  SymbolTable *symbol_table_;
-
-  // Identifiers which are injected from outside the query. Each identifier
-  // is mapped by its name.
-  std::unordered_map<std::string, Identifier *> predefined_identifiers_;
-  std::vector<Scope> scopes_;
-  std::unordered_set<std::string> prev_return_names_;
-  std::unordered_set<std::string> curr_return_names_;
-};
-
-inline SymbolTable MakeSymbolTable(CypherQuery *query, const std::vector<Identifier *> &predefined_identifiers = {}) {
-  SymbolTable symbol_table;
-  SymbolGenerator symbol_generator(&symbol_table, predefined_identifiers);
-  query->single_query_->Accept(symbol_generator);
-  for (auto *cypher_union : query->cypher_unions_) {
-    cypher_union->Accept(symbol_generator);
-  }
-  return symbol_table;
-}
-
-}  // namespace memgraph::expr

src/glue/v2/communication.cpp

@@ -16,7 +16,7 @@
 #include <vector>
 
 #include "storage/v3/edge_accessor.hpp"
-#include "storage/v3/shard.hpp"
+#include "storage/v3/storage.hpp"
 #include "storage/v3/vertex_accessor.hpp"
 #include "utils/temporal.hpp"
 
@@ -64,16 +64,16 @@ query::v2::TypedValue ToTypedValue(const Value &value) {
 }
 
 storage::v3::Result<communication::bolt::Vertex> ToBoltVertex(const query::v2::VertexAccessor &vertex,
-                                                              const storage::v3::Shard &db, storage::v3::View view) {
+                                                              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::Shard &db, storage::v3::View view) {
+                                                          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::Shard &db,
+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:
@@ -132,9 +132,8 @@ storage::v3::Result<Value> ToBoltValue(const query::v2::TypedValue &value, const
 }
 
 storage::v3::Result<communication::bolt::Vertex> ToBoltVertex(const storage::v3::VertexAccessor &vertex,
-                                                              const storage::v3::Shard &db, storage::v3::View view) {
-  // TODO(jbajic) Fix bolt communication
-  auto id = communication::bolt::Id::FromUint(0);
+                                                              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;
@@ -152,11 +151,10 @@ storage::v3::Result<communication::bolt::Vertex> ToBoltVertex(const storage::v3:
 }
 
 storage::v3::Result<communication::bolt::Edge> ToBoltEdge(const storage::v3::EdgeAccessor &edge,
-                                                          const storage::v3::Shard &db, storage::v3::View view) {
-  // TODO(jbajic) Fix bolt communication
-  auto id = communication::bolt::Id::FromUint(0);
-  auto from = communication::bolt::Id::FromUint(0);
-  auto to = communication::bolt::Id::FromUint(0);
+                                                          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();
@@ -167,7 +165,7 @@ storage::v3::Result<communication::bolt::Edge> ToBoltEdge(const storage::v3::Edg
   return communication::bolt::Edge{id, from, to, type, properties};
 }
 
-storage::v3::Result<communication::bolt::Path> ToBoltPath(const query::v2::Path &path, const storage::v3::Shard &db,
+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());

src/glue/v2/communication.hpp

@@ -13,7 +13,7 @@
 #pragma once
 
 #include "communication/bolt/v1/value.hpp"
-#include "query/v2/bindings/typed_value.hpp"
+#include "query/v2/typed_value.hpp"
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/result.hpp"
 #include "storage/v3/view.hpp"
@@ -28,36 +28,36 @@ namespace memgraph::glue::v2 {
 
 /// @param storage::v3::VertexAccessor for converting to
 ///        communication::bolt::Vertex.
-/// @param storage::v3::Shard for getting label and property names.
+/// @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::Shard &db, storage::v3::View view);
+                                                              const storage::v3::Storage &db, storage::v3::View view);
 
 /// @param storage::v3::EdgeAccessor for converting to communication::bolt::Edge.
-/// @param storage::v3::Shard for getting edge type and property names.
+/// @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::Shard &db, storage::v3::View view);
+                                                          const storage::v3::Storage &db, storage::v3::View view);
 
 /// @param query::v2::Path for converting to communication::bolt::Path.
-/// @param storage::v3::Shard for ToBoltVertex and ToBoltEdge.
+/// @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::Shard &db,
+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::Shard for ToBoltVertex and ToBoltEdge.
+/// @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::Shard &db, storage::v3::View view);
+                                                            const storage::v3::Storage &db, storage::v3::View view);
 
 query::v2::TypedValue ToTypedValue(const communication::bolt::Value &value);
 

src/io/address.hpp

@@ -1,77 +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 <compare>
-
-#include <fmt/format.h>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/uuid/uuid.hpp>
-#include <boost/uuid/uuid_generators.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) {
-    return Address{
-        .unique_id = boost::uuids::uuid{boost::uuids::random_generator()()},
-        .last_known_port = port,
-    };
-  }
-
-  static Address UniqueLocalAddress() {
-    return Address{
-        .unique_id = boost::uuids::uuid{boost::uuids::random_generator()()},
-    };
-  }
-
-  /// Returns a new ID with the same IP and port but a unique UUID.
-  Address ForkUniqueAddress() {
-    return Address{
-        .unique_id = boost::uuids::uuid{boost::uuids::random_generator()()},
-        .last_known_ip = last_known_ip,
-        .last_known_port = last_known_port,
-    };
-  }
-
-  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

@@ -1,26 +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
-
-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

@@ -1,256 +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 <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_.has_value();
-  }
-
-  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(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/local_transport/local_system.hpp

@@ -1,35 +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 <random>
-
-#include "io/address.hpp"
-#include "io/local_transport/local_transport.hpp"
-#include "io/local_transport/local_transport_handle.hpp"
-#include "io/transport.hpp"
-
-namespace memgraph::io::local_transport {
-
-class LocalSystem {
-  std::shared_ptr<LocalTransportHandle> local_transport_handle_ = std::make_shared<LocalTransportHandle>();
-
- public:
-  Io<LocalTransport> Register(Address address) {
-    LocalTransport local_transport(local_transport_handle_);
-    return Io{local_transport, address};
-  }
-
-  void ShutDown() { local_transport_handle_->ShutDown(); }
-};
-
-}  // namespace memgraph::io::local_transport

src/io/local_transport/local_transport.hpp

@@ -1,64 +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 <chrono>
-#include <memory>
-#include <random>
-#include <utility>
-
-#include "io/address.hpp"
-#include "io/local_transport/local_transport_handle.hpp"
-#include "io/time.hpp"
-#include "io/transport.hpp"
-
-namespace memgraph::io::local_transport {
-
-class LocalTransport {
-  std::shared_ptr<LocalTransportHandle> local_transport_handle_;
-
- public:
-  explicit LocalTransport(std::shared_ptr<LocalTransportHandle> local_transport_handle)
-      : local_transport_handle_(std::move(local_transport_handle)) {}
-
-  template <Message RequestT, Message ResponseT>
-  ResponseFuture<ResponseT> Request(Address to_address, Address from_address, RequestId request_id, RequestT request,
-                                    Duration timeout) {
-    auto [future, promise] = memgraph::io::FuturePromisePair<ResponseResult<ResponseT>>();
-
-    local_transport_handle_->SubmitRequest(to_address, from_address, request_id, std::move(request), timeout,
-                                           std::move(promise));
-
-    return std::move(future);
-  }
-
-  template <Message... Ms>
-  requires(sizeof...(Ms) > 0) RequestResult<Ms...> Receive(Address receiver_address, Duration timeout) {
-    return local_transport_handle_->template Receive<Ms...>(receiver_address, timeout);
-  }
-
-  template <Message M>
-  void Send(Address to_address, Address from_address, RequestId request_id, M &&message) {
-    return local_transport_handle_->template Send<M>(to_address, from_address, request_id, std::forward<M>(message));
-  }
-
-  Time Now() const { return local_transport_handle_->Now(); }
-
-  bool ShouldShutDown() const { return local_transport_handle_->ShouldShutDown(); }
-
-  template <class D = std::poisson_distribution<>, class Return = uint64_t>
-  Return Rand(D distrib) {
-    std::random_device rng;
-    return distrib(rng);
-  }
-};
-};  // namespace memgraph::io::local_transport

src/io/local_transport/local_transport_handle.hpp

@@ -1,151 +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 <chrono>
-#include <condition_variable>
-#include <iostream>
-#include <map>
-#include <mutex>
-
-#include "io/errors.hpp"
-#include "io/message_conversion.hpp"
-#include "io/time.hpp"
-#include "io/transport.hpp"
-
-namespace memgraph::io::local_transport {
-
-class LocalTransportHandle {
-  mutable std::mutex mu_{};
-  mutable std::condition_variable cv_;
-  bool should_shut_down_ = false;
-
-  // 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::vector<OpaqueMessage> can_receive_;
-
- public:
-  ~LocalTransportHandle() {
-    for (auto &&[pk, promise] : promises_) {
-      std::move(promise.promise).TimeOut();
-    }
-    promises_.clear();
-  }
-
-  void ShutDown() {
-    std::unique_lock<std::mutex> lock(mu_);
-    should_shut_down_ = true;
-    cv_.notify_all();
-  }
-
-  bool ShouldShutDown() const {
-    std::unique_lock<std::mutex> lock(mu_);
-    return should_shut_down_;
-  }
-
-  static Time Now() {
-    auto nano_time = std::chrono::system_clock::now();
-    return std::chrono::time_point_cast<std::chrono::microseconds>(nano_time);
-  }
-
-  template <Message... Ms>
-  requires(sizeof...(Ms) > 0) RequestResult<Ms...> Receive(Address /* receiver_address */, Duration timeout) {
-    std::unique_lock lock(mu_);
-
-    Time before = Now();
-
-    spdlog::info("can_receive_ size: {}", can_receive_.size());
-
-    while (can_receive_.empty()) {
-      Time now = Now();
-
-      // protection against non-monotonic timesources
-      auto maxed_now = std::max(now, before);
-      auto elapsed = maxed_now - before;
-
-      if (timeout < elapsed) {
-        return TimedOut{};
-      }
-
-      Duration relative_timeout = timeout - elapsed;
-
-      std::cv_status cv_status_value = cv_.wait_for(lock, relative_timeout);
-
-      if (cv_status_value == std::cv_status::timeout) {
-        return TimedOut{};
-      }
-    }
-
-    auto current_message = std::move(can_receive_.back());
-    can_receive_.pop_back();
-
-    auto m_opt = std::move(current_message).Take<Ms...>();
-
-    return std::move(m_opt).value();
-  }
-
-  template <Message M>
-  void Send(Address to_address, Address from_address, RequestId request_id, M &&message) {
-    std::any message_any(std::forward<M>(message));
-    OpaqueMessage opaque_message{.to_address = to_address,
-                                 .from_address = from_address,
-                                 .request_id = request_id,
-                                 .message = std::move(message_any)};
-
-    PromiseKey promise_key{
-        .requester_address = to_address, .request_id = opaque_message.request_id, .replier_address = from_address};
-
-    {
-      std::unique_lock<std::mutex> lock(mu_);
-
-      if (promises_.contains(promise_key)) {
-        spdlog::info("using message to fill promise");
-        // complete waiting promise if it's there
-        DeadlineAndOpaquePromise dop = std::move(promises_.at(promise_key));
-        promises_.erase(promise_key);
-
-        dop.promise.Fill(std::move(opaque_message));
-      } else {
-        spdlog::info("placing message in can_receive_");
-        can_receive_.emplace_back(std::move(opaque_message));
-      }
-    }  // lock dropped
-
-    cv_.notify_all();
-  }
-
-  template <Message RequestT, Message ResponseT>
-  void SubmitRequest(Address to_address, Address from_address, RequestId request_id, RequestT &&request,
-                     Duration timeout, ResponsePromise<ResponseT> promise) {
-    const bool port_matches = to_address.last_known_port == from_address.last_known_port;
-    const bool ip_matches = to_address.last_known_ip == from_address.last_known_ip;
-
-    MG_ASSERT(port_matches && ip_matches);
-    const Time deadline = Now() + timeout;
-
-    {
-      std::unique_lock<std::mutex> lock(mu_);
-
-      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));
-    }  // lock dropped
-
-    Send(to_address, from_address, request_id, std::forward<RequestT>(request));
-  }
-};
-
-}  // namespace memgraph::io::local_transport

src/io/message_conversion.hpp

@@ -1,232 +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 "io/transport.hpp"
-
-namespace memgraph::io {
-
-using memgraph::io::Duration;
-using memgraph::io::Message;
-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 OpaqueMessage {
-  Address to_address;
-  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,
-          .to_address = to_address,
-          .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,
-                                                 .to_address = opaque_message.to_address,
-                                                 .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");
-  }
-};
-
-struct DeadlineAndOpaquePromise {
-  Time deadline;
-  OpaquePromise promise;
-};
-
-template <class From>
-std::type_info const &type_info_for_variant(From const &from) {
-  return std::visit([](auto &&x) -> decltype(auto) { return typeid(x); }, from);
-}
-
-template <typename From, typename Return, typename Head, typename... Rest>
-std::optional<Return> ConvertVariantInner(From &&a) {
-  if (typeid(Head) == type_info_for_variant(a)) {
-    Head concrete = std::get<Head>(std::forward<From>(a));
-    return concrete;
-  }
-
-  if constexpr (sizeof...(Rest) > 0) {
-    return ConvertVariantInner<From, Return, Rest...>(std::forward<From>(a));
-  } else {
-    return std::nullopt;
-  }
-}
-
-/// This function converts a variant to another variant holding a subset OR superset of
-/// possible types.
-template <class From, class... Ms>
-requires(sizeof...(Ms) > 0) std::optional<std::variant<Ms...>> ConvertVariant(From &&from) {
-  return ConvertVariantInner<From, std::variant<Ms...>, Ms...>(std::forward<From>(from));
-}
-
-}  // namespace memgraph::io

src/io/messages.hpp

@@ -1,46 +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 <variant>
-
-#include <coordinator/coordinator.hpp>
-#include <io/rsm/raft.hpp>
-#include "query/v2/requests.hpp"
-#include "utils/concepts.hpp"
-
-namespace memgraph::io::messages {
-
-using memgraph::coordinator::CoordinatorReadRequests;
-using memgraph::coordinator::CoordinatorWriteRequests;
-using memgraph::coordinator::CoordinatorWriteResponses;
-using StorageReadRequest = msgs::ReadRequests;
-using StorageWriteRequest = msgs::WriteRequests;
-
-using memgraph::io::rsm::AppendRequest;
-using memgraph::io::rsm::AppendResponse;
-using memgraph::io::rsm::ReadRequest;
-using memgraph::io::rsm::VoteRequest;
-using memgraph::io::rsm::VoteResponse;
-using memgraph::io::rsm::WriteRequest;
-using memgraph::io::rsm::WriteResponse;
-
-using CoordinatorMessages =
-    std::variant<ReadRequest<CoordinatorReadRequests>, AppendRequest<CoordinatorWriteRequests>, AppendResponse,
-                 WriteRequest<CoordinatorWriteRequests>, VoteRequest, VoteResponse>;
-
-using ShardMessages = std::variant<ReadRequest<StorageReadRequest>, AppendRequest<StorageWriteRequest>, AppendResponse,
-                                   WriteRequest<StorageWriteRequest>, VoteRequest, VoteResponse>;
-
-using ShardManagerMessages = std::variant<WriteResponse<CoordinatorWriteResponses>>;
-
-}  // namespace memgraph::io::messages

src/io/rsm/raft.hpp

@@ -1,926 +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.
-
-// 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"
-#include "utils/concepts.hpp"
-
-namespace memgraph::io::rsm {
-
-/// Timeout and replication tunables
-using namespace std::chrono_literals;
-static constexpr auto kMinimumElectionTimeout = 100ms;
-static constexpr auto kMaximumElectionTimeout = 200ms;
-static constexpr auto kMinimumBroadcastTimeout = 40ms;
-static constexpr auto kMaximumBroadcastTimeout = 60ms;
-static constexpr auto kMinimumCronInterval = 1ms;
-static constexpr auto kMaximumCronInterval = 2ms;
-static constexpr auto kMinimumReceiveTimeout = 40ms;
-static constexpr auto kMaximumReceiveTimeout = 60ms;
-static_assert(kMinimumElectionTimeout > kMaximumBroadcastTimeout,
-              "The broadcast timeout has to be smaller than the election timeout!");
-static_assert(kMinimumElectionTimeout < kMaximumElectionTimeout,
-              "The minimum election timeout has to be smaller than the maximum election timeout!");
-static_assert(kMinimumBroadcastTimeout < kMaximumBroadcastTimeout,
-              "The minimum broadcast timeout has to be smaller than the maximum broadcast timeout!");
-static_assert(kMinimumCronInterval < kMaximumCronInterval,
-              "The minimum cron interval has to be smaller than the maximum cron interval!");
-static_assert(kMinimumReceiveTimeout < kMaximumReceiveTimeout,
-              "The minimum receive timeout has to be smaller than the maximum receive timeout!");
-static constexpr size_t kMaximumAppendBatchSize = 1024;
-
-using Term = uint64_t;
-using LogIndex = uint64_t;
-using LogSize = 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;
-  LogIndex raft_index;
-};
-
-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 batch_start_log_index;
-  Term last_log_term;
-  std::vector<std::pair<Term, WriteRequest>> entries;
-  LogSize 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.
-  LogSize log_size;
-};
-
-struct VoteRequest {
-  Term term = 0;
-  LogSize log_size;
-  Term last_log_term;
-};
-
-struct VoteResponse {
-  Term term = 0;
-  LogSize committed_log_size;
-  bool vote_granted = false;
-};
-
-template <typename WriteRequest>
-struct CommonState {
-  Term term = 0;
-  std::vector<std::pair<Term, WriteRequest>> log;
-  LogSize committed_log_size = 0;
-  LogSize applied_size = 0;
-};
-
-struct FollowerTracker {
-  LogIndex next_index = 0;
-  LogSize confirmed_log_size = 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 static ToString() { return "\tLeader   \t"; }
-};
-
-struct Candidate {
-  std::map<Address, LogSize> successful_votes;
-  Time election_began = Time::min();
-  std::set<Address> outstanding_votes;
-
-  std::string static ToString() { return "\tCandidate\t"; }
-};
-
-struct Follower {
-  Time last_received_append_entries_timestamp;
-  Address leader_address;
-
-  std::string static ToString() { return "\tFollower \t"; }
-};
-
-using Role = std::variant<Candidate, Leader, Follower>;
-
-template <typename Role>
-concept AllRoles = memgraph::utils::SameAsAnyOf<Role, Leader, Follower, Candidate>;
-
-template <typename Role>
-concept LeaderOrFollower = memgraph::utils::SameAsAnyOf<Role, Leader, Follower>;
-
-template <typename Role>
-concept FollowerOrCandidate = memgraph::utils::SameAsAnyOf<Role, Follower, Candidate>;
-
-/*
-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_;
-  Time next_cron_;
-
- public:
-  Raft(Io<IoImpl> &&io, std::vector<Address> peers, ReplicatedState &&replicated_state)
-      : io_(std::forward<Io<IoImpl>>(io)),
-        peers_(peers),
-        replicated_state_(std::forward<ReplicatedState>(replicated_state)) {
-    if (peers.empty()) {
-      role_ = Leader{};
-    }
-  }
-
-  /// Periodic protocol maintenance. Returns the time that Cron should be called again
-  /// in the future.
-  Time 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();
-    }
-    const Duration random_cron_interval = RandomTimeout(kMinimumCronInterval, kMaximumCronInterval);
-
-    return io_.Now() + random_cron_interval;
-  }
-
-  /// Returns the Address for our underlying Io implementation
-  Address GetAddress() { return io_.GetAddress(); }
-
-  using ReceiveVariant = std::variant<ReadRequest<ReadOperation>, AppendRequest<WriteOperation>, AppendResponse,
-                                      WriteRequest<WriteOperation>, VoteRequest, VoteResponse>;
-
-  void Handle(ReceiveVariant &&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) mutable {
-          return Handle(role, std::forward<decltype(msg)>(msg), request_id, from_address);
-        },
-        std::forward<ReceiveVariant>(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();
-    }
-  }
-
-  void Run() {
-    while (!io_.ShouldShutDown()) {
-      const auto now = io_.Now();
-      if (now >= next_cron_) {
-        next_cron_ = Cron();
-      }
-
-      const Duration receive_timeout = RandomTimeout(kMinimumReceiveTimeout, kMaximumReceiveTimeout);
-
-      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 confirmed_log_sizes = std::vector<LogSize>{};
-
-    // We include our own log size in the calculation of the log
-    // confirmed log size that is present on at least a majority of all peers.
-    confirmed_log_sizes.push_back(state_.log.size());
-
-    for (const auto &[addr, f] : leader.followers) {
-      confirmed_log_sizes.push_back(f.confirmed_log_size);
-      Log("Follower at port ", addr.last_known_port, " has confirmed log size of: ", f.confirmed_log_size);
-    }
-
-    // reverse sort from highest to lowest (using std::ranges::greater)
-    std::ranges::sort(confirmed_log_sizes, std::ranges::greater());
-
-    // This is a particularly correctness-critical calculation because it
-    // determines the committed log size that will be broadcast in
-    // the next AppendRequest.
-    //
-    // If the following sizes are recorded for clusters of different numbers of peers,
-    // these are the expected sizes that are considered to have reached consensus:
-    //
-    // state           | expected value | (confirmed_log_sizes.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
-    const size_t majority_index = confirmed_log_sizes.size() / 2;
-    const LogSize new_committed_log_size = confirmed_log_sizes[majority_index];
-
-    // We never go backwards in history.
-    MG_ASSERT(state_.committed_log_size <= new_committed_log_size,
-              "as a Leader, we have previously set our committed_log_size to {}, but our Followers have a majority "
-              "committed_log_size of {}",
-              state_.committed_log_size, new_committed_log_size);
-
-    state_.committed_log_size = new_committed_log_size;
-
-    // For each size between the old size 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;
-      const WriteResponseValue write_return = replicated_state_.Apply(write_request);
-
-      if (leader.pending_client_requests.contains(apply_index)) {
-        const PendingClientRequest client_request = std::move(leader.pending_client_requests.at(apply_index));
-        leader.pending_client_requests.erase(apply_index);
-
-        const WriteResponse<WriteResponseValue> resp{
-            .success = true,
-            .write_return = std::move(write_return),
-            .raft_index = apply_index,
-        };
-
-        io_.Send(client_request.address, client_request.request_id, std::move(resp));
-      }
-    }
-
-    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 next_index = follower.next_index;
-
-      const auto missing = state_.log.size() - next_index;
-      const auto batch_size = std::min(missing, kMaximumAppendBatchSize);
-      const auto start_index = next_index;
-      const auto end_index = start_index + batch_size;
-
-      // advance follower's next index
-      follower.next_index += batch_size;
-
-      std::vector<std::pair<Term, WriteOperation>> entries;
-
-      entries.insert(entries.begin(), state_.log.begin() + start_index, state_.log.begin() + end_index);
-
-      const Term previous_term_from_index = PreviousTermFromIndex(start_index);
-
-      Log("sending ", entries.size(), " entries to Follower ", address.last_known_port,
-          " which are above its next_index of ", next_index);
-
-      AppendRequest<WriteOperation> ar{
-          .term = state_.term,
-          .batch_start_log_index = start_index,
-          .last_log_term = previous_term_from_index,
-          .entries = std::move(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, std::move(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());
-
-    const auto rand_micros = io_.Rand(time_distrib);
-
-    return Duration{rand_micros};
-  }
-
-  Duration RandomTimeout(int min_micros, int max_micros) {
-    std::uniform_int_distribution time_distrib(min_micros, max_micros);
-
-    const 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;
-  }
-
-  Term CommittedLogTerm() {
-    MG_ASSERT(state_.log.size() >= state_.committed_log_size);
-    if (state_.log.empty() || state_.committed_log_size == 0) {
-      return 0;
-    }
-
-    const auto &[term, data] = state_.log.at(state_.committed_log_size - 1);
-    return term;
-  }
-
-  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();
-    const auto micros = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
-    const Term term = state_.term;
-    const std::string role_string = std::visit([&](const auto &role) { return role.ToString(); }, role_);
-
-    std::ostringstream out;
-
-    out << '\t' << static_cast<int>(micros) << "\t" << term << "\t" << io_.GetAddress().last_known_port;
-
-    out << role_string;
-
-    (out << ... << args);
-
-    spdlog::info(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.
-  /////////////////////////////////////////////////////////////
-
-  // 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(kMinimumElectionTimeout, kMaximumElectionTimeout);
-    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,
-          "ms elapsed since last election attempt");
-
-      const VoteRequest request{
-          .term = state_.term,
-          .log_size = state_.log.size(),
-          .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;
-
-    // randomized follower timeout
-    const Duration election_timeout = RandomTimeout(kMinimumElectionTimeout, kMaximumElectionTimeout);
-
-    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(kMinimumBroadcastTimeout, kMaximumBroadcastTimeout);
-
-    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.
-  /////////////////////////////////////////////////////////////
-
-  // all roles can receive Vote and possibly become a follower
-  template <AllRoles ALL>
-  std::optional<Role> Handle(ALL & /* variable */, VoteRequest &&req, RequestId request_id, Address from_address) {
-    Log("received VoteRequest 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 log_size_dominates = req.log_size >= state_.log.size();
-    const bool new_leader = last_log_term_dominates && term_dominates && log_size_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,
-      };
-    }
-
-    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 /* variable */, 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_log_size = committed_log_size,
-        };
-        followers.insert({address, follower});
-      }
-      for (const auto &address : candidate.outstanding_votes) {
-        FollowerTracker follower{
-            .next_index = state_.log.size(),
-            .confirmed_log_size = 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 <LeaderOrFollower LOF>
-  std::optional<Role> Handle(LOF & /* variable */, VoteResponse && /* variable */, RequestId /* variable */,
-                             Address /* variable */) {
-    Log("non-Candidate received VoteResponse");
-    return std::nullopt;
-  }
-
-  template <AllRoles ALL>
-  std::optional<Role> Handle(ALL &role, AppendRequest<WriteOperation> &&req, RequestId request_id,
-                             Address from_address) {
-    // log size starts out as state_.committed_log_size and only if everything is successful do we
-    // switch it to the log length.
-    AppendResponse res{
-        .success = false,
-        .term = state_.term,
-        .last_log_term = CommittedLogTerm(),
-        .log_size = state_.log.size(),
-    };
-
-    if constexpr (std::is_same<ALL, Leader>()) {
-      MG_ASSERT(req.term != state_.term, "Multiple leaders are acting under the term ", req.term);
-    }
-
-    const bool is_candidate = std::is_same<ALL, 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,
-      };
-    }
-
-    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<ALL, 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");
-    }
-
-    // Handle steady-state conditions.
-    if (req.batch_start_log_index != state_.log.size()) {
-      Log("req.batch_start_log_index of ", req.batch_start_log_index, " does not match our log size of ",
-          state_.log.size());
-    } 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 ", req.entries.size(), " entries to our log starting at index ",
-          req.batch_start_log_index);
-
-      const auto resize_length = req.batch_start_log_index;
-
-      MG_ASSERT(resize_length >= 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(resize_length);
-
-      if (req.entries.size() > 0) {
-        auto &[first_term, op] = req.entries.at(0);
-        MG_ASSERT(LastLogTerm() <= first_term);
-      }
-
-      state_.log.insert(state_.log.end(), std::make_move_iterator(req.entries.begin()),
-                        std::make_move_iterator(req.entries.end()));
-
-      MG_ASSERT(req.leader_commit >= state_.committed_log_size);
-      state_.committed_log_size = std::min(req.leader_commit, state_.log.size());
-
-      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;
-    }
-
-    res.last_log_term = LastLogTerm();
-    res.log_size = state_.log.size();
-
-    Log("returning log_size of ", res.log_size);
-
-    io_.Send(from_address, request_id, res);
-
-    return std::nullopt;
-  }
-
-  std::optional<Role> Handle(Leader &leader, AppendResponse &&res, RequestId /* variable */, Address from_address) {
-    if (res.term != state_.term) {
-      Log("received AppendResponse related to a previous term when we (presumably) were the leader");
-      return std::nullopt;
-    }
-
-    // TODO(tyler) when we have dynamic membership, this assert will become incorrect, but we should
-    // keep it in-place until then because it has bug finding value.
-    MG_ASSERT(leader.followers.contains(from_address), "received AppendResponse from unknown Follower");
-
-    // at this point, we know the term matches and we know this Follower
-
-    FollowerTracker &follower = leader.followers.at(from_address);
-
-    if (res.success) {
-      Log("got successful AppendResponse from ", from_address.last_known_port, " with log_size of ", res.log_size);
-      follower.next_index = std::max(follower.next_index, res.log_size);
-    } else {
-      Log("got unsuccessful AppendResponse from ", from_address.last_known_port, " with log_size of ", res.log_size);
-      follower.next_index = res.log_size;
-    }
-
-    follower.confirmed_log_size = std::max(follower.confirmed_log_size, res.log_size);
-
-    BumpCommitIndexAndReplyToClients(leader);
-
-    return std::nullopt;
-  }
-
-  template <FollowerOrCandidate FOC>
-  std::optional<Role> Handle(FOC & /* variable */, AppendResponse && /* variable */, RequestId /* variable */,
-                             Address /* variable */) {
-    // 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 & /* variable */, 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);
-
-    const 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 & /* variable */, ReadRequest<ReadOperation> && /* variable */,
-                             RequestId request_id, Address from_address) {
-    Log("received ReadOperation - not redirecting because no Leader is known");
-    const ReadResponse<ReadResponseValue> res{
-        .success = false,
-    };
-
-    io_.Send(from_address, request_id, res);
-
-    Cron();
-
-    return std::nullopt;
-  }
-
-  // Followers should respond with a redirection, similar to the Follower + WriteRequest response below
-  std::optional<Role> Handle(Follower &follower, ReadRequest<ReadOperation> && /* variable */, RequestId request_id,
-                             Address from_address) {
-    Log("redirecting client to known Leader with port ", follower.leader_address.last_known_port);
-
-    const ReadResponse<ReadResponseValue> res{
-        .success = false,
-        .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> && /* variable */, RequestId request_id,
-                             Address from_address) {
-    Log("redirecting client to known Leader with port ", follower.leader_address.last_known_port);
-
-    const WriteResponse<WriteResponseValue> res{
-        .success = false,
-        .retry_leader = follower.leader_address,
-    };
-
-    io_.Send(from_address, request_id, res);
-
-    return std::nullopt;
-  }
-
-  std::optional<Role> Handle(Candidate & /* variable */, WriteRequest<WriteOperation> && /* variable */,
-                             RequestId request_id, Address from_address) {
-    Log("received WriteRequest - not redirecting because no Leader is known");
-
-    const WriteResponse<WriteResponseValue> res{
-        .success = false,
-    };
-
-    io_.Send(from_address, request_id, res);
-
-    Cron();
-
-    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
-    MG_ASSERT(state_.term >= LastLogTerm());
-    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);
-
-    if (peers_.empty()) {
-      BumpCommitIndexAndReplyToClients(leader);
-    } else {
-      BroadcastAppendEntries(leader.followers);
-    }
-
-    return std::nullopt;
-  }
-};
-
-};  // namespace memgraph::io::rsm

src/io/rsm/rsm_client.hpp

@@ -1,136 +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 <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>;
-
-  Io<IoImpl> io_;
-  Address leader_;
-  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 = io_.Rand(addr_distrib);
-      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(Io<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());
-        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

@@ -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.
-
-#pragma once
-
-/// The ShardRsm 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 ShardRsm'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
-/// ShardRsm::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 "storage/v3/id_types.hpp"
-#include "storage/v3/property_value.hpp"
-#include "utils/logging.hpp"
-
-namespace memgraph::io::rsm {
-
-using memgraph::coordinator::Hlc;
-using memgraph::storage::v3::LabelId;
-using memgraph::storage::v3::PropertyValue;
-
-using ShardRsmKey = std::vector<PropertyValue>;
-
-struct StorageWriteRequest {
-  LabelId label_id;
-  Hlc transaction_id;
-  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 {
-  LabelId label_id;
-  Hlc transaction_id;
-  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 ShardRsm {
-  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) const {
-    if (maximum_key_) [[likely]] {
-      return (key >= minimum_key_ && key <= maximum_key_);
-    }
-    return key >= minimum_key_;
-  }
-
- public:
-  StorageReadResponse Read(StorageReadRequest request) const {
-    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_.at(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, request.value.value());
-    }
-
-    return ret;
-  }
-};
-
-}  // namespace memgraph::io::rsm

src/io/simulator/CMakeLists.txt

@@ -1,8 +0,0 @@
-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/simulator.hpp

@@ -1,51 +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 <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

@@ -1,30 +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 <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

@@ -1,142 +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 "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 = blocked_on_receive_.size();
-
-    const bool all_servers_blocked = blocked_servers == server_addresses_.size();
-
-    if (all_servers_blocked) {
-      return;
-    }
-
-    cv_.wait(lock);
-  }
-}
-
-bool SimulatorHandle::MaybeTickSimulator() {
-  std::unique_lock<std::mutex> lock(mu_);
-
-  const size_t blocked_servers = blocked_on_receive_.size();
-
-  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

@@ -1,177 +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 <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/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 {
-
-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_;
-  std::set<Address> blocked_on_receive_;
-  std::set<Address> server_addresses_;
-  std::mt19937 rng_;
-  SimulatorConfig config_;
-
-  void TimeoutPromisesPastDeadline() {
-    const Time now = cluster_wide_time_microseconds_;
-    for (auto it = promises_.begin(); it != promises_.end();) {
-      auto &[promise_key, dop] = *it;
-      if (dop.deadline < now) {
-        spdlog::info("timing out request from requester {} to replier {}.", promise_key.requester_address.ToString(),
-                     promise_key.replier_address.ToString());
-        std::move(dop).promise.TimeOut();
-        it = promises_.erase(it);
-
-        stats_.timed_out_requests++;
-      } else {
-        ++it;
-      }
-    }
-  }
-
- 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, RequestId 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{.to_address = to_address,
-                     .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_.emplace(receiver);
-
-    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_.erase(receiver);
-
-          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_.erase(receiver);
-
-    return TimedOut{};
-  }
-
-  template <Message M>
-  void Send(Address to_address, Address from_address, RequestId request_id, M message) {
-    std::unique_lock<std::mutex> lock(mu_);
-    std::any message_any(std::move(message));
-    OpaqueMessage om{.to_address = to_address,
-                     .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

@@ -1,25 +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 <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

@@ -1,67 +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 <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 RequestT, Message ResponseT>
-  ResponseFuture<ResponseT> Request(Address to_address, Address from_address, uint64_t request_id, RequestT request,
-                                    Duration timeout) {
-    std::function<bool()> maybe_tick_simulator = [this] { return simulator_handle_->MaybeTickSimulator(); };
-    auto [future, promise] =
-        memgraph::io::FuturePromisePairWithNotifier<ResponseResult<ResponseT>>(maybe_tick_simulator);
-
-    simulator_handle_->SubmitRequest(to_address, from_address, request_id, std::move(request), timeout,
-                                     std::move(promise));
-
-    return std::move(future);
-  }
-
-  template <Message... Ms>
-  requires(sizeof...(Ms) > 0) RequestResult<Ms...> Receive(Address receiver_address, Duration timeout) {
-    return simulator_handle_->template Receive<Ms...>(receiver_address, timeout);
-  }
-
-  template <Message M>
-  void Send(Address to_address, Address from_address, uint64_t request_id, M message) {
-    return simulator_handle_->template Send<M>(to_address, from_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

@@ -1,21 +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 <chrono>
-
-namespace memgraph::io {
-
-using Duration = std::chrono::microseconds;
-using Time = std::chrono::time_point<std::chrono::system_clock, Duration>;
-
-}  // namespace memgraph::io

src/io/transport.hpp

@@ -1,144 +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 <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>>;
-
-using RequestId = uint64_t;
-
-template <Message M>
-struct ResponseEnvelope {
-  M message;
-  RequestId request_id;
-  Address to_address;
-  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;
-  RequestId request_id;
-  Address to_address;
-  Address from_address;
-};
-
-template <Message... Ms>
-using RequestResult = BasicResult<TimedOut, RequestEnvelope<Ms...>>;
-
-template <typename I>
-class Io {
-  I implementation_;
-  Address address_;
-  RequestId request_id_counter_ = 0;
-  Duration default_timeout_ = std::chrono::microseconds{100000};
-
- 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 RequestT, Message ResponseT>
-  ResponseFuture<ResponseT> RequestWithTimeout(Address address, RequestT request, Duration timeout) {
-    const RequestId request_id = ++request_id_counter_;
-    const Address from_address = address_;
-    return implementation_.template Request<RequestT, ResponseT>(address, from_address, request_id, request, timeout);
-  }
-
-  /// Issue a request that times out after the default timeout. This tends
-  /// to be used by clients.
-  template <Message RequestT, Message ResponseT>
-  ResponseFuture<ResponseT> Request(Address to_address, RequestT request) {
-    const RequestId request_id = ++request_id_counter_;
-    const Duration timeout = default_timeout_;
-    const Address from_address = address_;
-    return implementation_.template Request<RequestT, ResponseT>(to_address, from_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...>(address_, 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...>(address_, 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 to_address, RequestId request_id, M message) {
-    Address from_address = address_;
-    return implementation_.template Send<M>(to_address, from_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_; }
-  void SetAddress(Address address) { address_ = address; }
-
-  Io<I> ForkLocal() { return Io(implementation_, address_.ForkUniqueAddress()); }
-};
-};  // namespace memgraph::io

src/machine_manager/machine_config.hpp

@@ -1,42 +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 <boost/asio/ip/tcp.hpp>
-#include "io/address.hpp"
-#include "storage/v3/property_value.hpp"
-#include "storage/v3/schemas.hpp"
-
-namespace memgraph::machine_manager {
-
-using memgraph::io::Address;
-using memgraph::storage::v3::SchemaProperty;
-using CompoundKey = std::vector<memgraph::storage::v3::PropertyValue>;
-
-struct InitialLabelSpace {
-  std::string label_name;
-  std::vector<SchemaProperty> schema;
-  size_t replication_factor;
-  std::vector<CompoundKey> split_points;
-};
-
-struct MachineConfig {
-  std::vector<InitialLabelSpace> initial_label_spaces;
-  std::vector<Address> coordinator_addresses;
-  bool is_storage;
-  bool is_coordinator;
-  bool is_query_engine;
-  boost::asio::ip::address listen_ip;
-  uint16_t listen_port;
-};
-
-}  // namespace memgraph::machine_manager

src/machine_manager/machine_manager.hpp

@@ -1,177 +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 <coordinator/coordinator_rsm.hpp>
-#include <io/message_conversion.hpp>
-#include <io/messages.hpp>
-#include <io/rsm/rsm_client.hpp>
-#include <io/time.hpp>
-#include <machine_manager/machine_config.hpp>
-#include <storage/v3/shard_manager.hpp>
-
-namespace memgraph::machine_manager {
-
-using memgraph::coordinator::Coordinator;
-using memgraph::coordinator::CoordinatorReadRequests;
-using memgraph::coordinator::CoordinatorReadResponses;
-using memgraph::coordinator::CoordinatorRsm;
-using memgraph::coordinator::CoordinatorWriteRequests;
-using memgraph::coordinator::CoordinatorWriteResponses;
-using memgraph::io::ConvertVariant;
-using memgraph::io::Duration;
-using memgraph::io::RequestId;
-using memgraph::io::Time;
-using memgraph::io::messages::CoordinatorMessages;
-using memgraph::io::messages::ShardManagerMessages;
-using memgraph::io::messages::ShardMessages;
-using memgraph::io::messages::StorageReadRequest;
-using memgraph::io::messages::StorageWriteRequest;
-using memgraph::io::rsm::AppendRequest;
-using memgraph::io::rsm::AppendResponse;
-using memgraph::io::rsm::ReadRequest;
-using memgraph::io::rsm::VoteRequest;
-using memgraph::io::rsm::VoteResponse;
-using memgraph::io::rsm::WriteRequest;
-using memgraph::io::rsm::WriteResponse;
-using memgraph::storage::v3::ShardManager;
-
-/// The MachineManager is responsible for:
-/// * starting the entire system and ensuring that high-level
-///   operational requirements continue to be met
-/// * acting as a machine's single caller of Io::Receive
-/// * routing incoming messages from the Io interface to the
-///   appropriate Coordinator or to the StorageManager
-///   (it's not necessary to route anything in this layer
-///   to the query engine because the query engine only
-///   communicates using higher-level Futures that will
-///   be filled immediately when the response comes in
-///   at the lower-level transport layer.
-///
-/// Every storage engine has exactly one RsmEngine.
-template <typename IoImpl>
-class MachineManager {
-  io::Io<IoImpl> io_;
-  MachineConfig config_;
-  CoordinatorRsm<IoImpl> coordinator_;
-  ShardManager<IoImpl> shard_manager_;
-  Time next_cron_;
-
- public:
-  // TODO initialize ShardManager with "real" coordinator addresses instead of io.GetAddress
-  // which is only true for single-machine config.
-  MachineManager(io::Io<IoImpl> io, MachineConfig config, Coordinator coordinator)
-      : io_(io),
-        config_(config),
-        coordinator_{std::move(io.ForkLocal()), {}, std::move(coordinator)},
-        shard_manager_(ShardManager{io.ForkLocal(), coordinator_.GetAddress()}) {}
-
-  Address CoordinatorAddress() { return coordinator_.GetAddress(); }
-
-  void Run() {
-    while (!io_.ShouldShutDown()) {
-      const auto now = io_.Now();
-
-      if (now >= next_cron_) {
-        next_cron_ = Cron();
-      }
-
-      Duration receive_timeout = next_cron_ - now;
-
-      // Note: this parameter pack must be kept in-sync with the ReceiveWithTimeout parameter pack below
-      using AllMessages =
-          std::variant<ReadRequest<CoordinatorReadRequests>, AppendRequest<CoordinatorWriteRequests>, AppendResponse,
-                       WriteRequest<CoordinatorWriteRequests>, VoteRequest, VoteResponse,
-                       WriteResponse<CoordinatorWriteResponses>, ReadRequest<StorageReadRequest>,
-                       AppendRequest<StorageWriteRequest>, WriteRequest<StorageWriteRequest>>;
-
-      spdlog::info("MM waiting on Receive");
-
-      // Note: this parameter pack must be kept in-sync with the AllMessages parameter pack above
-      auto request_result = io_.template ReceiveWithTimeout<
-          ReadRequest<CoordinatorReadRequests>, AppendRequest<CoordinatorWriteRequests>, AppendResponse,
-          WriteRequest<CoordinatorWriteRequests>, VoteRequest, VoteResponse, WriteResponse<CoordinatorWriteResponses>,
-          ReadRequest<StorageReadRequest>, AppendRequest<StorageWriteRequest>, WriteRequest<StorageWriteRequest>>(
-          receive_timeout);
-
-      if (request_result.HasError()) {
-        // time to do Cron
-        spdlog::info("MM got timeout");
-        continue;
-      }
-
-      auto &&request_envelope = std::move(request_result.GetValue());
-
-      spdlog::info("MM got message to {}", request_envelope.to_address.ToString());
-
-      // If message is for the coordinator, cast it to subset and pass it to the coordinator
-      bool to_coordinator = coordinator_.GetAddress() == request_envelope.to_address;
-      spdlog::info("coordinator: {}", coordinator_.GetAddress().ToString());
-      if (to_coordinator) {
-        std::optional<CoordinatorMessages> conversion_attempt =
-            ConvertVariant<AllMessages, ReadRequest<CoordinatorReadRequests>, AppendRequest<CoordinatorWriteRequests>,
-                           AppendResponse, WriteRequest<CoordinatorWriteRequests>, VoteRequest, VoteResponse>(
-                std::move(request_envelope.message));
-
-        MG_ASSERT(conversion_attempt.has_value(), "coordinator message conversion failed");
-
-        spdlog::info("got coordinator message");
-
-        CoordinatorMessages &&cm = std::move(conversion_attempt.value());
-
-        coordinator_.Handle(std::forward<CoordinatorMessages>(cm), request_envelope.request_id,
-                            request_envelope.from_address);
-        continue;
-      }
-
-      bool to_sm = shard_manager_.GetAddress() == request_envelope.to_address;
-      spdlog::info("smm: {}", shard_manager_.GetAddress().ToString());
-      if (to_sm) {
-        std::optional<ShardManagerMessages> conversion_attempt =
-            ConvertVariant<AllMessages, WriteResponse<CoordinatorWriteResponses>>(std::move(request_envelope.message));
-
-        MG_ASSERT(conversion_attempt.has_value(), "shard manager message conversion failed");
-
-        spdlog::info("got shard manager message");
-
-        ShardManagerMessages &&smm = std::move(conversion_attempt.value());
-        shard_manager_.Receive(std::forward<ShardManagerMessages>(smm), request_envelope.request_id,
-                               request_envelope.from_address);
-        continue;
-      }
-
-      // treat this as a message to a specific shard rsm and cast it accordingly
-
-      std::optional<ShardMessages> conversion_attempt =
-          ConvertVariant<AllMessages, ReadRequest<StorageReadRequest>, AppendRequest<StorageWriteRequest>,
-                         AppendResponse, WriteRequest<StorageWriteRequest>, VoteRequest, VoteResponse>(
-              std::move(request_envelope.message));
-
-      MG_ASSERT(conversion_attempt.has_value(), "shard rsm message conversion failed for {}",
-                request_envelope.to_address.ToString());
-
-      spdlog::info("got shard rsm message");
-
-      ShardMessages &&sm = std::move(conversion_attempt.value());
-      shard_manager_.Route(std::forward<ShardMessages>(sm), request_envelope.request_id, request_envelope.to_address,
-                           request_envelope.from_address);
-    }
-  }
-
- private:
-  Time Cron() {
-    spdlog::info("running MachineManager::Cron, address {}", io_.GetAddress().ToString());
-    return shard_manager_.Cron();
-  }
-};
-
-}  // namespace memgraph::machine_manager

src/memgraph.cpp

@@ -37,18 +37,18 @@
 #include "communication/websocket/server.hpp"
 #include "helpers.hpp"
 #include "py/py.hpp"
-#include "query/auth_checker.hpp"
-#include "query/discard_value_stream.hpp"
-#include "query/exceptions.hpp"
-#include "query/frontend/ast/ast.hpp"
-#include "query/interpreter.hpp"
-#include "query/plan/operator.hpp"
-#include "query/procedure/module.hpp"
-#include "query/procedure/py_module.hpp"
+#include "query/v2/auth_checker.hpp"
+#include "query/v2/discard_value_stream.hpp"
+#include "query/v2/exceptions.hpp"
+#include "query/v2/frontend/ast/ast.hpp"
+#include "query/v2/interpreter.hpp"
+#include "query/v2/plan/operator.hpp"
+#include "query/v2/procedure/module.hpp"
+#include "query/v2/procedure/py_module.hpp"
 #include "requests/requests.hpp"
-#include "storage/v2/isolation_level.hpp"
-#include "storage/v2/storage.hpp"
-#include "storage/v2/view.hpp"
+#include "storage/v3/isolation_level.hpp"
+#include "storage/v3/storage.hpp"
+#include "storage/v3/view.hpp"
 #include "telemetry/telemetry.hpp"
 #include "utils/event_counter.hpp"
 #include "utils/file.hpp"
@@ -83,10 +83,10 @@
 #include "communication/init.hpp"
 #include "communication/v2/server.hpp"
 #include "communication/v2/session.hpp"
-#include "glue/communication.hpp"
+#include "glue/v2/communication.hpp"
 
 #include "auth/auth.hpp"
-#include "glue/auth.hpp"
+#include "glue/v2/auth.hpp"
 
 #ifdef MG_ENTERPRISE
 #include "audit/log.hpp"
@@ -197,12 +197,12 @@ DEFINE_bool(storage_wal_enabled, false,
 DEFINE_VALIDATED_uint64(storage_snapshot_retention_count, 3, "The number of snapshots that should always be kept.",
                         FLAG_IN_RANGE(1, 1000000));
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_VALIDATED_uint64(storage_wal_file_size_kib, memgraph::storage::Config::Durability().wal_file_size_kibibytes,
+DEFINE_VALIDATED_uint64(storage_wal_file_size_kib, memgraph::storage::v3::Config::Durability().wal_file_size_kibibytes,
                         "Minimum file size of each WAL file.",
                         FLAG_IN_RANGE(1, static_cast<unsigned long>(1000) * 1024));
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_VALIDATED_uint64(storage_wal_file_flush_every_n_tx,
-                        memgraph::storage::Config::Durability().wal_file_flush_every_n_tx,
+                        memgraph::storage::v3::Config::Durability().wal_file_flush_every_n_tx,
                         "Issue a 'fsync' call after this amount of transactions are written to the "
                         "WAL file. Set to 1 for fully synchronous operation.",
                         FLAG_IN_RANGE(1, 1000000));
@@ -271,9 +271,9 @@ DEFINE_uint64(
 namespace {
 using namespace std::literals;
 inline constexpr std::array isolation_level_mappings{
-    std::pair{"SNAPSHOT_ISOLATION"sv, memgraph::storage::IsolationLevel::SNAPSHOT_ISOLATION},
-    std::pair{"READ_COMMITTED"sv, memgraph::storage::IsolationLevel::READ_COMMITTED},
-    std::pair{"READ_UNCOMMITTED"sv, memgraph::storage::IsolationLevel::READ_UNCOMMITTED}};
+    std::pair{"SNAPSHOT_ISOLATION"sv, memgraph::storage::v3::IsolationLevel::SNAPSHOT_ISOLATION},
+    std::pair{"READ_COMMITTED"sv, memgraph::storage::v3::IsolationLevel::READ_COMMITTED},
+    std::pair{"READ_UNCOMMITTED"sv, memgraph::storage::v3::IsolationLevel::READ_UNCOMMITTED}};
 
 const std::string isolation_level_help_string =
     fmt::format("Default isolation level used for the transactions. Allowed values: {}",
@@ -302,9 +302,9 @@ DEFINE_VALIDATED_string(isolation_level, "SNAPSHOT_ISOLATION", isolation_level_h
 });
 
 namespace {
-memgraph::storage::IsolationLevel ParseIsolationLevel() {
+memgraph::storage::v3::IsolationLevel ParseIsolationLevel() {
   const auto isolation_level =
-      StringToEnum<memgraph::storage::IsolationLevel>(FLAGS_isolation_level, isolation_level_mappings);
+      StringToEnum<memgraph::storage::v3::IsolationLevel>(FLAGS_isolation_level, isolation_level_mappings);
   MG_ASSERT(isolation_level, "Invalid isolation level");
   return *isolation_level;
 }
@@ -445,22 +445,22 @@ struct SessionData {
   // supplied.
 #if MG_ENTERPRISE
 
-  SessionData(memgraph::storage::Storage *db, memgraph::query::InterpreterContext *interpreter_context,
+  SessionData(memgraph::storage::v3::Storage *db, memgraph::query::v2::InterpreterContext *interpreter_context,
               memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth,
               memgraph::audit::Log *audit_log)
       : db(db), interpreter_context(interpreter_context), auth(auth), audit_log(audit_log) {}
-  memgraph::storage::Storage *db;
-  memgraph::query::InterpreterContext *interpreter_context;
+  memgraph::storage::v3::Storage *db;
+  memgraph::query::v2::InterpreterContext *interpreter_context;
   memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth;
   memgraph::audit::Log *audit_log;
 
 #else
 
-  SessionData(memgraph::storage::Storage *db, memgraph::query::InterpreterContext *interpreter_context,
+  SessionData(memgraph::storage::v3::Storage *db, memgraph::query::v2::InterpreterContext *interpreter_context,
               memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth)
       : db(db), interpreter_context(interpreter_context), auth(auth) {}
-  memgraph::storage::Storage *db;
-  memgraph::query::InterpreterContext *interpreter_context;
+  memgraph::storage::v3::Storage *db;
+  memgraph::query::v2::InterpreterContext *interpreter_context;
   memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth;
 
 #endif
@@ -471,7 +471,7 @@ inline constexpr std::string_view default_user_role_regex = "[a-zA-Z0-9_.+-@]+";
 DEFINE_string(auth_user_or_role_name_regex, default_user_role_regex.data(),
               "Set to the regular expression that each user or role name must fulfill.");
 
-class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
+class AuthQueryHandler final : public memgraph::query::v2::AuthQueryHandler {
   memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
   std::string name_regex_string_;
   std::regex name_regex_;
@@ -494,7 +494,7 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
       }
     }
     if (!std::regex_match(username, name_regex_)) {
-      throw memgraph::query::QueryRuntimeException("Invalid user name.");
+      throw memgraph::query::v2::QueryRuntimeException("Invalid user name.");
     }
     try {
       const auto [first_user, user_added] = std::invoke([&, this] {
@@ -506,18 +506,18 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
 
       if (first_user) {
         spdlog::info("{} is first created user. Granting all privileges.", username);
-        GrantPrivilege(username, memgraph::query::kPrivilegesAll);
+        GrantPrivilege(username, memgraph::query::v2::kPrivilegesAll);
       }
 
       return user_added;
     } catch (const memgraph::auth::AuthException &e) {
-      throw memgraph::query::QueryRuntimeException(e.what());
+      throw memgraph::query::v2::QueryRuntimeException(e.what());
     }
   }
 
   bool DropUser(const std::string &username) override {
     if (!std::regex_match(username, name_regex_)) {
-      throw memgraph::query::QueryRuntimeException("Invalid user name.");
+      throw memgraph::query::v2::QueryRuntimeException("Invalid user name.");
     }
     try {
       auto locked_auth = auth_->Lock();
@@ -525,42 +525,42 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
       if (!user) return false;
       return locked_auth->RemoveUser(username);
     } catch (const memgraph::auth::AuthException &e) {
-      throw memgraph::query::QueryRuntimeException(e.what());
+      throw memgraph::query::v2::QueryRuntimeException(e.what());
     }
   }
 
   void SetPassword(const std::string &username, const std::optional<std::string> &password) override {
     if (!std::regex_match(username, name_regex_)) {
-      throw memgraph::query::QueryRuntimeException("Invalid user name.");
+      throw memgraph::query::v2::QueryRuntimeException("Invalid user name.");
     }
     try {
       auto locked_auth = auth_->Lock();
       auto user = locked_auth->GetUser(username);
       if (!user) {
-        throw memgraph::query::QueryRuntimeException("User '{}' doesn't exist.", username);
+        throw memgraph::query::v2::QueryRuntimeException("User '{}' doesn't exist.", username);
       }
       user->UpdatePassword(password);
       locked_auth->SaveUser(*user);
     } catch (const memgraph::auth::AuthException &e) {
-      throw memgraph::query::QueryRuntimeException(e.what());
+      throw memgraph::query::v2::QueryRuntimeException(e.what());
     }
   }
 
   bool CreateRole(const std::string &rolename) override {
     if (!std::regex_match(rolename, name_regex_)) {
-      throw memgraph::query::QueryRuntimeException("Invalid role name.");
+      throw memgraph::query::v2::QueryRuntimeException("Invalid role name.");
     }
     try {
       auto locked_auth = auth_->Lock();
       return locked_auth->AddRole(rolename).has_value();
     } catch (const memgraph::auth::AuthException &e) {
-      throw memgraph::query::QueryRuntimeException(e.what());
+      throw memgraph::query::v2::QueryRuntimeException(e.what());
     }
   }
 
   bool DropRole(const std::string &rolename) override {
     if (!std::regex_match(rolename, name_regex_)) {
-      throw memgraph::query::QueryRuntimeException("Invalid role name.");
+      throw memgraph::query::v2::QueryRuntimeException("Invalid role name.");
     }
     try {
       auto locked_auth = auth_->Lock();
@@ -568,14 +568,14 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
       if (!role) return false;
       return locked_auth->RemoveRole(rolename);
     } catch (const memgraph::auth::AuthException &e) {
-      throw memgraph::query::QueryRuntimeException(e.what());
+      throw memgraph::query::v2::QueryRuntimeException(e.what());
     }
   }
 
-  std::vector<memgraph::query::TypedValue> GetUsernames() override {
+  std::vector<memgraph::query::v2::TypedValue> GetUsernames() override {
     try {
       auto locked_auth = auth_->ReadLock();
-      std::vector<memgraph::query::TypedValue> usernames;
+      std::vector<memgraph::query::v2::TypedValue> usernames;
       const auto &users = locked_auth->AllUsers();
       usernames.reserve(users.size());
       for (const auto &user : users) {
@@ -583,14 +583,14 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
       }
       return usernames;
     } catch (const memgraph::auth::AuthException &e) {
-      throw memgraph::query::QueryRuntimeException(e.what());
+      throw memgraph::query::v2::QueryRuntimeException(e.what());
     }
   }
 
-  std::vector<memgraph::query::TypedValue> GetRolenames() override {
+  std::vector<memgraph::query::v2::TypedValue> GetRolenames() override {
     try {
       auto locked_auth = auth_->ReadLock();
-      std::vector<memgraph::query::TypedValue> rolenames;
+      std::vector<memgraph::query::v2::TypedValue> rolenames;
       const auto &roles = locked_auth->AllRoles();
       rolenames.reserve(roles.size());
       for (const auto &role : roles) {
@@ -598,19 +598,19 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
       }
       return rolenames;
     } catch (const memgraph::auth::AuthException &e) {
-      throw memgraph::query::QueryRuntimeException(e.what());
+      throw memgraph::query::v2::QueryRuntimeException(e.what());
     }
   }
 
   std::optional<std::string> GetRolenameForUser(const std::string &username) override {
     if (!std::regex_match(username, name_regex_)) {
-      throw memgraph::query::QueryRuntimeException("Invalid user name.");
+      throw memgraph::query::v2::QueryRuntimeException("Invalid user name.");
     }
     try {
       auto locked_auth = auth_->ReadLock();
       auto user = locked_auth->GetUser(username);
       if (!user) {
-        throw memgraph::query::QueryRuntimeException("User '{}' doesn't exist .", username);
+        throw memgraph::query::v2::QueryRuntimeException("User '{}' doesn't exist .", username);
       }
 
       if (const auto *role = user->role(); role != nullptr) {
@@ -618,21 +618,21 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
       }
       return std::nullopt;
     } catch (const memgraph::auth::AuthException &e) {
-      throw memgraph::query::QueryRuntimeException(e.what());
+      throw memgraph::query::v2::QueryRuntimeException(e.what());
     }
   }
 
-  std::vector<memgraph::query::TypedValue> GetUsernamesForRole(const std::string &rolename) override {
+  std::vector<memgraph::query::v2::TypedValue> GetUsernamesForRole(const std::string &rolename) override {
     if (!std::regex_match(rolename, name_regex_)) {
-      throw memgraph::query::QueryRuntimeException("Invalid role name.");
+      throw memgraph::query::v2::QueryRuntimeException("Invalid role name.");
     }
     try {
       auto locked_auth = auth_->ReadLock();
       auto role = locked_auth->GetRole(rolename);
       if (!role) {
-        throw memgraph::query::QueryRuntimeException("Role '{}' doesn't exist.", rolename);
+        throw memgraph::query::v2::QueryRuntimeException("Role '{}' doesn't exist.", rolename);
       }
-      std::vector<memgraph::query::TypedValue> usernames;
+      std::vector<memgraph::query::v2::TypedValue> usernames;
       const auto &users = locked_auth->AllUsersForRole(rolename);
       usernames.reserve(users.size());
       for (const auto &user : users) {
@@ -640,71 +640,71 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
       }
       return usernames;
     } catch (const memgraph::auth::AuthException &e) {
-      throw memgraph::query::QueryRuntimeException(e.what());
+      throw memgraph::query::v2::QueryRuntimeException(e.what());
     }
   }
 
   void SetRole(const std::string &username, const std::string &rolename) override {
     if (!std::regex_match(username, name_regex_)) {
-      throw memgraph::query::QueryRuntimeException("Invalid user name.");
+      throw memgraph::query::v2::QueryRuntimeException("Invalid user name.");
     }
     if (!std::regex_match(rolename, name_regex_)) {
-      throw memgraph::query::QueryRuntimeException("Invalid role name.");
+      throw memgraph::query::v2::QueryRuntimeException("Invalid role name.");
     }
     try {
       auto locked_auth = auth_->Lock();
       auto user = locked_auth->GetUser(username);
       if (!user) {
-        throw memgraph::query::QueryRuntimeException("User '{}' doesn't exist .", username);
+        throw memgraph::query::v2::QueryRuntimeException("User '{}' doesn't exist .", username);
       }
       auto role = locked_auth->GetRole(rolename);
       if (!role) {
-        throw memgraph::query::QueryRuntimeException("Role '{}' doesn't exist .", rolename);
+        throw memgraph::query::v2::QueryRuntimeException("Role '{}' doesn't exist .", rolename);
       }
       if (const auto *current_role = user->role(); current_role != nullptr) {
-        throw memgraph::query::QueryRuntimeException("User '{}' is already a member of role '{}'.", username,
-                                                     current_role->rolename());
+        throw memgraph::query::v2::QueryRuntimeException("User '{}' is already a member of role '{}'.", username,
+                                                         current_role->rolename());
       }
       user->SetRole(*role);
       locked_auth->SaveUser(*user);
     } catch (const memgraph::auth::AuthException &e) {
-      throw memgraph::query::QueryRuntimeException(e.what());
+      throw memgraph::query::v2::QueryRuntimeException(e.what());
     }
   }
 
   void ClearRole(const std::string &username) override {
     if (!std::regex_match(username, name_regex_)) {
-      throw memgraph::query::QueryRuntimeException("Invalid user name.");
+      throw memgraph::query::v2::QueryRuntimeException("Invalid user name.");
     }
     try {
       auto locked_auth = auth_->Lock();
       auto user = locked_auth->GetUser(username);
       if (!user) {
-        throw memgraph::query::QueryRuntimeException("User '{}' doesn't exist .", username);
+        throw memgraph::query::v2::QueryRuntimeException("User '{}' doesn't exist .", username);
       }
       user->ClearRole();
       locked_auth->SaveUser(*user);
     } catch (const memgraph::auth::AuthException &e) {
-      throw memgraph::query::QueryRuntimeException(e.what());
+      throw memgraph::query::v2::QueryRuntimeException(e.what());
     }
   }
 
-  std::vector<std::vector<memgraph::query::TypedValue>> GetPrivileges(const std::string &user_or_role) override {
+  std::vector<std::vector<memgraph::query::v2::TypedValue>> GetPrivileges(const std::string &user_or_role) override {
     if (!std::regex_match(user_or_role, name_regex_)) {
-      throw memgraph::query::QueryRuntimeException("Invalid user or role name.");
+      throw memgraph::query::v2::QueryRuntimeException("Invalid user or role name.");
     }
     try {
       auto locked_auth = auth_->ReadLock();
-      std::vector<std::vector<memgraph::query::TypedValue>> grants;
+      std::vector<std::vector<memgraph::query::v2::TypedValue>> grants;
       auto user = locked_auth->GetUser(user_or_role);
       auto role = locked_auth->GetRole(user_or_role);
       if (!user && !role) {
-        throw memgraph::query::QueryRuntimeException("User or role '{}' doesn't exist.", user_or_role);
+        throw memgraph::query::v2::QueryRuntimeException("User or role '{}' doesn't exist.", user_or_role);
       }
       if (user) {
         const auto &permissions = user->GetPermissions();
-        for (const auto &privilege : memgraph::query::kPrivilegesAll) {
-          auto permission = memgraph::glue::PrivilegeToPermission(privilege);
+        for (const auto &privilege : memgraph::query::v2::kPrivilegesAll) {
+          auto permission = memgraph::glue::v2::PrivilegeToPermission(privilege);
           auto effective = permissions.Has(permission);
           if (permissions.Has(permission) != memgraph::auth::PermissionLevel::NEUTRAL) {
             std::vector<std::string> description;
@@ -722,15 +722,15 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
                 description.emplace_back("DENIED TO ROLE");
               }
             }
-            grants.push_back({memgraph::query::TypedValue(memgraph::auth::PermissionToString(permission)),
-                              memgraph::query::TypedValue(memgraph::auth::PermissionLevelToString(effective)),
-                              memgraph::query::TypedValue(memgraph::utils::Join(description, ", "))});
+            grants.push_back({memgraph::query::v2::TypedValue(memgraph::auth::PermissionToString(permission)),
+                              memgraph::query::v2::TypedValue(memgraph::auth::PermissionLevelToString(effective)),
+                              memgraph::query::v2::TypedValue(memgraph::utils::Join(description, ", "))});
           }
         }
       } else {
         const auto &permissions = role->permissions();
-        for (const auto &privilege : memgraph::query::kPrivilegesAll) {
-          auto permission = memgraph::glue::PrivilegeToPermission(privilege);
+        for (const auto &privilege : memgraph::query::v2::kPrivilegesAll) {
+          auto permission = memgraph::glue::v2::PrivilegeToPermission(privilege);
           auto effective = permissions.Has(permission);
           if (effective != memgraph::auth::PermissionLevel::NEUTRAL) {
             std::string description;
@@ -739,20 +739,20 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
             } else if (effective == memgraph::auth::PermissionLevel::DENY) {
               description = "DENIED TO ROLE";
             }
-            grants.push_back({memgraph::query::TypedValue(memgraph::auth::PermissionToString(permission)),
-                              memgraph::query::TypedValue(memgraph::auth::PermissionLevelToString(effective)),
-                              memgraph::query::TypedValue(description)});
+            grants.push_back({memgraph::query::v2::TypedValue(memgraph::auth::PermissionToString(permission)),
+                              memgraph::query::v2::TypedValue(memgraph::auth::PermissionLevelToString(effective)),
+                              memgraph::query::v2::TypedValue(description)});
           }
         }
       }
       return grants;
     } catch (const memgraph::auth::AuthException &e) {
-      throw memgraph::query::QueryRuntimeException(e.what());
+      throw memgraph::query::v2::QueryRuntimeException(e.what());
     }
   }
 
   void GrantPrivilege(const std::string &user_or_role,
-                      const std::vector<memgraph::query::AuthQuery::Privilege> &privileges) override {
+                      const std::vector<memgraph::query::v2::AuthQuery::Privilege> &privileges) override {
     EditPermissions(user_or_role, privileges, [](auto *permissions, const auto &permission) {
       // TODO (mferencevic): should we first check that the
       // privilege is granted/denied/revoked before
@@ -762,7 +762,7 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
   }
 
   void DenyPrivilege(const std::string &user_or_role,
-                     const std::vector<memgraph::query::AuthQuery::Privilege> &privileges) override {
+                     const std::vector<memgraph::query::v2::AuthQuery::Privilege> &privileges) override {
     EditPermissions(user_or_role, privileges, [](auto *permissions, const auto &permission) {
       // TODO (mferencevic): should we first check that the
       // privilege is granted/denied/revoked before
@@ -772,7 +772,7 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
   }
 
   void RevokePrivilege(const std::string &user_or_role,
-                       const std::vector<memgraph::query::AuthQuery::Privilege> &privileges) override {
+                       const std::vector<memgraph::query::v2::AuthQuery::Privilege> &privileges) override {
     EditPermissions(user_or_role, privileges, [](auto *permissions, const auto &permission) {
       // TODO (mferencevic): should we first check that the
       // privilege is granted/denied/revoked before
@@ -784,21 +784,22 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
  private:
   template <class TEditFun>
   void EditPermissions(const std::string &user_or_role,
-                       const std::vector<memgraph::query::AuthQuery::Privilege> &privileges, const TEditFun &edit_fun) {
+                       const std::vector<memgraph::query::v2::AuthQuery::Privilege> &privileges,
+                       const TEditFun &edit_fun) {
     if (!std::regex_match(user_or_role, name_regex_)) {
-      throw memgraph::query::QueryRuntimeException("Invalid user or role name.");
+      throw memgraph::query::v2::QueryRuntimeException("Invalid user or role name.");
     }
     try {
       std::vector<memgraph::auth::Permission> permissions;
       permissions.reserve(privileges.size());
       for (const auto &privilege : privileges) {
-        permissions.push_back(memgraph::glue::PrivilegeToPermission(privilege));
+        permissions.push_back(memgraph::glue::v2::PrivilegeToPermission(privilege));
       }
       auto locked_auth = auth_->Lock();
       auto user = locked_auth->GetUser(user_or_role);
       auto role = locked_auth->GetRole(user_or_role);
       if (!user && !role) {
-        throw memgraph::query::QueryRuntimeException("User or role '{}' doesn't exist.", user_or_role);
+        throw memgraph::query::v2::QueryRuntimeException("User or role '{}' doesn't exist.", user_or_role);
       }
       if (user) {
         for (const auto &permission : permissions) {
@@ -812,28 +813,28 @@ class AuthQueryHandler final : public memgraph::query::AuthQueryHandler {
         locked_auth->SaveRole(*role);
       }
     } catch (const memgraph::auth::AuthException &e) {
-      throw memgraph::query::QueryRuntimeException(e.what());
+      throw memgraph::query::v2::QueryRuntimeException(e.what());
     }
   }
 };
 
-class AuthChecker final : public memgraph::query::AuthChecker {
+class AuthChecker final : public memgraph::query::v2::AuthChecker {
  public:
   explicit AuthChecker(
       memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth)
       : auth_{auth} {}
 
   static bool IsUserAuthorized(const memgraph::auth::User &user,
-                               const std::vector<memgraph::query::AuthQuery::Privilege> &privileges) {
+                               const std::vector<memgraph::query::v2::AuthQuery::Privilege> &privileges) {
     const auto user_permissions = user.GetPermissions();
     return std::all_of(privileges.begin(), privileges.end(), [&user_permissions](const auto privilege) {
-      return user_permissions.Has(memgraph::glue::PrivilegeToPermission(privilege)) ==
+      return user_permissions.Has(memgraph::glue::v2::PrivilegeToPermission(privilege)) ==
              memgraph::auth::PermissionLevel::GRANT;
     });
   }
 
   bool IsUserAuthorized(const std::optional<std::string> &username,
-                        const std::vector<memgraph::query::AuthQuery::Privilege> &privileges) const final {
+                        const std::vector<memgraph::query::v2::AuthQuery::Privilege> &privileges) const final {
     std::optional<memgraph::auth::User> maybe_user;
     {
       auto locked_auth = auth_->ReadLock();
@@ -880,8 +881,8 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
 
   std::pair<std::vector<std::string>, std::optional<int>> Interpret(
       const std::string &query, const std::map<std::string, memgraph::communication::bolt::Value> &params) override {
-    std::map<std::string, memgraph::storage::PropertyValue> params_pv;
-    for (const auto &kv : params) params_pv.emplace(kv.first, memgraph::glue::ToPropertyValue(kv.second));
+    std::map<std::string, memgraph::storage::v3::PropertyValue> params_pv;
+    for (const auto &kv : params) params_pv.emplace(kv.first, memgraph::glue::v2::ToPropertyValue(kv.second));
     const std::string *username{nullptr};
     if (user_) {
       username = &user_->username();
@@ -889,7 +890,7 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
 #ifdef MG_ENTERPRISE
     if (memgraph::utils::license::global_license_checker.IsValidLicenseFast()) {
       audit_log_->Record(endpoint_.address().to_string(), user_ ? *username : "", query,
-                         memgraph::storage::PropertyValue(params_pv));
+                         memgraph::storage::v3::PropertyValue(params_pv));
     }
 #endif
     try {
@@ -902,7 +903,7 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
       }
       return {result.headers, result.qid};
 
-    } catch (const memgraph::query::QueryException &e) {
+    } catch (const memgraph::query::v2::QueryException &e) {
       // Wrap QueryException into ClientError, because we want to allow the
       // client to fix their query.
       throw memgraph::communication::bolt::ClientError(e.what());
@@ -917,7 +918,7 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
 
   std::map<std::string, memgraph::communication::bolt::Value> Discard(std::optional<int> n,
                                                                       std::optional<int> qid) override {
-    memgraph::query::DiscardValueResultStream stream;
+    memgraph::query::v2::DiscardValueResultStream stream;
     return PullResults(stream, n, qid);
   }
 
@@ -945,21 +946,21 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
       const auto &summary = interpreter_.Pull(&stream, n, qid);
       std::map<std::string, memgraph::communication::bolt::Value> decoded_summary;
       for (const auto &kv : summary) {
-        auto maybe_value = memgraph::glue::ToBoltValue(kv.second, *db_, memgraph::storage::View::NEW);
+        auto maybe_value = memgraph::glue::v2::ToBoltValue(kv.second, *db_, memgraph::storage::v3::View::NEW);
         if (maybe_value.HasError()) {
           switch (maybe_value.GetError()) {
-            case memgraph::storage::Error::DELETED_OBJECT:
-            case memgraph::storage::Error::SERIALIZATION_ERROR:
-            case memgraph::storage::Error::VERTEX_HAS_EDGES:
-            case memgraph::storage::Error::PROPERTIES_DISABLED:
-            case memgraph::storage::Error::NONEXISTENT_OBJECT:
+            case memgraph::storage::v3::Error::DELETED_OBJECT:
+            case memgraph::storage::v3::Error::SERIALIZATION_ERROR:
+            case memgraph::storage::v3::Error::VERTEX_HAS_EDGES:
+            case memgraph::storage::v3::Error::PROPERTIES_DISABLED:
+            case memgraph::storage::v3::Error::NONEXISTENT_OBJECT:
               throw memgraph::communication::bolt::ClientError("Unexpected storage error when streaming summary.");
           }
         }
         decoded_summary.emplace(kv.first, std::move(*maybe_value));
       }
       return decoded_summary;
-    } catch (const memgraph::query::QueryException &e) {
+    } catch (const memgraph::query::v2::QueryException &e) {
       // Wrap QueryException into ClientError, because we want to allow the
       // client to fix their query.
       throw memgraph::communication::bolt::ClientError(e.what());
@@ -970,22 +971,22 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
   /// before forwarding the calls to original TEncoder.
   class TypedValueResultStream {
    public:
-    TypedValueResultStream(TEncoder *encoder, const memgraph::storage::Storage *db) : encoder_(encoder), db_(db) {}
+    TypedValueResultStream(TEncoder *encoder, const memgraph::storage::v3::Storage *db) : encoder_(encoder), db_(db) {}
 
-    void Result(const std::vector<memgraph::query::TypedValue> &values) {
+    void Result(const std::vector<memgraph::query::v2::TypedValue> &values) {
       std::vector<memgraph::communication::bolt::Value> decoded_values;
       decoded_values.reserve(values.size());
       for (const auto &v : values) {
-        auto maybe_value = memgraph::glue::ToBoltValue(v, *db_, memgraph::storage::View::NEW);
+        auto maybe_value = memgraph::glue::v2::ToBoltValue(v, *db_, memgraph::storage::v3::View::NEW);
         if (maybe_value.HasError()) {
           switch (maybe_value.GetError()) {
-            case memgraph::storage::Error::DELETED_OBJECT:
+            case memgraph::storage::v3::Error::DELETED_OBJECT:
               throw memgraph::communication::bolt::ClientError("Returning a deleted object as a result.");
-            case memgraph::storage::Error::NONEXISTENT_OBJECT:
+            case memgraph::storage::v3::Error::NONEXISTENT_OBJECT:
               throw memgraph::communication::bolt::ClientError("Returning a nonexistent object as a result.");
-            case memgraph::storage::Error::VERTEX_HAS_EDGES:
-            case memgraph::storage::Error::SERIALIZATION_ERROR:
-            case memgraph::storage::Error::PROPERTIES_DISABLED:
+            case memgraph::storage::v3::Error::VERTEX_HAS_EDGES:
+            case memgraph::storage::v3::Error::SERIALIZATION_ERROR:
+            case memgraph::storage::v3::Error::PROPERTIES_DISABLED:
               throw memgraph::communication::bolt::ClientError("Unexpected storage error when streaming results.");
           }
         }
@@ -997,12 +998,12 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
    private:
     TEncoder *encoder_;
     // NOTE: Needed only for ToBoltValue conversions
-    const memgraph::storage::Storage *db_;
+    const memgraph::storage::v3::Storage *db_;
   };
 
   // NOTE: Needed only for ToBoltValue conversions
-  const memgraph::storage::Storage *db_;
-  memgraph::query::Interpreter interpreter_;
+  const memgraph::storage::v3::Storage *db_;
+  memgraph::query::v2::Interpreter interpreter_;
   memgraph::utils::Synchronized<memgraph::auth::Auth, memgraph::utils::WritePrioritizedRWLock> *auth_;
   std::optional<memgraph::auth::User> user_;
 #ifdef MG_ENTERPRISE
@@ -1065,7 +1066,7 @@ int main(int argc, char **argv) {
   // Set program name, so Python can find its way to runtime libraries relative
   // to executable.
   Py_SetProgramName(program_name);
-  PyImport_AppendInittab("_mgp", &memgraph::query::procedure::PyInitMgpModule);
+  PyImport_AppendInittab("_mgp", &memgraph::query::v2::procedure::PyInitMgpModule);
   Py_InitializeEx(0 /* = initsigs */);
   PyEval_InitThreads();
   Py_BEGIN_ALLOW_THREADS;
@@ -1191,8 +1192,8 @@ int main(int argc, char **argv) {
 #endif
 
   // Main storage and execution engines initialization
-  memgraph::storage::Config db_config{
-      .gc = {.type = memgraph::storage::Config::Gc::Type::PERIODIC,
+  memgraph::storage::v3::Config db_config{
+      .gc = {.type = memgraph::storage::v3::Config::Gc::Type::PERIODIC,
              .interval = std::chrono::seconds(FLAGS_storage_gc_cycle_sec)},
       .items = {.properties_on_edges = FLAGS_storage_properties_on_edges},
       .durability = {.storage_directory = FLAGS_data_directory,
@@ -1200,8 +1201,7 @@ int main(int argc, char **argv) {
                      .snapshot_retention_count = FLAGS_storage_snapshot_retention_count,
                      .wal_file_size_kibibytes = FLAGS_storage_wal_file_size_kib,
                      .wal_file_flush_every_n_tx = FLAGS_storage_wal_file_flush_every_n_tx,
-                     .snapshot_on_exit = FLAGS_storage_snapshot_on_exit,
-                     .restore_replicas_on_startup = FLAGS_storage_restore_replicas_on_startup},
+                     .snapshot_on_exit = FLAGS_storage_snapshot_on_exit},
       .transaction = {.isolation_level = ParseIsolationLevel()}};
   if (FLAGS_storage_snapshot_interval_sec == 0) {
     if (FLAGS_storage_wal_enabled) {
@@ -1209,21 +1209,21 @@ int main(int argc, char **argv) {
           "In order to use write-ahead-logging you must enable "
           "periodic snapshots by setting the snapshot interval to a "
           "value larger than 0!");
-      db_config.durability.snapshot_wal_mode = memgraph::storage::Config::Durability::SnapshotWalMode::DISABLED;
+      db_config.durability.snapshot_wal_mode = memgraph::storage::v3::Config::Durability::SnapshotWalMode::DISABLED;
     }
   } else {
     if (FLAGS_storage_wal_enabled) {
       db_config.durability.snapshot_wal_mode =
-          memgraph::storage::Config::Durability::SnapshotWalMode::PERIODIC_SNAPSHOT_WITH_WAL;
+          memgraph::storage::v3::Config::Durability::SnapshotWalMode::PERIODIC_SNAPSHOT_WITH_WAL;
     } else {
       db_config.durability.snapshot_wal_mode =
-          memgraph::storage::Config::Durability::SnapshotWalMode::PERIODIC_SNAPSHOT;
+          memgraph::storage::v3::Config::Durability::SnapshotWalMode::PERIODIC_SNAPSHOT;
     }
     db_config.durability.snapshot_interval = std::chrono::seconds(FLAGS_storage_snapshot_interval_sec);
   }
-  memgraph::storage::Storage db(db_config);
+  memgraph::storage::v3::Storage db(db_config);
 
-  memgraph::query::InterpreterContext interpreter_context{
+  memgraph::query::v2::InterpreterContext interpreter_context{
       &db,
       {.query = {.allow_load_csv = FLAGS_allow_load_csv},
        .execution_timeout_sec = FLAGS_query_execution_timeout_sec,
@@ -1239,8 +1239,8 @@ int main(int argc, char **argv) {
   SessionData session_data{&db, &interpreter_context, &auth};
 #endif
 
-  memgraph::query::procedure::gModuleRegistry.SetModulesDirectory(query_modules_directories, FLAGS_data_directory);
-  memgraph::query::procedure::gModuleRegistry.UnloadAndLoadModulesFromDirectories();
+  memgraph::query::v2::procedure::gModuleRegistry.SetModulesDirectory(query_modules_directories, FLAGS_data_directory);
+  memgraph::query::v2::procedure::gModuleRegistry.UnloadAndLoadModulesFromDirectories();
 
   AuthQueryHandler auth_handler(&auth, FLAGS_auth_user_or_role_name_regex);
   AuthChecker auth_checker{&auth};
@@ -1251,7 +1251,7 @@ int main(int argc, char **argv) {
     // Triggers can execute query procedures, so we need to reload the modules first and then
     // the triggers
     auto storage_accessor = interpreter_context.db->Access();
-    auto dba = memgraph::query::DbAccessor{&storage_accessor};
+    auto dba = memgraph::query::v2::DbAccessor{&storage_accessor};
     interpreter_context.trigger_store.RestoreTriggers(
         &interpreter_context.ast_cache, &dba, interpreter_context.config.query, interpreter_context.auth_checker);
   }
@@ -1292,7 +1292,7 @@ int main(int argc, char **argv) {
       return ret;
     });
     telemetry->AddCollector("query_module_counters", []() -> nlohmann::json {
-      return memgraph::query::plan::CallProcedure::GetAndResetCounters();
+      return memgraph::query::v2::plan::CallProcedure::GetAndResetCounters();
     });
   }
 
@@ -1309,7 +1309,7 @@ int main(int argc, char **argv) {
     // After the server is notified to stop accepting and processing
     // connections we tell the execution engine to stop processing all pending
     // queries.
-    memgraph::query::Shutdown(&interpreter_context);
+    memgraph::query::v2::Shutdown(&interpreter_context);
     websocket_server.Shutdown();
   };
 
@@ -1321,7 +1321,7 @@ int main(int argc, char **argv) {
   server.AwaitShutdown();
   websocket_server.AwaitShutdown();
 
-  memgraph::query::procedure::gModuleRegistry.UnloadAllModules();
+  memgraph::query::v2::procedure::gModuleRegistry.UnloadAllModules();
 
   Py_END_ALLOW_THREADS;
   // Shutdown Python

src/parser/CMakeLists.txt

@@ -1,41 +0,0 @@
-## Generate Antlr openCypher parser
-
-set(opencypher_frontend ${CMAKE_CURRENT_SOURCE_DIR}/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(generated_opencypher_parser
-    DEPENDS ${antlr_opencypher_generated_src} ${antlr_opencypher_generated_include})
-
-add_library(mg-parser STATIC ${antlr_opencypher_generated_src})
-add_dependencies(mg-parser generated_opencypher_parser)
-target_include_directories(mg-parser PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
-target_link_libraries(mg-parser antlr4)

src/query/v2/CMakeLists.txt

@@ -1,6 +1,7 @@
 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})
@@ -10,9 +11,14 @@ set(mg_query_v2_sources
     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
@@ -23,28 +29,25 @@ set(mg_query_v2_sources
     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
+    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
-    bindings/typed_value.cpp
-    accessors.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_include_directories(mg-query-v2 PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/bindings)
 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)
-target_link_libraries(mg-query-v2 mg-expr)
 
 if(NOT "${MG_PYTHON_PATH}" STREQUAL "")
     set(Python3_ROOT_DIR "${MG_PYTHON_PATH}")
@@ -57,3 +60,45 @@ else()
 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/accessors.cpp

@@ -1,75 +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/v2/accessors.hpp"
-#include "query/v2/requests.hpp"
-
-namespace memgraph::query::v2::accessors {
-EdgeAccessor::EdgeAccessor(Edge edge, std::vector<std::pair<PropertyId, Value>> props)
-    : edge(std::move(edge)), properties(std::move(props)) {}
-
-uint64_t EdgeAccessor::EdgeType() const { return edge.type.id; }
-
-std::vector<std::pair<PropertyId, Value>> EdgeAccessor::Properties() const {
-  return properties;
-  //    std::map<std::string, TypedValue> res;
-  //    for (const auto &[name, value] : *properties) {
-  //      res[name] = ValueToTypedValue(value);
-  //    }
-  //    return res;
-}
-
-// NOLINTNEXTLINE(readability-convert-member-functions-to-static)
-Value EdgeAccessor::GetProperty(const std::string & /*prop_name*/) const {
-  // TODO(kostasrim) fix this
-  return {};
-}
-
-Edge EdgeAccessor::GetEdge() const { return edge; }
-
-VertexAccessor EdgeAccessor::To() const { return VertexAccessor(Vertex{edge.dst}, {}); }
-
-VertexAccessor EdgeAccessor::From() const { return VertexAccessor(Vertex{edge.src}, {}); }
-
-VertexAccessor::VertexAccessor(Vertex v, std::vector<std::pair<PropertyId, Value>> props)
-    : vertex(std::move(v)), properties(std::move(props)) {}
-
-std::vector<Label> VertexAccessor::Labels() const { return vertex.labels; }
-
-bool VertexAccessor::HasLabel(Label &label) const {
-  return std::find_if(vertex.labels.begin(), vertex.labels.end(),
-                      [label](const auto &l) { return l.id == label.id; }) != vertex.labels.end();
-}
-
-std::vector<std::pair<PropertyId, Value>> VertexAccessor::Properties() const {
-  //    std::map<std::string, TypedValue> res;
-  //    for (const auto &[name, value] : *properties) {
-  //      res[name] = ValueToTypedValue(value);
-  //    }
-  //    return res;
-  return properties;
-}
-
-Value VertexAccessor::GetProperty(PropertyId prop_id) const {
-  return std::find_if(properties.begin(), properties.end(), [&](auto &pr) { return prop_id == pr.first; })->second;
-  //    return ValueToTypedValue(properties[prop_name]);
-}
-
-// NOLINTNEXTLINE(readability-convert-member-functions-to-static)
-Value VertexAccessor::GetProperty(const std::string & /*prop_name*/) const {
-  // TODO(kostasrim) Add string mapping
-  return {};
-  //    return ValueToTypedValue(properties[prop_name]);
-}
-
-msgs::Vertex VertexAccessor::GetVertex() const { return vertex; }
-
-}  // namespace memgraph::query::v2::accessors

src/query/v2/accessors.hpp

@@ -1,187 +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 <optional>
-#include <utility>
-#include <vector>
-
-#include "query/exceptions.hpp"
-#include "query/v2/requests.hpp"
-#include "storage/v3/view.hpp"
-#include "utils/bound.hpp"
-#include "utils/exceptions.hpp"
-#include "utils/memory.hpp"
-#include "utils/memory_tracker.hpp"
-
-namespace memgraph::query::v2::accessors {
-
-using Value = memgraph::msgs::Value;
-using Edge = memgraph::msgs::Edge;
-using Vertex = memgraph::msgs::Vertex;
-using Label = memgraph::msgs::Label;
-using PropertyId = memgraph::msgs::PropertyId;
-
-class VertexAccessor;
-
-class EdgeAccessor final {
- public:
-  EdgeAccessor(Edge edge, std::vector<std::pair<PropertyId, Value>> props);
-
-  uint64_t EdgeType() const;
-
-  std::vector<std::pair<PropertyId, Value>> Properties() const;
-
-  Value GetProperty(const std::string &prop_name) const;
-
-  Edge GetEdge() const;
-
-  // Dummy function
-  // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
-  inline size_t CypherId() const { return 10; }
-
-  //  bool HasSrcAccessor const { return src == nullptr; }
-  //  bool HasDstAccessor const { return dst == nullptr; }
-
-  VertexAccessor To() const;
-  VertexAccessor From() const;
-
-  friend bool operator==(const EdgeAccessor &lhs, const EdgeAccessor &rhs) {
-    return lhs.edge == rhs.edge && lhs.properties == rhs.properties;
-  }
-
-  friend bool operator!=(const EdgeAccessor &lhs, const EdgeAccessor &rhs) { return !(lhs == rhs); }
-
- private:
-  Edge edge;
-  std::vector<std::pair<PropertyId, Value>> properties;
-};
-
-class VertexAccessor final {
- public:
-  using PropertyId = msgs::PropertyId;
-  using Label = msgs::Label;
-  VertexAccessor(Vertex v, std::vector<std::pair<PropertyId, Value>> props);
-
-  std::vector<Label> Labels() const;
-
-  bool HasLabel(Label &label) const;
-
-  std::vector<std::pair<PropertyId, Value>> Properties() const;
-
-  Value GetProperty(PropertyId prop_id) const;
-  Value GetProperty(const std::string &prop_name) const;
-
-  msgs::Vertex GetVertex() const;
-
-  // Dummy function
-  // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
-  inline size_t CypherId() const { return 10; }
-
-  //  auto InEdges(storage::View view, const std::vector<storage::EdgeTypeId> &edge_types) const
-  //      -> storage::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::View view) const { return InEdges(view, {}); }
-  //
-  //  auto InEdges(storage::View view, const std::vector<storage::EdgeTypeId> &edge_types, const VertexAccessor &dest)
-  //  const
-  //      -> storage::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::View view, const std::vector<storage::EdgeTypeId> &edge_types) const
-  //      -> storage::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::View view) const { return OutEdges(view, {}); }
-  //
-  //  auto OutEdges(storage::View view, const std::vector<storage::EdgeTypeId> &edge_types,
-  //                const VertexAccessor &dest) const
-  //      -> storage::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::Result<size_t> InDegree(storage::View view) const { return impl_.InDegree(view); }
-  //
-  //  storage::Result<size_t> OutDegree(storage::View view) const { return impl_.OutDegree(view); }
-  //
-
-  friend bool operator==(const VertexAccessor &lhs, const VertexAccessor &rhs) {
-    return lhs.vertex == rhs.vertex && lhs.properties == rhs.properties;
-  }
-
-  friend bool operator!=(const VertexAccessor &lhs, const VertexAccessor &rhs) { return !(lhs == rhs); }
-
- private:
-  Vertex vertex;
-  std::vector<std::pair<PropertyId, Value>> properties;
-};
-
-// inline VertexAccessor EdgeAccessor::To() const { return VertexAccessor(impl_.ToVertex()); }
-
-// inline VertexAccessor EdgeAccessor::From() const { return VertexAccessor(impl_.FromVertex()); }
-
-// Highly mocked interface. Won't work if used.
-class Path {
- public:
-  // Empty for now
-  explicit Path(const VertexAccessor & /*vertex*/, utils::MemoryResource *memory = utils::NewDeleteResource())
-      : mem(memory) {}
-
-  template <typename... TOthers>
-  explicit Path(const VertexAccessor &vertex, const TOthers &...others) {}
-
-  template <typename... TOthers>
-  Path(std::allocator_arg_t /*unused*/, utils::MemoryResource *memory, const VertexAccessor &vertex,
-       const TOthers &...others) {}
-
-  Path(const Path & /*other*/) {}
-
-  Path(const Path & /*other*/, utils::MemoryResource *memory) : mem(memory) {}
-
-  Path(Path && /*other*/) noexcept {}
-
-  Path(Path && /*other*/, utils::MemoryResource *memory) : mem(memory) {}
-  Path &operator=(const Path &path) {
-    if (this == &path) {
-      return *this;
-    }
-    return *this;
-  }
-
-  Path &operator=(Path &&path) noexcept {
-    if (this == &path) {
-      return *this;
-    }
-    return *this;
-  }
-
-  ~Path() {}
-
-  friend bool operator==(const Path & /*lhs*/, const Path & /*rhs*/) { return true; };
-  utils::MemoryResource *GetMemoryResource() { return mem; }
-
- private:
-  utils::MemoryResource *mem = utils::NewDeleteResource();
-};
-}  // namespace memgraph::query::v2::accessors

src/query/v2/bindings/bindings.hpp

@@ -1,15 +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
-
-#define MG_AST_INCLUDE_PATH "query/v2/frontend/ast/ast.hpp"  // NOLINT(cppcoreguidelines-macro-usage)
-#define MG_INJECTED_NAMESPACE_NAME memgraph::query::v2       // NOLINT(cppcoreguidelines-macro-usage)

src/query/v2/bindings/cypher_main_visitor.hpp

@@ -1,20 +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 "query/v2/bindings/bindings.hpp"
-
-#include "expr/ast/cypher_main_visitor.hpp"
-
-namespace memgraph::query::v2 {
-using CypherMainVisitor = memgraph::expr::CypherMainVisitor;
-}  // namespace memgraph::query::v2

src/query/v2/bindings/eval.hpp

@@ -1,44 +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 "query/v2/bindings/bindings.hpp"
-
-#include "expr/interpret/eval.hpp"
-#include "query/v2/bindings/typed_value.hpp"
-#include "query/v2/context.hpp"
-#include "query/v2/conversions.hpp"
-#include "query/v2/db_accessor.hpp"
-#include "query/v2/requests.hpp"
-#include "storage/v3/conversions.hpp"
-#include "storage/v3/property_value.hpp"
-#include "storage/v3/view.hpp"
-
-namespace memgraph::query::v2 {
-
-inline const auto lam = [](const auto &val) { return ValueToTypedValue(val); };
-namespace detail {
-class Callable {
- public:
-  auto operator()(const memgraph::storage::v3::PropertyValue &val) const {
-    return memgraph::storage::v3::PropertyToTypedValue<TypedValue>(val);
-  };
-  auto operator()(const msgs::Value &val) const { return ValueToTypedValue(val); };
-};
-
-}  // namespace detail
-using ExpressionEvaluator =
-    memgraph::expr::ExpressionEvaluator<TypedValue, memgraph::query::v2::EvaluationContext, DbAccessor,
-                                        storage::v3::View, storage::v3::LabelId, msgs::Value, detail::Callable,
-                                        memgraph::storage::v3::Error, memgraph::expr::QueryEngineTag>;
-
-}  // namespace memgraph::query::v2

src/query/v2/bindings/frame.hpp

@@ -1,21 +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 "query/v2/bindings/bindings.hpp"
-
-#include "query/v2/bindings/typed_value.hpp"
-#include "expr/interpret/frame.hpp"
-
-namespace memgraph::query::v2 {
-using Frame = memgraph::expr::Frame<TypedValue>;
-} // namespace memgraph::query::v2

src/query/v2/bindings/symbol.hpp

@@ -1,20 +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 "query/v2/bindings/bindings.hpp"
-
-#include "expr/semantic/symbol.hpp"
-
-namespace memgraph::query::v2 {
-using Symbol = memgraph::expr::Symbol;
-} // namespace memgraph::query::v2

src/query/v2/bindings/symbol_generator.hpp

@@ -1,16 +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 "query/v2/bindings/bindings.hpp"
-
-#include "expr/semantic/symbol_generator.hpp"

src/query/v2/bindings/symbol_table.hpp

@@ -1,20 +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 "query/v2/bindings/bindings.hpp"
-
-#include "expr/semantic/symbol_table.hpp"
-
-namespace memgraph::query::v2 {
-using SymbolTable = memgraph::expr::SymbolTable;
-} // namespace memgraph::query::v2

src/query/v2/bindings/typed_value.cpp

@@ -1,19 +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 "expr/typed_value.hpp"
-#include "query/v2/accessors.hpp"
-#include "query/v2/path.hpp"
-
-namespace memgraph::expr {
-namespace v2 = memgraph::query::v2;
-template class TypedValueT<v2::accessors::VertexAccessor, v2::accessors::EdgeAccessor, v2::accessors::Path>;
-}  // namespace memgraph::expr

src/query/v2/bindings/typed_value.hpp

@@ -1,27 +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 "query/v2/bindings/bindings.hpp"
-
-#include "expr/typed_value.hpp"
-#include "query/v2/accessors.hpp"
-
-namespace memgraph::expr {
-namespace v2 = memgraph::query::v2;
-extern template class memgraph::expr::TypedValueT<v2::accessors::VertexAccessor, v2::accessors::EdgeAccessor,
-                                                  v2::accessors::Path>;
-}  // namespace memgraph::expr
-namespace memgraph::query::v2 {
-using TypedValue =
-    memgraph::expr::TypedValueT<v2::accessors::VertexAccessor, v2::accessors::EdgeAccessor, v2::accessors::Path>;
-}  // namespace memgraph::query::v2

src/query/v2/common.hpp

@@ -18,13 +18,11 @@
 #include <string_view>
 #include <type_traits>
 
-#include "query/v2/bindings/symbol.hpp"
-#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/db_accessor.hpp"
 #include "query/v2/exceptions.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/path.hpp"
-#include "storage/v3/conversions.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"
@@ -88,18 +86,6 @@ concept AccessorWithSetProperty = requires(T accessor, const storage::v3::Proper
   { accessor.SetProperty(key, new_value) } -> std::same_as<storage::v3::Result<storage::v3::PropertyValue>>;
 };
 
-template <typename T>
-concept AccessorWithSetPropertyAndValidate = requires(T accessor, const storage::v3::PropertyId key,
-                                                      const storage::v3::PropertyValue new_value) {
-  {
-    accessor.SetPropertyAndValidate(key, new_value)
-    } -> std::same_as<storage::v3::ResultSchema<storage::v3::PropertyValue>>;
-};
-
-template <typename TRecordAccessor>
-concept RecordAccessor =
-    AccessorWithSetProperty<TRecordAccessor> || AccessorWithSetPropertyAndValidate<TRecordAccessor>;
-
 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: {
@@ -123,14 +109,13 @@ inline void HandleSchemaViolation(const storage::v3::SchemaViolation &schema_vio
                                                  *schema_violation.violated_property_value,
                                                  dba.LabelToName(schema_violation.label)));
     }
-    case storage::v3::SchemaViolation::ValidationStatus::VERTEX_UPDATE_PRIMARY_LABEL: {
-      throw SchemaViolationException(fmt::format(
-          "Adding primary label as secondary or removing primary label:", *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 where primary label is secondary:{}",
-                                                 dba.LabelToName(schema_violation.label)));
+      throw SchemaViolationException(
+          fmt::format("Cannot create vertex with secondary label :{}", dba.LabelToName(schema_violation.label)));
     }
   }
 }
@@ -152,12 +137,12 @@ inline void HandleErrorOnPropertyUpdate(const storage::v3::Error error) {
 /// Set a property `value` mapped with given `key` on a `record`.
 ///
 /// @throw QueryRuntimeException if value cannot be set as a property value
-template <RecordAccessor T>
+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::TypedToPropertyValue(value));
+      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) {
@@ -168,13 +153,13 @@ storage::v3::PropertyValue PropsSetChecked(T *record, const DbAccessor &dba, con
       return std::move(*maybe_old_value);
     } else {
       // No validation on edge properties
-      const auto maybe_old_value = record->SetProperty(key, storage::v3::TypedToPropertyValue(value));
+      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 expr::TypedValueException &) {
+  } catch (const TypedValueException &) {
     throw QueryRuntimeException("'{}' cannot be used as a property value.", value.type());
   }
 }

src/query/v2/context.hpp

@@ -13,13 +13,12 @@
 
 #include <type_traits>
 
-#include "query/v2/bindings/symbol_table.hpp"
 #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 "query/v2/shard_request_manager.hpp"
+#include "query/v2/trigger.hpp"
 #include "utils/async_timer.hpp"
 
 namespace memgraph::query::v2 {
@@ -71,9 +70,8 @@ struct ExecutionContext {
   plan::ProfilingStats stats;
   plan::ProfilingStats *stats_root{nullptr};
   ExecutionStats execution_stats;
-  //  TriggerContextCollector *trigger_context_collector{nullptr};
+  TriggerContextCollector *trigger_context_collector{nullptr};
   utils::AsyncTimer timer;
-  std::unique_ptr<msgs::ShardRequestManagerInterface> shard_request_manager{nullptr};
 };
 
 static_assert(std::is_move_assignable_v<ExecutionContext>, "ExecutionContext must be move assignable!");

src/query/v2/conversions.hpp

@@ -1,100 +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 "bindings/typed_value.hpp"
-#include "query/v2/accessors.hpp"
-#include "query/v2/requests.hpp"
-
-namespace memgraph::query::v2 {
-
-inline TypedValue ValueToTypedValue(const msgs::Value &value) {
-  using Value = msgs::Value;
-  switch (value.type) {
-    case Value::Type::Null:
-      return {};
-    case Value::Type::Bool:
-      return TypedValue(value.bool_v);
-    case Value::Type::Int64:
-      return TypedValue(value.int_v);
-    case Value::Type::Double:
-      return TypedValue(value.double_v);
-    case Value::Type::String:
-      return TypedValue(value.string_v);
-    case Value::Type::List: {
-      const auto &lst = value.list_v;
-      std::vector<TypedValue> dst;
-      dst.reserve(lst.size());
-      for (const auto &elem : lst) {
-        dst.push_back(ValueToTypedValue(elem));
-      }
-      return TypedValue(std::move(dst));
-    }
-    case Value::Type::Map: {
-      const auto &value_map = value.map_v;
-      std::map<std::string, TypedValue> dst;
-      for (const auto &[key, val] : value_map) {
-        dst[key] = ValueToTypedValue(val);
-      }
-      return TypedValue(std::move(dst));
-    }
-    case Value::Type::Vertex:
-      return TypedValue(accessors::VertexAccessor(value.vertex_v, {}));
-    case Value::Type::Edge:
-      return TypedValue(accessors::EdgeAccessor(value.edge_v, {}));
-    case Value::Type::Path:
-      break;
-  }
-  throw std::runtime_error("Incorrect type in conversion");
-}
-
-inline msgs::Value TypedValueToValue(const TypedValue &value) {
-  using Value = msgs::Value;
-  switch (value.type()) {
-    case TypedValue::Type::Null:
-      return {};
-    case TypedValue::Type::Bool:
-      return Value(value.ValueBool());
-    case TypedValue::Type::Int:
-      return Value(value.ValueInt());
-    case TypedValue::Type::Double:
-      return Value(value.ValueDouble());
-    case TypedValue::Type::String:
-      return Value(std::string(value.ValueString()));
-    case TypedValue::Type::List: {
-      const auto &lst = value.ValueList();
-      std::vector<Value> dst;
-      dst.reserve(lst.size());
-      for (const auto &elem : lst) {
-        dst.push_back(TypedValueToValue(elem));
-      }
-      return Value(std::move(dst));
-    }
-    case TypedValue::Type::Map: {
-      const auto &value_map = value.ValueMap();
-      std::map<std::string, Value> dst;
-      for (const auto &[key, val] : value_map) {
-        dst[std::string(key)] = TypedValueToValue(val);
-      }
-      return Value(std::move(dst));
-    }
-    case TypedValue::Type::Vertex:
-      return Value(value.ValueVertex().GetVertex());
-    case TypedValue::Type::Edge:
-      return Value(value.ValueEdge().GetEdge());
-    case TypedValue::Type::Path:
-    default:
-      break;
-  }
-  throw std::runtime_error("Incorrect type in conversion");
-}
-
-}  // namespace memgraph::query::v2

src/query/v2/cypher_query_interpreter.cpp

@@ -10,7 +10,6 @@
 // licenses/APL.txt.
 
 #include "query/v2/cypher_query_interpreter.hpp"
-#include "query/v2/bindings/symbol_generator.hpp"
 
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_HIDDEN_bool(query_cost_planner, true, "Use the cost-estimating query planner.");
@@ -47,7 +46,7 @@ ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::stri
   auto hash = stripped_query.hash();
   auto accessor = cache->access();
   auto it = accessor.find(hash);
-  std::unique_ptr<memgraph::frontend::opencypher::Parser<>> parser;
+  std::unique_ptr<frontend::opencypher::Parser> parser;
 
   // Return a copy of both the AST storage and the query.
   CachedQuery result;
@@ -64,11 +63,11 @@ ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::stri
 
   if (it == accessor.end()) {
     try {
-      parser = std::make_unique<memgraph::frontend::opencypher::Parser<>>(stripped_query.query());
+      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<memgraph::frontend::opencypher::Parser<>>(query_string);
+      parser = std::make_unique<frontend::opencypher::Parser>(query_string);
 
       // If an exception was not thrown here, the stripper messed something
       // up.
@@ -77,8 +76,8 @@ ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::stri
 
     // Convert the ANTLR4 parse tree into an AST.
     AstStorage ast_storage;
-    expr::ParsingContext context{true};
-    memgraph::expr::CypherMainVisitor visitor(context, &ast_storage);
+    frontend::ParsingContext context{true};
+    frontend::CypherMainVisitor visitor(context, &ast_storage);
 
     visitor.visit(parser->tree());
 
@@ -120,7 +119,7 @@ std::unique_ptr<LogicalPlan> MakeLogicalPlan(AstStorage ast_storage, CypherQuery
                                              DbAccessor *db_accessor,
                                              const std::vector<Identifier *> &predefined_identifiers) {
   auto vertex_counts = plan::MakeVertexCountCache(db_accessor);
-  auto symbol_table = expr::MakeSymbolTable(query, predefined_identifiers);
+  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),

src/query/v2/cypher_query_interpreter.hpp

@@ -11,11 +11,11 @@
 
 #pragma once
 
-#include "parser/opencypher/parser.hpp"
-#include "query/v2/bindings/cypher_main_visitor.hpp"
-#include "query/v2/bindings/symbol_table.hpp"
 #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"

src/query/v2/db_accessor.hpp

@@ -11,7 +11,6 @@
 
 #pragma once
 
-#include <cstdint>
 #include <optional>
 #include <vector>
 
@@ -20,7 +19,6 @@
 
 #include "query/v2/exceptions.hpp"
 #include "storage/v3/id_types.hpp"
-#include "storage/v3/key_store.hpp"
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/result.hpp"
 
@@ -111,17 +109,13 @@ class VertexAccessor final {
 
   auto PrimaryLabel(storage::v3::View view) const { return impl_.PrimaryLabel(view); }
 
-  auto PrimaryKey(storage::v3::View view) const { return impl_.PrimaryKey(view); }
-
-  storage::v3::ResultSchema<bool> AddLabel(storage::v3::LabelId label) { return impl_.AddLabelAndValidate(label); }
+  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::ResultSchema<bool> RemoveLabel(storage::v3::LabelId label) {
-    return impl_.RemoveLabelAndValidate(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);
@@ -138,9 +132,9 @@ class VertexAccessor final {
     return impl_.GetProperty(key, view);
   }
 
-  storage::v3::ResultSchema<storage::v3::PropertyValue> SetProperty(storage::v3::PropertyId key,
-                                                                    const storage::v3::PropertyValue &value) {
-    return impl_.SetPropertyAndValidate(key, value);
+  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(
@@ -168,8 +162,7 @@ class VertexAccessor final {
   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)))> {
-    const auto dest_id = dest.impl_.Id(view).GetValue();
-    auto maybe_edges = impl_.InEdges(view, edge_types, &dest_id);
+    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));
   }
@@ -186,8 +179,7 @@ class VertexAccessor final {
   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)))> {
-    const auto dest_id = dest.impl_.Id(view).GetValue();
-    auto maybe_edges = impl_.OutEdges(view, edge_types, &dest_id);
+    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));
   }
@@ -196,8 +188,9 @@ class VertexAccessor final {
 
   storage::v3::Result<size_t> OutDegree(storage::v3::View view) const { return impl_.OutDegree(view); }
 
-  // TODO(jbajic) Fix Remove Gid
-  static int64_t CypherId() { return 1; }
+  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_));
@@ -207,19 +200,14 @@ class VertexAccessor final {
   bool operator!=(const VertexAccessor &v) const noexcept { return !(*this == v); }
 };
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wnull-dereference"
-// NOLINTNEXTLINE(readability-convert-member-functions-to-static,clang-analyzer-core.NonNullParamChecker)
-inline VertexAccessor EdgeAccessor::To() const { return *static_cast<VertexAccessor *>(nullptr); }
+inline VertexAccessor EdgeAccessor::To() const { return VertexAccessor(impl_.ToVertex()); }
 
-// NOLINTNEXTLINE(readability-convert-member-functions-to-static,clang-analyzer-core.NonNullParamChecker)
-inline VertexAccessor EdgeAccessor::From() const { return *static_cast<VertexAccessor *>(nullptr); }
-#pragma clang diagnostic pop
+inline VertexAccessor EdgeAccessor::From() const { return VertexAccessor(impl_.FromVertex()); }
 
 inline bool EdgeAccessor::IsCycle() const { return To() == From(); }
 
 class DbAccessor final {
-  storage::v3::Shard::Accessor *accessor_;
+  storage::v3::Storage::Accessor *accessor_;
 
   class VerticesIterable final {
     storage::v3::VerticesIterable iterable_;
@@ -251,18 +239,16 @@ class DbAccessor final {
   };
 
  public:
-  explicit DbAccessor(storage::v3::Shard::Accessor *accessor) : accessor_(accessor) {}
+  explicit DbAccessor(storage::v3::Storage::Accessor *accessor) : accessor_(accessor) {}
 
-  // TODO(jbajic) Fix Remove Gid
-  // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
-  std::optional<VertexAccessor> FindVertex(uint64_t /*unused*/) { return std::nullopt; }
-
-  std::optional<VertexAccessor> FindVertex(storage::v3::PrimaryKey &primary_key, storage::v3::View view) {
-    auto maybe_vertex = accessor_->FindVertex(primary_key, view);
+  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) {
@@ -284,6 +270,9 @@ class DbAccessor final {
     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) {
@@ -296,15 +285,13 @@ class DbAccessor final {
 
   storage::v3::Result<EdgeAccessor> InsertEdge(VertexAccessor *from, VertexAccessor *to,
                                                const storage::v3::EdgeTypeId &edge_type) {
-    static constexpr auto kDummyGid = storage::v3::Gid::FromUint(0);
-    auto maybe_edge = accessor_->CreateEdge(from->impl_.Id(storage::v3::View::NEW).GetValue(),
-                                            to->impl_.Id(storage::v3::View::NEW).GetValue(), edge_type, kDummyGid);
+    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_.FromVertex(), edge->impl_.ToVertex(), edge->impl_.Gid());
+    auto res = accessor_->DeleteEdge(&edge->impl_);
     if (res.HasError()) {
       return res.GetError();
     }
@@ -355,15 +342,10 @@ class DbAccessor final {
     return {std::make_optional<VertexAccessor>(*value)};
   }
 
-  // TODO(jbajic) Query engine should have a map of labels, properties and edge
-  // types
-  // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
   storage::v3::PropertyId NameToProperty(const std::string_view name) { return accessor_->NameToProperty(name); }
 
-  // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
   storage::v3::LabelId NameToLabel(const std::string_view name) { return accessor_->NameToLabel(name); }
 
-  // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
   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); }
@@ -374,7 +356,7 @@ class DbAccessor final {
 
   void AdvanceCommand() { accessor_->AdvanceCommand(); }
 
-  void Commit() { return accessor_->Commit(coordinator::Hlc{}); }
+  utils::BasicResult<storage::v3::ConstraintViolation, void> Commit() { return accessor_->Commit(); }
 
   void Abort() { accessor_->Abort(); }
 
@@ -405,6 +387,8 @@ class DbAccessor final {
 
   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(); }

src/query/v2/discard_value_stream.hpp

@@ -13,7 +13,7 @@
 
 #include <vector>
 
-#include "query/v2/bindings/typed_value.hpp"
+#include "query/v2/typed_value.hpp"
 
 namespace memgraph::query::v2 {
 struct DiscardValueResultStream final {

src/query/v2/dump.cpp

@@ -21,10 +21,10 @@
 
 #include <fmt/format.h>
 
-#include "query/v2/bindings/typed_value.hpp"
 #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"
@@ -269,6 +269,10 @@ PullPlanDump::PullPlanDump(DbAccessor *dba)
                    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
@@ -360,6 +364,60 @@ PullPlanDump::PullChunk PullPlanDump::CreateLabelPropertyIndicesPullChunk() {
   };
 }
 
+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()) {

src/query/v2/dump.hpp

@@ -32,6 +32,7 @@ struct PullPlanDump {
   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());
@@ -54,6 +55,8 @@ struct PullPlanDump {
 
   PullChunk CreateLabelIndicesPullChunk();
   PullChunk CreateLabelPropertyIndicesPullChunk();
+  PullChunk CreateExistenceConstraintsPullChunk();
+  PullChunk CreateUniqueConstraintsPullChunk();
   PullChunk CreateInternalIndexPullChunk();
   PullChunk CreateVertexPullChunk();
   PullChunk CreateEdgePullChunk();

src/query/v2/frontend/ast/ast.lcp

@@ -17,12 +17,11 @@
 #include <variant>
 #include <vector>
 
-#include "query/v2/bindings/ast_visitor.hpp"
-#include "query/v2/bindings/symbol.hpp"
+#include "query/v2/frontend/ast/ast_visitor.hpp"
+#include "query/v2/frontend/semantic/symbol.hpp"
 #include "query/v2/interpret/awesome_memgraph_functions.hpp"
-#include "query/v2/bindings/typed_value.hpp"
-#include "query/v2/db_accessor.hpp"
-#include "query/v2/path.hpp"
+#include "query/v2/typed_value.hpp"
+#include "storage/v3/property_value.hpp"
 #include "utils/typeinfo.hpp"
 
 cpp<#
@@ -631,7 +630,7 @@ cpp<#
   (:clone))
 
 (lcp:define-class primitive-literal (base-literal)
-  ((value "TypedValue" :scope :public)
+  ((value "::storage::v3::PropertyValue" :scope :public)
    (token-position :int32_t :scope :public :initval -1
                    :documentation "This field contains token position of literal used to create PrimitiveLiteral object. If PrimitiveLiteral object is not created from query, leave its value at -1."))
   (:public

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

@@ -13,7 +13,7 @@
 
 #include "utils/visitor.hpp"
 
-namespace MG_INJECTED_NAMESPACE_NAME {
+namespace memgraph::query::v2 {
 
 // Forward declares for Tree visitors.
 class CypherQuery;
@@ -96,7 +96,7 @@ class VersionQuery;
 class Foreach;
 class SchemaQuery;
 
-using TreeCompositeVisitor = memgraph::utils::CompositeVisitor<
+using TreeCompositeVisitor = utils::CompositeVisitor<
     SingleQuery, CypherUnion, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator, AdditionOperator,
     SubtractionOperator, MultiplicationOperator, DivisionOperator, ModOperator, NotEqualOperator, EqualOperator,
     LessOperator, GreaterOperator, LessEqualOperator, GreaterEqualOperator, InListOperator, SubscriptOperator,
@@ -105,7 +105,7 @@ using TreeCompositeVisitor = memgraph::utils::CompositeVisitor<
     Create, Match, Return, With, Pattern, NodeAtom, EdgeAtom, Delete, Where, SetProperty, SetProperties, SetLabels,
     RemoveProperty, RemoveLabels, Merge, Unwind, RegexMatch, LoadCsv, Foreach>;
 
-using TreeLeafVisitor = memgraph::utils::LeafVisitor<Identifier, PrimitiveLiteral, ParameterLookup>;
+using TreeLeafVisitor = utils::LeafVisitor<Identifier, PrimitiveLiteral, ParameterLookup>;
 
 class HierarchicalTreeVisitor : public TreeCompositeVisitor, public TreeLeafVisitor {
  public:
@@ -117,7 +117,7 @@ class HierarchicalTreeVisitor : public TreeCompositeVisitor, public TreeLeafVisi
 
 template <class TResult>
 class ExpressionVisitor
-    : public memgraph::utils::Visitor<
+    : public utils::Visitor<
           TResult, NamedExpression, OrOperator, XorOperator, AndOperator, NotOperator, AdditionOperator,
           SubtractionOperator, MultiplicationOperator, DivisionOperator, ModOperator, NotEqualOperator, EqualOperator,
           LessOperator, GreaterOperator, LessEqualOperator, GreaterEqualOperator, InListOperator, SubscriptOperator,
@@ -126,10 +126,9 @@ class ExpressionVisitor
           None, ParameterLookup, Identifier, PrimitiveLiteral, RegexMatch> {};
 
 template <class TResult>
-class QueryVisitor
-    : public memgraph::utils::Visitor<TResult, CypherQuery, ExplainQuery, ProfileQuery, IndexQuery, AuthQuery,
-                                      InfoQuery, ConstraintQuery, DumpQuery, ReplicationQuery, LockPathQuery,
-                                      FreeMemoryQuery, TriggerQuery, IsolationLevelQuery, CreateSnapshotQuery,
-                                      StreamQuery, SettingQuery, VersionQuery, SchemaQuery> {};
+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 MG_INJECTED_NAMESPACE_NAME
+}  // 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

@@ -11,9 +11,13 @@
 
 #pragma once
 
-#include "query/v2/bindings/bindings.hpp"
+#include <iostream>
 
-#include "expr/ast/pretty_print.hpp"
+#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/CypherLexer.g4

@@ -1,6 +1,6 @@
 /*
  * When changing this grammar make sure to update constants in
- * src/parser/stripped_lexer_constants.hpp (kKeywords, kSpecialTokens
+ * src/query/frontend/stripped_lexer_constants.hpp (kKeywords, kSpecialTokens
  * and bitsets) if needed.
  */
 

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

@@ -15,7 +15,7 @@
 
 /*
  * When changing this grammar make sure to update constants in
- * src/parser/stripped_lexer_constants.hpp (kKeywords, kSpecialTokens
+ * src/query/frontend/stripped_lexer_constants.hpp (kKeywords, kSpecialTokens
  * and bitsets) if needed.
  */
 

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

@@ -14,29 +14,17 @@
 #include <string>
 
 #include "antlr4-runtime.h"
-#include "utils/exceptions.hpp"
-#include "parser/opencypher/generated/MemgraphCypher.h"
-#include "parser/opencypher/generated/MemgraphCypherLexer.h"
-#include "utils/concepts.hpp"
+#include "query/v2/exceptions.hpp"
+#include "query/v2/frontend/opencypher/generated/MemgraphCypher.h"
+#include "query/v2/frontend/opencypher/generated/MemgraphCypherLexer.h"
 
-namespace memgraph::frontend::opencypher {
-
-class SyntaxException : public utils::BasicException {
- public:
-  using utils::BasicException::BasicException;
-  SyntaxException() : SyntaxException("") {}
-};
+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.
  */
-enum class ParserOpTag : uint8_t {
-  CYPHER, EXPRESSION
-};
-
-template<ParserOpTag Tag = ParserOpTag::CYPHER>
 class Parser {
  public:
   /**
@@ -46,14 +34,9 @@ class Parser {
   Parser(const std::string query) : query_(std::move(query)) {
     parser_.removeErrorListeners();
     parser_.addErrorListener(&error_listener_);
-    if constexpr(Tag == ParserOpTag::CYPHER) {
-      tree_ = parser_.cypher();
-    }
-    else {
-      tree_ = parser_.expression();
-    }
+    tree_ = parser_.cypher();
     if (parser_.getNumberOfSyntaxErrors()) {
-      throw SyntaxException(error_listener_.error_);
+      throw query::v2::SyntaxException(error_listener_.error_);
     }
   }
 
@@ -82,4 +65,4 @@ class Parser {
   antlropencypher::MemgraphCypher parser_{&tokens_};
   antlr4::tree::ParseTree *tree_ = nullptr;
 };
-}  // namespace memgraph::frontend::opencypher
+}  // namespace memgraph::query::v2::frontend::opencypher

src/query/v2/frontend/parsing.cpp

@@ -9,18 +9,18 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
 
-#include "expr/parsing.hpp"
+#include "query/v2/frontend/parsing.hpp"
 
 #include <cctype>
 #include <codecvt>
 #include <locale>
 #include <stdexcept>
 
-#include "expr/exceptions.hpp"
+#include "query/v2/exceptions.hpp"
 #include "utils/logging.hpp"
 #include "utils/string.hpp"
 
-namespace memgraph::expr {
+namespace memgraph::query::v2::frontend {
 
 int64_t ParseIntegerLiteral(const std::string &s) {
   try {
@@ -181,4 +181,4 @@ std::string ParseParameter(const std::string &s) {
   return out;
 }
 
-}  // namespace memgraph::expr
+}  // namespace memgraph::query::v2::frontend

src/query/v2/frontend/parsing.hpp

@@ -15,7 +15,7 @@
 #include <cstdint>
 #include <string>
 
-namespace memgraph::expr {
+namespace memgraph::query::v2::frontend {
 
 // These are the functions for parsing literals and parameter names from
 // opencypher query.
@@ -24,4 +24,4 @@ std::string ParseStringLiteral(const std::string &s);
 double ParseDoubleLiteral(const std::string &s);
 std::string ParseParameter(const std::string &s);
 
-}  // namespace memgraph::expr
+}  // namespace memgraph::query::v2::frontend

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

@@ -9,8 +9,9 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
 
-#include "query/v2/bindings/ast_visitor.hpp"
 #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 {
@@ -85,7 +86,12 @@ class PrivilegeExtractor : public QueryVisitor<void>, public HierarchicalTreeVis
     AddPrivilege(AuthQuery::Privilege::CREATE);
     return false;
   }
-  bool PreVisit(CallProcedure & /*procedure*/) override {
+  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 {

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

@@ -18,7 +18,8 @@
 cpp<#
 
 (lcp:namespace memgraph)
-(lcp:namespace expr)
+(lcp:namespace query)
+(lcp:namespace v2)
 
 (lcp:define-class symbol ()
   ((name "std::string" :scope :public)
@@ -65,15 +66,16 @@ cpp<#
     cpp<#)
   (:serialize (:slk)))
 
-(lcp:pop-namespace) ;; expr
+(lcp:pop-namespace) ;; v2
+(lcp:pop-namespace) ;; query
 (lcp:pop-namespace) ;; memgraph
 
 #>cpp
 namespace std {
 
 template <>
-struct hash<memgraph::expr::Symbol> {
-  size_t operator()(const memgraph::expr::Symbol &symbol) const {
+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());

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

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

@@ -0,0 +1,176 @@
+// 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 11-03-2017
+
+#pragma once
+
+#include <optional>
+#include <vector>
+
+#include "query/v2/exceptions.hpp"
+#include "query/v2/frontend/ast/ast.hpp"
+#include "query/v2/frontend/semantic/symbol_table.hpp"
+
+namespace memgraph::query::v2 {
+
+/// Visits the AST and generates symbols for variables.
+///
+/// During the process of symbol generation, simple semantic checks are
+/// performed. Such as, redeclaring a variable or conflicting expectations of
+/// variable types.
+class SymbolGenerator : public HierarchicalTreeVisitor {
+ public:
+  explicit SymbolGenerator(SymbolTable *symbol_table, const std::vector<Identifier *> &predefined_identifiers);
+
+  using HierarchicalTreeVisitor::PostVisit;
+  using HierarchicalTreeVisitor::PreVisit;
+  using HierarchicalTreeVisitor::Visit;
+  using typename HierarchicalTreeVisitor::ReturnType;
+
+  // Query
+  bool PreVisit(SingleQuery &) override;
+
+  // Union
+  bool PreVisit(CypherUnion &) override;
+  bool PostVisit(CypherUnion &) override;
+
+  // Clauses
+  bool PreVisit(Create &) override;
+  bool PostVisit(Create &) override;
+  bool PreVisit(CallProcedure &) override;
+  bool PostVisit(CallProcedure &) override;
+  bool PreVisit(LoadCsv &) override;
+  bool PostVisit(LoadCsv &) override;
+  bool PreVisit(Return &) override;
+  bool PostVisit(Return &) override;
+  bool PreVisit(With &) override;
+  bool PreVisit(Where &) override;
+  bool PostVisit(Where &) override;
+  bool PreVisit(Merge &) override;
+  bool PostVisit(Merge &) override;
+  bool PostVisit(Unwind &) override;
+  bool PreVisit(Match &) override;
+  bool PostVisit(Match &) override;
+  bool PreVisit(Foreach &) override;
+  bool PostVisit(Foreach &) override;
+
+  // Expressions
+  ReturnType Visit(Identifier &) override;
+  ReturnType Visit(PrimitiveLiteral &) override { return true; }
+  ReturnType Visit(ParameterLookup &) override { return true; }
+  bool PreVisit(Aggregation &) override;
+  bool PostVisit(Aggregation &) override;
+  bool PreVisit(IfOperator &) override;
+  bool PostVisit(IfOperator &) override;
+  bool PreVisit(All &) override;
+  bool PreVisit(Single &) override;
+  bool PreVisit(Any &) override;
+  bool PreVisit(None &) override;
+  bool PreVisit(Reduce &) override;
+  bool PreVisit(Extract &) override;
+
+  // Pattern and its subparts.
+  bool PreVisit(Pattern &) override;
+  bool PostVisit(Pattern &) override;
+  bool PreVisit(NodeAtom &) override;
+  bool PostVisit(NodeAtom &) override;
+  bool PreVisit(EdgeAtom &) override;
+  bool PostVisit(EdgeAtom &) override;
+
+ private:
+  // Scope stores the state of where we are when visiting the AST and a map of
+  // names to symbols.
+  struct Scope {
+    bool in_pattern{false};
+    bool in_merge{false};
+    bool in_create{false};
+    // in_create_node is true if we are creating or merging *only* a node.
+    // Therefore, it is *not* equivalent to (in_create || in_merge) &&
+    // in_node_atom.
+    bool in_create_node{false};
+    // True if creating an edge;
+    // shortcut for (in_create || in_merge) && visiting_edge.
+    bool in_create_edge{false};
+    bool in_node_atom{false};
+    EdgeAtom *visiting_edge{nullptr};
+    bool in_aggregation{false};
+    bool in_return{false};
+    bool in_with{false};
+    bool in_skip{false};
+    bool in_limit{false};
+    bool in_order_by{false};
+    bool in_where{false};
+    bool in_match{false};
+    bool in_foreach{false};
+    // True when visiting a pattern atom (node or edge) identifier, which can be
+    // reused or created in the pattern itself.
+    bool in_pattern_atom_identifier{false};
+    // True when visiting range bounds of a variable path.
+    bool in_edge_range{false};
+    // True if the return/with contains an aggregation in any named expression.
+    bool has_aggregation{false};
+    // Map from variable names to symbols.
+    std::map<std::string, Symbol> symbols;
+    // Identifiers found in property maps of patterns or as variable length path
+    // bounds in a single Match clause. They need to be checked after visiting
+    // Match. Identifiers created by naming vertices, edges and paths are *not*
+    // stored in here.
+    std::vector<Identifier *> identifiers_in_match;
+    // Number of nested IfOperators.
+    int num_if_operators{0};
+  };
+
+  static std::optional<Symbol> FindSymbolInScope(const std::string &name, const Scope &scope, Symbol::Type type);
+
+  bool HasSymbol(const std::string &name) const;
+  bool HasSymbolLocalScope(const std::string &name) const;
+
+  // @return true if it added a predefined identifier with that name
+  bool ConsumePredefinedIdentifier(const std::string &name);
+
+  // Returns a freshly generated symbol. Previous mapping of the same name to a
+  // different symbol is replaced with the new one.
+  auto CreateSymbol(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY,
+                    int token_position = -1);
+
+  auto GetOrCreateSymbol(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY);
+  // Returns the symbol by name. If the mapping already exists, checks if the
+  // types match. Otherwise, returns a new symbol.
+  auto GetOrCreateSymbolLocalScope(const std::string &name, bool user_declared, Symbol::Type type = Symbol::Type::ANY);
+
+  void VisitReturnBody(ReturnBody &body, Where *where = nullptr);
+
+  void VisitWithIdentifiers(Expression *, const std::vector<Identifier *> &);
+
+  SymbolTable *symbol_table_;
+
+  // Identifiers which are injected from outside the query. Each identifier
+  // is mapped by its name.
+  std::unordered_map<std::string, Identifier *> predefined_identifiers_;
+  std::vector<Scope> scopes_;
+  std::unordered_set<std::string> prev_return_names_;
+  std::unordered_set<std::string> curr_return_names_;
+};
+
+inline SymbolTable MakeSymbolTable(CypherQuery *query, const std::vector<Identifier *> &predefined_identifiers = {}) {
+  SymbolTable symbol_table;
+  SymbolGenerator symbol_generator(&symbol_table, predefined_identifiers);
+  query->single_query_->Accept(symbol_generator);
+  for (auto *cypher_union : query->cypher_unions_) {
+    cypher_union->Accept(symbol_generator);
+  }
+  return symbol_table;
+}
+
+}  // namespace memgraph::query::v2

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

@@ -14,11 +14,11 @@
 #include <map>
 #include <string>
 
-#include "expr/ast.hpp"
-#include "expr/semantic/symbol.hpp"
+#include "query/v2/frontend/ast/ast.hpp"
+#include "query/v2/frontend/semantic/symbol.hpp"
 #include "utils/logging.hpp"
 
-namespace memgraph::expr {
+namespace memgraph::query::v2 {
 
 class SymbolTable final {
  public:
@@ -61,4 +61,4 @@ class SymbolTable final {
   std::map<int32_t, Symbol> table_;
 };
 
-}  // namespace memgraph::expr
+}  // namespace memgraph::query::v2

src/query/v2/frontend/stripped.cpp

@@ -18,19 +18,19 @@
 #include <string>
 #include <vector>
 
-#include "expr/parsing.hpp"
-#include "parser/opencypher/generated/MemgraphCypher.h"
-#include "parser/opencypher/generated/MemgraphCypherBaseVisitor.h"
-#include "parser/opencypher/generated/MemgraphCypherLexer.h"
-#include "parser/stripped_lexer_constants.hpp"
 #include "query/v2/exceptions.hpp"
+#include "query/v2/frontend/opencypher/generated/MemgraphCypher.h"
+#include "query/v2/frontend/opencypher/generated/MemgraphCypherBaseVisitor.h"
+#include "query/v2/frontend/opencypher/generated/MemgraphCypherLexer.h"
+#include "query/v2/frontend/parsing.hpp"
+#include "query/v2/frontend/stripped_lexer_constants.hpp"
 #include "utils/fnv.hpp"
 #include "utils/logging.hpp"
 #include "utils/string.hpp"
 
 namespace memgraph::query::v2::frontend {
 
-using namespace parser::lexer_constants;  // NOLINT(google-build-using-namespace)
+using namespace lexer_constants;
 
 StrippedQuery::StrippedQuery(const std::string &query) : original_(query) {
   enum class Token {
@@ -134,13 +134,13 @@ StrippedQuery::StrippedQuery(const std::string &query) : original_(query) {
       case Token::SPACE:
         break;
       case Token::STRING:
-        replace_stripped(token_index, expr::ParseStringLiteral(token.second), kStrippedStringToken);
+        replace_stripped(token_index, ParseStringLiteral(token.second), kStrippedStringToken);
         break;
       case Token::INT:
-        replace_stripped(token_index, expr::ParseIntegerLiteral(token.second), kStrippedIntToken);
+        replace_stripped(token_index, ParseIntegerLiteral(token.second), kStrippedIntToken);
         break;
       case Token::REAL:
-        replace_stripped(token_index, expr::ParseDoubleLiteral(token.second), kStrippedDoubleToken);
+        replace_stripped(token_index, ParseDoubleLiteral(token.second), kStrippedDoubleToken);
         break;
       case Token::SPECIAL:
       case Token::ESCAPED_NAME:
@@ -148,7 +148,7 @@ StrippedQuery::StrippedQuery(const std::string &query) : original_(query) {
         token_strings.push_back(token.second);
         break;
       case Token::PARAMETER:
-        parameters_[token_index] = expr::ParseParameter(token.second);
+        parameters_[token_index] = ParseParameter(token.second);
         token_strings.push_back(token.second);
         break;
     }
@@ -462,13 +462,13 @@ int StrippedQuery::MatchEscapedName(int start) const {
 int StrippedQuery::MatchUnescapedName(int start) const {
   auto i = start;
   auto got = GetFirstUtf8SymbolCodepoint(original_.data() + i);
-  if (got.first >= parser::lexer_constants::kBitsetSize || !kUnescapedNameAllowedStarts[got.first]) {
+  if (got.first >= lexer_constants::kBitsetSize || !kUnescapedNameAllowedStarts[got.first]) {
     return 0;
   }
   i += got.second;
   while (i < static_cast<int>(original_.size())) {
     got = GetFirstUtf8SymbolCodepoint(original_.data() + i);
-    if (got.first >= parser::lexer_constants::kBitsetSize || !kUnescapedNameAllowedParts[got.first]) {
+    if (got.first >= lexer_constants::kBitsetSize || !kUnescapedNameAllowedParts[got.first]) {
       break;
     }
     i += got.second;
@@ -487,7 +487,7 @@ int StrippedQuery::MatchWhitespaceAndComments(int start) const {
   while (i < len) {
     if (state == State::OUT) {
       auto got = GetFirstUtf8SymbolCodepoint(original_.data() + i);
-      if (got.first < parser::lexer_constants::kBitsetSize && kSpaceParts[got.first]) {
+      if (got.first < lexer_constants::kBitsetSize && kSpaceParts[got.first]) {
         i += got.second;
       } else if (i + 1 < len && original_[i] == '/' && original_[i + 1] == '*') {
         comment_position = i;

src/query/v2/frontend/stripped_lexer_constants.hpp

@@ -17,7 +17,7 @@
 #include <unordered_set>
 #include <vector>
 
-namespace parser {
+namespace memgraph::query::v2 {
 namespace lexer_constants {
 
 namespace trie {
@@ -2922,4 +2922,4 @@ const trie::Trie kSpecialTokens = {";",
                                    "\xEF\xB9\xA3",   // u8"\ufe63"
                                    "\xEF\xBC\x8D"};  // u8"\uff0d"
 }  // namespace lexer_constants
-}  // namespace parser
+}  // namespace memgraph::query::v2

src/query/v2/interpret/awesome_memgraph_functions.cpp

@@ -20,14 +20,12 @@
 #include <string_view>
 #include <type_traits>
 
-#include "query/v2/bindings/typed_value.hpp"
-#include "query/v2/conversions.hpp"
 #include "query/v2/db_accessor.hpp"
 #include "query/v2/exceptions.hpp"
 #include "query/v2/procedure/cypher_types.hpp"
-//#include "query/v2/procedure/mg_procedure_impl.hpp"
-//#include "query/v2/procedure/module.hpp"
-#include "storage/v3/conversions.hpp"
+#include "query/v2/procedure/mg_procedure_impl.hpp"
+#include "query/v2/procedure/module.hpp"
+#include "query/v2/typed_value.hpp"
 #include "utils/string.hpp"
 #include "utils/temporal.hpp"
 
@@ -388,7 +386,38 @@ TypedValue Last(const TypedValue *args, int64_t nargs, const FunctionContext &ct
   return TypedValue(list.back(), ctx.memory);
 }
 
-TypedValue Properties(const TypedValue * /*args*/, int64_t /*nargs*/, const FunctionContext & /*ctx*/) { return {}; }
+TypedValue Properties(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
+  FType<Or<Null, Vertex, Edge>>("properties", args, nargs);
+  auto *dba = ctx.db_accessor;
+  auto get_properties = [&](const auto &record_accessor) {
+    TypedValue::TMap properties(ctx.memory);
+    auto maybe_props = record_accessor.Properties(ctx.view);
+    if (maybe_props.HasError()) {
+      switch (maybe_props.GetError()) {
+        case storage::v3::Error::DELETED_OBJECT:
+          throw 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 object that doesn't exist.");
+        case storage::v3::Error::SERIALIZATION_ERROR:
+        case storage::v3::Error::VERTEX_HAS_EDGES:
+        case storage::v3::Error::PROPERTIES_DISABLED:
+          throw QueryRuntimeException("Unexpected error when getting properties.");
+      }
+    }
+    for (const auto &property : *maybe_props) {
+      properties.emplace(dba->PropertyToName(property.first), property.second);
+    }
+    return TypedValue(std::move(properties));
+  };
+  const auto &value = args[0];
+  if (value.IsNull()) {
+    return TypedValue(ctx.memory);
+  } else if (value.IsVertex()) {
+    return get_properties(value.ValueVertex());
+  } else {
+    return get_properties(value.ValueEdge());
+  }
+}
 
 TypedValue Size(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
   FType<Or<Null, List, String, Map, Path>>("size", args, nargs);
@@ -404,8 +433,7 @@ TypedValue Size(const TypedValue *args, int64_t nargs, const FunctionContext &ct
     // to do it.
     return TypedValue(static_cast<int64_t>(value.ValueMap().size()), ctx.memory);
   } else {
-    // TODO(kostasrim) Fix the dummy return
-    return TypedValue(int64_t(0), ctx.memory);
+    return TypedValue(static_cast<int64_t>(value.ValuePath().edges().size()), ctx.memory);
   }
 }
 
@@ -439,22 +467,25 @@ TypedValue Degree(const TypedValue *args, int64_t nargs, const FunctionContext &
   FType<Or<Null, Vertex>>("degree", args, nargs);
   if (args[0].IsNull()) return TypedValue(ctx.memory);
   const auto &vertex = args[0].ValueVertex();
-  // TODO(kostasrim) Fix dummy values
-  return TypedValue(int64_t(0), ctx.memory);
+  size_t out_degree = UnwrapDegreeResult(vertex.OutDegree(ctx.view));
+  size_t in_degree = UnwrapDegreeResult(vertex.InDegree(ctx.view));
+  return TypedValue(static_cast<int64_t>(out_degree + in_degree), ctx.memory);
 }
 
 TypedValue InDegree(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
   FType<Or<Null, Vertex>>("inDegree", args, nargs);
   if (args[0].IsNull()) return TypedValue(ctx.memory);
   const auto &vertex = args[0].ValueVertex();
-  return TypedValue(int64_t(0), ctx.memory);
+  size_t in_degree = UnwrapDegreeResult(vertex.InDegree(ctx.view));
+  return TypedValue(static_cast<int64_t>(in_degree), ctx.memory);
 }
 
 TypedValue OutDegree(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
   FType<Or<Null, Vertex>>("outDegree", args, nargs);
   if (args[0].IsNull()) return TypedValue(ctx.memory);
   const auto &vertex = args[0].ValueVertex();
-  return TypedValue(int64_t(0), ctx.memory);
+  size_t out_degree = UnwrapDegreeResult(vertex.OutDegree(ctx.view));
+  return TypedValue(static_cast<int64_t>(out_degree), ctx.memory);
 }
 
 TypedValue ToBoolean(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
@@ -520,7 +551,7 @@ TypedValue Type(const TypedValue *args, int64_t nargs, const FunctionContext &ct
   FType<Or<Null, Edge>>("type", args, nargs);
   auto *dba = ctx.db_accessor;
   if (args[0].IsNull()) return TypedValue(ctx.memory);
-  return TypedValue(static_cast<int64_t>(args[0].ValueEdge().EdgeType()), ctx.memory);
+  return TypedValue(dba->EdgeTypeToName(args[0].ValueEdge().EdgeType()), ctx.memory);
 }
 
 TypedValue ValueType(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
@@ -560,27 +591,81 @@ TypedValue ValueType(const TypedValue *args, int64_t nargs, const FunctionContex
 }
 
 // TODO: How is Keys different from Properties function?
-TypedValue Keys(const TypedValue *args, int64_t nargs, const FunctionContext & /*ctx*/) {
+TypedValue Keys(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
   FType<Or<Null, Vertex, Edge>>("keys", args, nargs);
-  return {};
+  auto *dba = ctx.db_accessor;
+  auto get_keys = [&](const auto &record_accessor) {
+    TypedValue::TVector keys(ctx.memory);
+    auto maybe_props = record_accessor.Properties(ctx.view);
+    if (maybe_props.HasError()) {
+      switch (maybe_props.GetError()) {
+        case storage::v3::Error::DELETED_OBJECT:
+          throw QueryRuntimeException("Trying to get keys from a deleted object.");
+        case storage::v3::Error::NONEXISTENT_OBJECT:
+          throw query::v2::QueryRuntimeException("Trying to get keys from an object that doesn't exist.");
+        case storage::v3::Error::SERIALIZATION_ERROR:
+        case storage::v3::Error::VERTEX_HAS_EDGES:
+        case storage::v3::Error::PROPERTIES_DISABLED:
+          throw QueryRuntimeException("Unexpected error when getting keys.");
+      }
+    }
+    for (const auto &property : *maybe_props) {
+      keys.emplace_back(dba->PropertyToName(property.first));
+    }
+    return TypedValue(std::move(keys));
+  };
+  const auto &value = args[0];
+  if (value.IsNull()) {
+    return TypedValue(ctx.memory);
+  } else if (value.IsVertex()) {
+    return get_keys(value.ValueVertex());
+  } else {
+    return get_keys(value.ValueEdge());
+  }
 }
 
 TypedValue Labels(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
   FType<Or<Null, Vertex>>("labels", args, nargs);
+  auto *dba = ctx.db_accessor;
   if (args[0].IsNull()) return TypedValue(ctx.memory);
-  return {};
+  TypedValue::TVector labels(ctx.memory);
+  auto maybe_labels = args[0].ValueVertex().Labels(ctx.view);
+  if (maybe_labels.HasError()) {
+    switch (maybe_labels.GetError()) {
+      case storage::v3::Error::DELETED_OBJECT:
+        throw 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 QueryRuntimeException("Unexpected error when getting labels.");
+    }
+  }
+  for (const auto &label : *maybe_labels) {
+    labels.emplace_back(dba->LabelToName(label));
+  }
+  return TypedValue(std::move(labels));
 }
 
 TypedValue Nodes(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
   FType<Or<Null, Path>>("nodes", args, nargs);
   if (args[0].IsNull()) return TypedValue(ctx.memory);
-  return {};
+  const auto &vertices = args[0].ValuePath().vertices();
+  TypedValue::TVector values(ctx.memory);
+  values.reserve(vertices.size());
+  for (const auto &v : vertices) values.emplace_back(v);
+  return TypedValue(std::move(values));
 }
 
 TypedValue Relationships(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
   FType<Or<Null, Path>>("relationships", args, nargs);
   if (args[0].IsNull()) return TypedValue(ctx.memory);
-  return {};
+  const auto &edges = args[0].ValuePath().edges();
+  TypedValue::TVector values(ctx.memory);
+  values.reserve(edges.size());
+  for (const auto &e : edges) values.emplace_back(e);
+  return TypedValue(std::move(values));
 }
 
 TypedValue Range(const TypedValue *args, int64_t nargs, const FunctionContext &ctx) {
@@ -790,9 +875,9 @@ TypedValue Id(const TypedValue *args, int64_t nargs, const FunctionContext &ctx)
   if (arg.IsNull()) {
     return TypedValue(ctx.memory);
   } else if (arg.IsVertex()) {
-    return TypedValue(int64_t(arg.ValueVertex().CypherId()), ctx.memory);
+    return TypedValue(arg.ValueVertex().CypherId(), ctx.memory);
   } else {
-    return TypedValue(int64_t(arg.ValueEdge().CypherId()), ctx.memory);
+    return TypedValue(arg.ValueEdge().CypherId(), ctx.memory);
   }
 }
 
@@ -1093,6 +1178,52 @@ TypedValue Duration(const TypedValue *args, int64_t nargs, const FunctionContext
   return TypedValue(utils::Duration(duration_parameters), ctx.memory);
 }
 
+std::function<TypedValue(const TypedValue *, const int64_t, const FunctionContext &)> UserFunction(
+    const mgp_func &func, const std::string &fully_qualified_name) {
+  return [func, fully_qualified_name](const TypedValue *args, int64_t nargs, const FunctionContext &ctx) -> TypedValue {
+    /// Find function is called to aquire the lock on Module pointer while user-defined function is executed
+    const auto &maybe_found =
+        procedure::FindFunction(procedure::gModuleRegistry, fully_qualified_name, utils::NewDeleteResource());
+    if (!maybe_found) {
+      throw QueryRuntimeException(
+          "Function '{}' has been unloaded. Please check query modules to confirm that function is loaded in Memgraph.",
+          fully_qualified_name);
+    }
+    /// Explicit extraction of module pointer, to clearly state that the lock is aquired.
+    // NOLINTNEXTLINE(clang-diagnostic-unused-variable)
+    const auto &module_ptr = (*maybe_found).first;
+
+    const auto &func_cb = func.cb;
+    mgp_memory memory{ctx.memory};
+    mgp_func_context functx{ctx.db_accessor, ctx.view};
+    auto graph = mgp_graph::NonWritableGraph(*ctx.db_accessor, ctx.view);
+
+    std::vector<TypedValue> args_list;
+    args_list.reserve(nargs);
+    for (std::size_t i = 0; i < nargs; ++i) {
+      args_list.emplace_back(args[i]);
+    }
+
+    auto function_argument_list = mgp_list(ctx.memory);
+    procedure::ConstructArguments(args_list, func, fully_qualified_name, function_argument_list, graph);
+
+    mgp_func_result maybe_res;
+    func_cb(&function_argument_list, &functx, &maybe_res, &memory);
+    if (maybe_res.error_msg) {
+      throw QueryRuntimeException(*maybe_res.error_msg);
+    }
+
+    if (!maybe_res.value) {
+      throw QueryRuntimeException(
+          "Function '{}' didn't set the result nor the error message. Please either set the result by using "
+          "mgp_func_result_set_value or the error by using mgp_func_result_set_error_msg.",
+          fully_qualified_name);
+    }
+
+    return {*(maybe_res.value), ctx.memory};
+  };
+}
+
 }  // namespace
 
 std::function<TypedValue(const TypedValue *, int64_t, const FunctionContext &ctx)> NameToFunction(
@@ -1162,7 +1293,6 @@ std::function<TypedValue(const TypedValue *, int64_t, const FunctionContext &ctx
   if (function_name == kStartsWith) return StartsWith;
   if (function_name == "SUBSTRING") return Substring;
   if (function_name == "TOLOWER") return ToLower;
-  // TODO(kostasrim) fix function lookup here
   if (function_name == "TOSTRING") return ToString;
   if (function_name == "TOUPPER") return ToUpper;
   if (function_name == "TRIM") return Trim;
@@ -1179,6 +1309,14 @@ std::function<TypedValue(const TypedValue *, int64_t, const FunctionContext &ctx
   if (function_name == "LOCALDATETIME") return LocalDateTime;
   if (function_name == "DURATION") return Duration;
 
+  const auto &maybe_found =
+      procedure::FindFunction(procedure::gModuleRegistry, function_name, utils::NewDeleteResource());
+
+  if (maybe_found) {
+    const auto *func = (*maybe_found).second;
+    return UserFunction(*func, function_name);
+  }
+
   return nullptr;
 }
 

src/query/v2/interpret/awesome_memgraph_functions.hpp

@@ -15,13 +15,13 @@
 #include <string>
 #include <unordered_map>
 
-#include "query/v2/bindings/typed_value.hpp"
 #include "storage/v3/view.hpp"
 #include "utils/memory.hpp"
 
 namespace memgraph::query::v2 {
 
 class DbAccessor;
+class TypedValue;
 
 namespace {
 const char kStartsWith[] = "STARTSWITH";

src/query/v2/interpret/eval.cpp

@@ -0,0 +1,35 @@
+// 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/interpret/eval.hpp"
+
+namespace memgraph::query::v2 {
+
+int64_t EvaluateInt(ExpressionEvaluator *evaluator, Expression *expr, const std::string &what) {
+  TypedValue value = expr->Accept(*evaluator);
+  try {
+    return value.ValueInt();
+  } catch (TypedValueException &e) {
+    throw QueryRuntimeException(what + " must be an int");
+  }
+}
+
+std::optional<size_t> EvaluateMemoryLimit(ExpressionEvaluator *eval, Expression *memory_limit, size_t memory_scale) {
+  if (!memory_limit) return std::nullopt;
+  auto limit_value = memory_limit->Accept(*eval);
+  if (!limit_value.IsInt() || limit_value.ValueInt() <= 0)
+    throw QueryRuntimeException("Memory limit must be a non-negative integer.");
+  size_t limit = limit_value.ValueInt();
+  if (std::numeric_limits<size_t>::max() / memory_scale < limit) throw QueryRuntimeException("Memory limit overflow.");
+  return limit * memory_scale;
+}
+
+}  // namespace memgraph::query::v2

src/query/v2/interpret/eval.hpp

@@ -17,26 +17,24 @@
 #include <map>
 #include <optional>
 #include <regex>
-#include <type_traits>
 #include <vector>
 
-#include "expr/ast.hpp"
-#include "expr/exceptions.hpp"
-#include "expr/interpret/frame.hpp"
-#include "expr/semantic/symbol_table.hpp"
+#include "query/v2/common.hpp"
+#include "query/v2/context.hpp"
+#include "query/v2/db_accessor.hpp"
+#include "query/v2/exceptions.hpp"
+#include "query/v2/frontend/ast/ast.hpp"
+#include "query/v2/frontend/semantic/symbol_table.hpp"
+#include "query/v2/interpret/frame.hpp"
+#include "query/v2/typed_value.hpp"
 #include "utils/exceptions.hpp"
 
-namespace memgraph::expr {
+namespace memgraph::query::v2 {
 
-struct StorageTag {};
-struct QueryEngineTag {};
-
-template <typename TypedValue, typename EvaluationContext, typename DbAccessor, typename StorageView, typename LabelId,
-          typename PropertyValue, typename ConvFunctor, typename Error, typename Tag = StorageTag>
 class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
  public:
-  ExpressionEvaluator(Frame<TypedValue> *frame, const SymbolTable &symbol_table, const EvaluationContext &ctx,
-                      DbAccessor *dba, StorageView view)
+  ExpressionEvaluator(Frame *frame, const SymbolTable &symbol_table, const EvaluationContext &ctx, DbAccessor *dba,
+                      storage::v3::View view)
       : frame_(frame), symbol_table_(&symbol_table), ctx_(&ctx), dba_(dba), view_(view) {}
 
   using ExpressionVisitor<TypedValue>::Visit;
@@ -54,29 +52,25 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     return TypedValue(frame_->at(symbol_table_->at(ident)), ctx_->memory);
   }
 
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define BINARY_OPERATOR_VISITOR(OP_NODE, CPP_OP, CYPHER_OP)                                                         \
-  /* NOLINTNEXTLINE(bugprone-macro-parentheses) */                                                                  \
-  TypedValue Visit(OP_NODE &op) override {                                                                          \
-    auto val1 = op.expression1_->Accept(*this);                                                                     \
-    auto val2 = op.expression2_->Accept(*this);                                                                     \
-    try {                                                                                                           \
-      return val1 CPP_OP val2;                                                                                      \
-    } catch (const TypedValueException &) {                                                                         \
-      throw ExpressionRuntimeException("Invalid types: {} and {} for '{}'.", val1.type(), val2.type(), #CYPHER_OP); \
-    }                                                                                                               \
+#define BINARY_OPERATOR_VISITOR(OP_NODE, CPP_OP, CYPHER_OP)                                                    \
+  TypedValue Visit(OP_NODE &op) override {                                                                     \
+    auto val1 = op.expression1_->Accept(*this);                                                                \
+    auto val2 = op.expression2_->Accept(*this);                                                                \
+    try {                                                                                                      \
+      return val1 CPP_OP val2;                                                                                 \
+    } catch (const TypedValueException &) {                                                                    \
+      throw QueryRuntimeException("Invalid types: {} and {} for '{}'.", val1.type(), val2.type(), #CYPHER_OP); \
+    }                                                                                                          \
   }
 
-  // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define UNARY_OPERATOR_VISITOR(OP_NODE, CPP_OP, CYPHER_OP)                                   \
-  /* NOLINTNEXTLINE(bugprone-macro-parentheses) */                                           \
-  TypedValue Visit(OP_NODE &op) override {                                                   \
-    auto val = op.expression_->Accept(*this);                                                \
-    try {                                                                                    \
-      return CPP_OP val;                                                                     \
-    } catch (const TypedValueException &) {                                                  \
-      throw ExpressionRuntimeException("Invalid type {} for '{}'.", val.type(), #CYPHER_OP); \
-    }                                                                                        \
+#define UNARY_OPERATOR_VISITOR(OP_NODE, CPP_OP, CYPHER_OP)                              \
+  TypedValue Visit(OP_NODE &op) override {                                              \
+    auto val = op.expression_->Accept(*this);                                           \
+    try {                                                                               \
+      return CPP_OP val;                                                                \
+    } catch (const TypedValueException &) {                                             \
+      throw QueryRuntimeException("Invalid type {} for '{}'.", val.type(), #CYPHER_OP); \
+    }                                                                                   \
   }
 
   BINARY_OPERATOR_VISITOR(OrOperator, ||, OR);
@@ -110,18 +104,18 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     try {
       return value1 && value2;
     } catch (const TypedValueException &) {
-      throw ExpressionRuntimeException("Invalid types: {} and {} for AND.", value1.type(), value2.type());
+      throw QueryRuntimeException("Invalid types: {} and {} for AND.", value1.type(), value2.type());
     }
   }
 
   TypedValue Visit(IfOperator &if_operator) override {
     auto condition = if_operator.condition_->Accept(*this);
     if (condition.IsNull()) {
-      return if_operator.else_expression_->Accept(*this);
+      return if_operator.then_expression_->Accept(*this);
     }
     if (condition.type() != TypedValue::Type::Bool) {
       // At the moment IfOperator is used only in CASE construct.
-      throw ExpressionRuntimeException("CASE expected boolean expression, got {}.", condition.type());
+      throw QueryRuntimeException("CASE expected boolean expression, got {}.", condition.type());
     }
     if (condition.ValueBool()) {
       return if_operator.then_expression_->Accept(*this);
@@ -138,7 +132,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     // Exceptions have higher priority than returning nulls when list expression
     // is not null.
     if (_list.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("IN expected a list, got {}.", _list.type());
+      throw QueryRuntimeException("IN expected a list, got {}.", _list.type());
     }
     const auto &list = _list.ValueList();
 
@@ -168,14 +162,13 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     auto lhs = list_indexing.expression1_->Accept(*this);
     auto index = list_indexing.expression2_->Accept(*this);
     if (!lhs.IsList() && !lhs.IsMap() && !lhs.IsVertex() && !lhs.IsEdge() && !lhs.IsNull())
-      throw ExpressionRuntimeException(
+      throw QueryRuntimeException(
           "Expected a list, a map, a node or an edge to index with '[]', got "
           "{}.",
           lhs.type());
     if (lhs.IsNull() || index.IsNull()) return TypedValue(ctx_->memory);
     if (lhs.IsList()) {
-      if (!index.IsInt())
-        throw ExpressionRuntimeException("Expected an integer as a list index, got {}.", index.type());
+      if (!index.IsInt()) throw QueryRuntimeException("Expected an integer as a list index, got {}.", index.type());
       auto index_int = index.ValueInt();
       // NOTE: Take non-const reference to list, so that we can move out the
       // indexed element as the result.
@@ -190,8 +183,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     }
 
     if (lhs.IsMap()) {
-      if (!index.IsString())
-        throw ExpressionRuntimeException("Expected a string as a map index, got {}.", index.type());
+      if (!index.IsString()) throw QueryRuntimeException("Expected a string as a map index, got {}.", index.type());
       // NOTE: Take non-const reference to map, so that we can move out the
       // looked-up element as the result.
       auto &map = lhs.ValueMap();
@@ -203,14 +195,12 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     }
 
     if (lhs.IsVertex()) {
-      if (!index.IsString())
-        throw ExpressionRuntimeException("Expected a string as a property name, got {}.", index.type());
+      if (!index.IsString()) throw QueryRuntimeException("Expected a string as a property name, got {}.", index.type());
       return TypedValue(GetProperty(lhs.ValueVertex(), index.ValueString()), ctx_->memory);
     }
 
     if (lhs.IsEdge()) {
-      if (!index.IsString())
-        throw ExpressionRuntimeException("Expected a string as a property name, got {}.", index.type());
+      if (!index.IsString()) throw QueryRuntimeException("Expected a string as a property name, got {}.", index.type());
       return TypedValue(GetProperty(lhs.ValueEdge(), index.ValueString()), ctx_->memory);
     }
 
@@ -228,7 +218,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         if (bound.type() == TypedValue::Type::Null) {
           is_null = true;
         } else if (bound.type() != TypedValue::Type::Int) {
-          throw ExpressionRuntimeException("Expected an integer for a bound in list slicing, got {}.", bound.type());
+          throw QueryRuntimeException("Expected an integer for a bound in list slicing, got {}.", bound.type());
         }
         return bound;
       }
@@ -241,7 +231,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     if (_list.type() == TypedValue::Type::Null) {
       is_null = true;
     } else if (_list.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("Expected a list to slice, got {}.", _list.type());
+      throw QueryRuntimeException("Expected a list to slice, got {}.", _list.type());
     }
 
     if (is_null) {
@@ -257,10 +247,9 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     auto lower_bound = normalise_bound(_lower_bound.ValueInt());
     auto upper_bound = normalise_bound(_upper_bound.ValueInt());
     if (upper_bound <= lower_bound) {
-      return TypedValue(typename TypedValue::TVector(ctx_->memory), ctx_->memory);
+      return TypedValue(TypedValue::TVector(ctx_->memory), ctx_->memory);
     }
-    return TypedValue(
-        typename TypedValue::TVector(list.begin() + lower_bound, list.begin() + upper_bound, ctx_->memory));
+    return TypedValue(TypedValue::TVector(list.begin() + lower_bound, list.begin() + upper_bound, ctx_->memory));
   }
 
   TypedValue Visit(IsNullOperator &is_null) override {
@@ -328,9 +317,9 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       case TypedValue::Type::Null:
         return TypedValue(ctx_->memory);
       case TypedValue::Type::Vertex:
-        return GetProperty(expression_result.ValueVertex(), property_lookup.property_);
+        return TypedValue(GetProperty(expression_result.ValueVertex(), property_lookup.property_), ctx_->memory);
       case TypedValue::Type::Edge:
-        return GetProperty(expression_result.ValueEdge(), property_lookup.property_);
+        return TypedValue(GetProperty(expression_result.ValueEdge(), property_lookup.property_), ctx_->memory);
       case TypedValue::Type::Map: {
         // NOTE: Take non-const reference to map, so that we can move out the
         // looked-up element as the result.
@@ -347,7 +336,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         if (auto dur_field = maybe_duration(dur, prop_name); dur_field) {
           return std::move(*dur_field);
         }
-        throw ExpressionRuntimeException("Invalid property name {} for Duration", prop_name);
+        throw QueryRuntimeException("Invalid property name {} for Duration", prop_name);
       }
       case TypedValue::Type::Date: {
         const auto &prop_name = property_lookup.property_.name;
@@ -355,7 +344,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         if (auto date_field = maybe_date(date, prop_name); date_field) {
           return std::move(*date_field);
         }
-        throw ExpressionRuntimeException("Invalid property name {} for Date", prop_name);
+        throw QueryRuntimeException("Invalid property name {} for Date", prop_name);
       }
       case TypedValue::Type::LocalTime: {
         const auto &prop_name = property_lookup.property_.name;
@@ -363,7 +352,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         if (auto lt_field = maybe_local_time(lt, prop_name); lt_field) {
           return std::move(*lt_field);
         }
-        throw ExpressionRuntimeException("Invalid property name {} for LocalTime", prop_name);
+        throw QueryRuntimeException("Invalid property name {} for LocalTime", prop_name);
       }
       case TypedValue::Type::LocalDateTime: {
         const auto &prop_name = property_lookup.property_.name;
@@ -374,50 +363,13 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         if (auto lt_field = maybe_local_time(ldt.local_time, prop_name); lt_field) {
           return std::move(*lt_field);
         }
-        throw ExpressionRuntimeException("Invalid property name {} for LocalDateTime", prop_name);
+        throw QueryRuntimeException("Invalid property name {} for LocalDateTime", prop_name);
       }
       default:
-        throw ExpressionRuntimeException("Only nodes, edges, maps and temporal types have properties to be looked-up.");
+        throw QueryRuntimeException("Only nodes, edges, maps and temporal types have properties to be looked-up.");
     }
   }
 
-  template <typename VertexAccessor, typename TTag = Tag,
-            typename TReturnType = std::enable_if_t<std::is_same_v<TTag, StorageTag>, bool>>
-  TReturnType HasLabelImpl(const VertexAccessor &vertex, const LabelIx &label, StorageTag /*tag*/) {
-    auto has_label = vertex.HasLabel(view_, GetLabel(label));
-    if (has_label.HasError() && has_label.GetError() == Error::NONEXISTENT_OBJECT) {
-      // This is a very nasty and temporary hack in order to make MERGE
-      // work. The old storage had the following logic when returning an
-      // `OLD` view: `return old ? old : new`. That means that if the
-      // `OLD` view didn't exist, it returned the NEW view. With this hack
-      // we simulate that behavior.
-      // TODO (mferencevic, teon.banek): Remove once MERGE is
-      // reimplemented.
-      has_label = vertex.HasLabel(StorageView::NEW, GetLabel(label));
-    }
-    if (has_label.HasError()) {
-      switch (has_label.GetError()) {
-        case Error::DELETED_OBJECT:
-          throw ExpressionRuntimeException("Trying to access labels on a deleted node.");
-        case Error::NONEXISTENT_OBJECT:
-          throw ExpressionRuntimeException("Trying to access labels from a node that doesn't exist.");
-        case Error::SERIALIZATION_ERROR:
-        case Error::VERTEX_HAS_EDGES:
-        case Error::PROPERTIES_DISABLED:
-          throw ExpressionRuntimeException("Unexpected error when accessing labels.");
-      }
-    }
-    return *has_label;
-  }
-
-  template <typename VertexAccessor, typename TTag = Tag,
-            typename TReturnType = std::enable_if_t<std::is_same_v<TTag, QueryEngineTag>, bool>>
-  TReturnType HasLabelImpl(const VertexAccessor &vertex, const LabelIx &label_ix, QueryEngineTag /*tag*/) {
-    auto label = typename VertexAccessor::Label{LabelId::FromUint(label_ix.ix)};
-    auto has_label = vertex.HasLabel(label);
-    return !has_label;
-  }
-
   TypedValue Visit(LabelsTest &labels_test) override {
     auto expression_result = labels_test.expression_->Accept(*this);
     switch (expression_result.type()) {
@@ -425,15 +377,38 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
         return TypedValue(ctx_->memory);
       case TypedValue::Type::Vertex: {
         const auto &vertex = expression_result.ValueVertex();
-        if (std::ranges::all_of(labels_test.labels_, [&vertex, this](const auto label_test) {
-              return this->HasLabelImpl(vertex, label_test, Tag{});
-            })) {
-          return TypedValue(true, ctx_->memory);
+        for (const auto &label : labels_test.labels_) {
+          auto has_label = vertex.HasLabel(view_, GetLabel(label));
+          if (has_label.HasError() && has_label.GetError() == storage::v3::Error::NONEXISTENT_OBJECT) {
+            // This is a very nasty and temporary hack in order to make MERGE
+            // work. The old storage had the following logic when returning an
+            // `OLD` view: `return old ? old : new`. That means that if the
+            // `OLD` view didn't exist, it returned the NEW view. With this hack
+            // we simulate that behavior.
+            // TODO (mferencevic, teon.banek): Remove once MERGE is
+            // reimplemented.
+            has_label = vertex.HasLabel(storage::v3::View::NEW, GetLabel(label));
+          }
+          if (has_label.HasError()) {
+            switch (has_label.GetError()) {
+              case storage::v3::Error::DELETED_OBJECT:
+                throw QueryRuntimeException("Trying to access labels on a deleted node.");
+              case storage::v3::Error::NONEXISTENT_OBJECT:
+                throw query::v2::QueryRuntimeException("Trying to access 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 QueryRuntimeException("Unexpected error when accessing labels.");
+            }
+          }
+          if (!*has_label) {
+            return TypedValue(false, ctx_->memory);
+          }
         }
-        return TypedValue(false, ctx_->memory);
+        return TypedValue(true, ctx_->memory);
       }
       default:
-        throw ExpressionRuntimeException("Only nodes have labels.");
+        throw QueryRuntimeException("Only nodes have labels.");
     }
   }
 
@@ -444,14 +419,14 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
   }
 
   TypedValue Visit(ListLiteral &literal) override {
-    typename TypedValue::TVector result(ctx_->memory);
+    TypedValue::TVector result(ctx_->memory);
     result.reserve(literal.elements_.size());
     for (const auto &expression : literal.elements_) result.emplace_back(expression->Accept(*this));
     return TypedValue(result, ctx_->memory);
   }
 
   TypedValue Visit(MapLiteral &literal) override {
-    typename TypedValue::TMap result(ctx_->memory);
+    TypedValue::TMap result(ctx_->memory);
     for (const auto &pair : literal.elements_) result.emplace(pair.first.name, pair.second->Accept(*this));
     return TypedValue(result, ctx_->memory);
   }
@@ -464,7 +439,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     auto &exprs = coalesce.expressions_;
 
     if (exprs.size() == 0) {
-      throw ExpressionRuntimeException("'coalesce' requires at least one argument.");
+      throw QueryRuntimeException("'coalesce' requires at least one argument.");
     }
 
     for (int64_t i = 0; i < exprs.size(); ++i) {
@@ -491,7 +466,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       MG_ASSERT(res.GetMemoryResource() == ctx_->memory);
       return res;
     } else {
-      typename TypedValue::TVector arguments(ctx_->memory);
+      TypedValue::TVector arguments(ctx_->memory);
       arguments.reserve(function.arguments_.size());
       for (const auto &argument : function.arguments_) {
         arguments.emplace_back(argument->Accept(*this));
@@ -508,7 +483,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (list_value.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("REDUCE expected a list, got {}.", list_value.type());
+      throw QueryRuntimeException("REDUCE expected a list, got {}.", list_value.type());
     }
     const auto &list = list_value.ValueList();
     const auto &element_symbol = symbol_table_->at(*reduce.identifier_);
@@ -528,11 +503,11 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (list_value.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("EXTRACT expected a list, got {}.", list_value.type());
+      throw QueryRuntimeException("EXTRACT expected a list, got {}.", list_value.type());
     }
     const auto &list = list_value.ValueList();
     const auto &element_symbol = symbol_table_->at(*extract.identifier_);
-    typename TypedValue::TVector result(ctx_->memory);
+    TypedValue::TVector result(ctx_->memory);
     result.reserve(list.size());
     for (const auto &element : list) {
       if (element.IsNull()) {
@@ -551,7 +526,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (list_value.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("ALL expected a list, got {}.", list_value.type());
+      throw QueryRuntimeException("ALL expected a list, got {}.", list_value.type());
     }
     const auto &list = list_value.ValueList();
     const auto &symbol = symbol_table_->at(*all.identifier_);
@@ -561,7 +536,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       frame_->at(symbol) = element;
       auto result = all.where_->expression_->Accept(*this);
       if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
-        throw ExpressionRuntimeException("Predicate of ALL must evaluate to boolean, got {}.", result.type());
+        throw QueryRuntimeException("Predicate of ALL must evaluate to boolean, got {}.", result.type());
       }
       if (!result.IsNull()) {
         has_value = true;
@@ -588,7 +563,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (list_value.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("SINGLE expected a list, got {}.", list_value.type());
+      throw QueryRuntimeException("SINGLE expected a list, got {}.", list_value.type());
     }
     const auto &list = list_value.ValueList();
     const auto &symbol = symbol_table_->at(*single.identifier_);
@@ -598,7 +573,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       frame_->at(symbol) = element;
       auto result = single.where_->expression_->Accept(*this);
       if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
-        throw ExpressionRuntimeException("Predicate of SINGLE must evaluate to boolean, got {}.", result.type());
+        throw QueryRuntimeException("Predicate of SINGLE must evaluate to boolean, got {}.", result.type());
       }
       if (result.type() == TypedValue::Type::Bool) {
         has_value = true;
@@ -626,7 +601,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (list_value.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("ANY expected a list, got {}.", list_value.type());
+      throw QueryRuntimeException("ANY expected a list, got {}.", list_value.type());
     }
     const auto &list = list_value.ValueList();
     const auto &symbol = symbol_table_->at(*any.identifier_);
@@ -635,7 +610,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       frame_->at(symbol) = element;
       auto result = any.where_->expression_->Accept(*this);
       if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
-        throw ExpressionRuntimeException("Predicate of ANY must evaluate to boolean, got {}.", result.type());
+        throw QueryRuntimeException("Predicate of ANY must evaluate to boolean, got {}.", result.type());
       }
       if (!result.IsNull()) {
         has_value = true;
@@ -658,7 +633,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (list_value.type() != TypedValue::Type::List) {
-      throw ExpressionRuntimeException("NONE expected a list, got {}.", list_value.type());
+      throw QueryRuntimeException("NONE expected a list, got {}.", list_value.type());
     }
     const auto &list = list_value.ValueList();
     const auto &symbol = symbol_table_->at(*none.identifier_);
@@ -667,7 +642,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       frame_->at(symbol) = element;
       auto result = none.where_->expression_->Accept(*this);
       if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
-        throw ExpressionRuntimeException("Predicate of NONE must evaluate to boolean, got {}.", result.type());
+        throw QueryRuntimeException("Predicate of NONE must evaluate to boolean, got {}.", result.type());
       }
       if (!result.IsNull()) {
         has_value = true;
@@ -685,7 +660,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
   }
 
   TypedValue Visit(ParameterLookup &param_lookup) override {
-    return TypedValue(conv_(ctx_->parameters.AtTokenPosition(param_lookup.token_position_)), ctx_->memory);
+    return TypedValue(ctx_->parameters.AtTokenPosition(param_lookup.token_position_), ctx_->memory);
   }
 
   TypedValue Visit(RegexMatch &regex_match) override {
@@ -695,7 +670,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       return TypedValue(ctx_->memory);
     }
     if (regex_value.type() != TypedValue::Type::String) {
-      throw ExpressionRuntimeException("Regular expression must evaluate to a string, got {}.", regex_value.type());
+      throw QueryRuntimeException("Regular expression must evaluate to a string, got {}.", regex_value.type());
     }
     if (target_string_value.type() != TypedValue::Type::String) {
       // Instead of error, we return Null which makes it compatible in case we
@@ -708,60 +683,42 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       std::regex regex(regex_value.ValueString());
       return TypedValue(std::regex_match(target_string, regex), ctx_->memory);
     } catch (const std::regex_error &e) {
-      throw ExpressionRuntimeException("Regex error in '{}': {}", regex_value.ValueString(), e.what());
+      throw QueryRuntimeException("Regex error in '{}': {}", regex_value.ValueString(), e.what());
     }
   }
 
  private:
-  template <class TRecordAccessor, class TTag = Tag,
-            class TReturnType = std::enable_if_t<std::is_same_v<TTag, QueryEngineTag>, TypedValue>>
-  TReturnType GetProperty(const TRecordAccessor &record_accessor, PropertyIx prop) {
-    auto maybe_prop = record_accessor.GetProperty(prop.name);
-    // Handler non existent property
-    return conv_(maybe_prop);
-  }
-
-  template <class TRecordAccessor, class TTag = Tag,
-            class TReturnType = std::enable_if_t<std::is_same_v<TTag, QueryEngineTag>, TypedValue>>
-  TReturnType GetProperty(const TRecordAccessor &record_accessor, const std::string_view name) {
-    auto maybe_prop = record_accessor.GetProperty(std::string(name));
-    // Handler non existent property
-    return conv_(maybe_prop);
-  }
-
-  template <class TRecordAccessor, class TTag = Tag,
-            class TReturnType = std::enable_if_t<std::is_same_v<TTag, StorageTag>, TypedValue>>
-  TypedValue GetProperty(const TRecordAccessor &record_accessor, PropertyIx prop) {
+  template <class TRecordAccessor>
+  storage::v3::PropertyValue GetProperty(const TRecordAccessor &record_accessor, PropertyIx prop) {
     auto maybe_prop = record_accessor.GetProperty(view_, ctx_->properties[prop.ix]);
-    if (maybe_prop.HasError() && maybe_prop.GetError() == Error::NONEXISTENT_OBJECT) {
+    if (maybe_prop.HasError() && maybe_prop.GetError() == storage::v3::Error::NONEXISTENT_OBJECT) {
       // This is a very nasty and temporary hack in order to make MERGE work.
       // The old storage had the following logic when returning an `OLD` view:
       // `return old ? old : new`. That means that if the `OLD` view didn't
       // exist, it returned the NEW view. With this hack we simulate that
       // behavior.
       // TODO (mferencevic, teon.banek): Remove once MERGE is reimplemented.
-      maybe_prop = record_accessor.GetProperty(StorageView::NEW, ctx_->properties[prop.ix]);
+      maybe_prop = record_accessor.GetProperty(storage::v3::View::NEW, ctx_->properties[prop.ix]);
     }
     if (maybe_prop.HasError()) {
       switch (maybe_prop.GetError()) {
-        case Error::DELETED_OBJECT:
-          throw ExpressionRuntimeException("Trying to get a property from a deleted object.");
-        case Error::NONEXISTENT_OBJECT:
-          throw ExpressionRuntimeException("Trying to get a property from an object that doesn't exist.");
-        case Error::SERIALIZATION_ERROR:
-        case Error::VERTEX_HAS_EDGES:
-        case Error::PROPERTIES_DISABLED:
-          throw ExpressionRuntimeException("Unexpected error when getting a property.");
+        case storage::v3::Error::DELETED_OBJECT:
+          throw QueryRuntimeException("Trying to get a property from a deleted object.");
+        case storage::v3::Error::NONEXISTENT_OBJECT:
+          throw query::v2::QueryRuntimeException("Trying to get a property from an object that doesn't exist.");
+        case storage::v3::Error::SERIALIZATION_ERROR:
+        case storage::v3::Error::VERTEX_HAS_EDGES:
+        case storage::v3::Error::PROPERTIES_DISABLED:
+          throw QueryRuntimeException("Unexpected error when getting a property.");
       }
     }
-    return conv_(*maybe_prop, ctx_->memory);
+    return *maybe_prop;
   }
 
-  template <class TRecordAccessor, class TTag = Tag,
-            class TReturnType = std::enable_if_t<std::is_same_v<TTag, StorageTag>, TypedValue>>
-  TypedValue GetProperty(const TRecordAccessor &record_accessor, const std::string_view name) {
+  template <class TRecordAccessor>
+  storage::v3::PropertyValue GetProperty(const TRecordAccessor &record_accessor, const std::string_view name) {
     auto maybe_prop = record_accessor.GetProperty(view_, dba_->NameToProperty(name));
-    if (maybe_prop.HasError() && maybe_prop.GetError() == Error::NONEXISTENT_OBJECT) {
+    if (maybe_prop.HasError() && maybe_prop.GetError() == storage::v3::Error::NONEXISTENT_OBJECT) {
       // This is a very nasty and temporary hack in order to make MERGE work.
       // The old storage had the following logic when returning an `OLD` view:
       // `return old ? old : new`. That means that if the `OLD` view didn't
@@ -772,55 +729,36 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     }
     if (maybe_prop.HasError()) {
       switch (maybe_prop.GetError()) {
-        case Error::DELETED_OBJECT:
-          throw ExpressionRuntimeException("Trying to get a property from a deleted object.");
-        case Error::NONEXISTENT_OBJECT:
-          throw ExpressionRuntimeException("Trying to get a property from an object that doesn't exist.");
-        case Error::SERIALIZATION_ERROR:
-        case Error::VERTEX_HAS_EDGES:
-        case Error::PROPERTIES_DISABLED:
-          throw ExpressionRuntimeException("Unexpected error when getting a property.");
+        case storage::v3::Error::DELETED_OBJECT:
+          throw QueryRuntimeException("Trying to get a property from a deleted object.");
+        case storage::v3::Error::NONEXISTENT_OBJECT:
+          throw query::v2::QueryRuntimeException("Trying to get a property from an object that doesn't exist.");
+        case storage::v3::Error::SERIALIZATION_ERROR:
+        case storage::v3::Error::VERTEX_HAS_EDGES:
+        case storage::v3::Error::PROPERTIES_DISABLED:
+          throw QueryRuntimeException("Unexpected error when getting a property.");
       }
     }
-    return conv_(*maybe_prop, ctx_->memory);
+    return *maybe_prop;
   }
 
-  LabelId GetLabel(LabelIx label) { return ctx_->labels[label.ix]; }
+  storage::v3::LabelId GetLabel(LabelIx label) { return ctx_->labels[label.ix]; }
 
-  Frame<TypedValue> *frame_;
+  Frame *frame_;
   const SymbolTable *symbol_table_;
   const EvaluationContext *ctx_;
   DbAccessor *dba_;
   // which switching approach should be used when evaluating
-  StorageView view_;
-  ConvFunctor conv_;
+  storage::v3::View view_;
 };
 
 /// A helper function for evaluating an expression that's an int.
 ///
 /// @param what - Name of what's getting evaluated. Used for user feedback (via
 ///               exception) when the evaluated value is not an int.
-/// @throw ExpressionRuntimeException if expression doesn't evaluate to an int.
-template <typename ExpressionEvaluator>
-int64_t EvaluateInt(ExpressionEvaluator *evaluator, Expression *expr, const std::string &what) {
-  TypedValue value = expr->Accept(*evaluator);
-  try {
-    return value.ValueInt();
-  } catch (TypedValueException &e) {
-    throw ExpressionRuntimeException(what + " must be an int");
-  }
-}
+/// @throw QueryRuntimeException if expression doesn't evaluate to an int.
+int64_t EvaluateInt(ExpressionEvaluator *evaluator, Expression *expr, const std::string &what);
 
-template <typename ExpressionEvaluator>
-std::optional<size_t> EvaluateMemoryLimit(ExpressionEvaluator *eval, Expression *memory_limit, size_t memory_scale) {
-  if (!memory_limit) return std::nullopt;
-  auto limit_value = memory_limit->Accept(*eval);
-  if (!limit_value.IsInt() || limit_value.ValueInt() <= 0)
-    throw ExpressionRuntimeException("Memory limit must be a non-negative integer.");
-  size_t limit = limit_value.ValueInt();
-  if (std::numeric_limits<size_t>::max() / memory_scale < limit)
-    throw ExpressionRuntimeException("Memory limit overflow.");
-  return limit * memory_scale;
-}
+std::optional<size_t> EvaluateMemoryLimit(ExpressionEvaluator *eval, Expression *memory_limit, size_t memory_scale);
 
-}  // namespace memgraph::expr
+}  // namespace memgraph::query::v2

src/query/v2/interpret/frame.hpp

@@ -13,14 +13,14 @@
 
 #include <vector>
 
-#include "expr/semantic/symbol_table.hpp"
+#include "query/v2/frontend/semantic/symbol_table.hpp"
+#include "query/v2/typed_value.hpp"
 #include "utils/logging.hpp"
 #include "utils/memory.hpp"
 #include "utils/pmr/vector.hpp"
 
-namespace memgraph::expr {
+namespace memgraph::query::v2 {
 
-template <typename TypedValue>
 class Frame {
  public:
   /// Create a Frame of given size backed by a utils::NewDeleteResource()
@@ -42,4 +42,4 @@ class Frame {
   utils::pmr::vector<TypedValue> elems_;
 };
 
-}  // namespace memgraph::expr
+}  // namespace memgraph::query::v2

src/query/v2/interpreter.hpp

@@ -14,21 +14,23 @@
 #include <gflags/gflags.h>
 
 #include "query/v2/auth_checker.hpp"
-#include "query/v2/bindings/cypher_main_visitor.hpp"
-#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/config.hpp"
 #include "query/v2/context.hpp"
 #include "query/v2/cypher_query_interpreter.hpp"
 #include "query/v2/db_accessor.hpp"
 #include "query/v2/exceptions.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
+#include "query/v2/frontend/ast/cypher_main_visitor.hpp"
 #include "query/v2/frontend/stripped.hpp"
+#include "query/v2/interpret/frame.hpp"
 #include "query/v2/metadata.hpp"
 #include "query/v2/plan/operator.hpp"
 #include "query/v2/plan/read_write_type_checker.hpp"
 #include "query/v2/stream.hpp"
+#include "query/v2/stream/streams.hpp"
+#include "query/v2/trigger.hpp"
+#include "query/v2/typed_value.hpp"
 #include "storage/v3/isolation_level.hpp"
-#include "storage/v3/name_id_mapper.hpp"
 #include "utils/event_counter.hpp"
 #include "utils/logging.hpp"
 #include "utils/memory.hpp"
@@ -164,10 +166,10 @@ struct PreparedQuery {
  * been passed to an `Interpreter` instance.
  */
 struct InterpreterContext {
-  explicit InterpreterContext(storage::v3::Shard *db, InterpreterConfig config,
+  explicit InterpreterContext(storage::v3::Storage *db, InterpreterConfig config,
                               const std::filesystem::path &data_directory);
 
-  storage::v3::Shard *db;
+  storage::v3::Storage *db;
 
   std::optional<double> tsc_frequency{utils::GetTSCFrequency()};
   std::atomic<bool> is_shutting_down{false};
@@ -178,23 +180,12 @@ struct InterpreterContext {
   utils::SkipList<QueryCacheEntry> ast_cache;
   utils::SkipList<PlanCacheEntry> plan_cache;
 
+  TriggerStore trigger_store;
+  utils::ThreadPool after_commit_trigger_pool{1};
+
   const InterpreterConfig config;
 
-  storage::v3::LabelId NameToLabelId(std::string_view label_name) {
-    return storage::v3::LabelId::FromUint(query_id_mapper.NameToId(label_name));
-  }
-
-  storage::v3::PropertyId NameToPropertyId(std::string_view property_name) {
-    return storage::v3::PropertyId::FromUint(query_id_mapper.NameToId(property_name));
-  }
-
-  storage::v3::EdgeTypeId NameToEdgeTypeId(std::string_view edge_type_name) {
-    return storage::v3::EdgeTypeId::FromUint(query_id_mapper.NameToId(edge_type_name));
-  }
-
- private:
-  // TODO Replace with local map of labels, properties and edge type ids
-  storage::v3::NameIdMapper query_id_mapper;
+  query::v2::stream::Streams streams;
 };
 
 /// Function that is used to tell all active interpreters that they should stop
@@ -325,8 +316,9 @@ class Interpreter final {
   // This cannot be std::optional because we need to move this accessor later on into a lambda capture
   // which is assigned to std::function. std::function requires every object to be copyable, so we
   // move this unique_ptr into a shrared_ptr.
-  std::unique_ptr<storage::v3::Shard::Accessor> db_accessor_;
+  std::unique_ptr<storage::v3::Storage::Accessor> db_accessor_;
   std::optional<DbAccessor> execution_db_accessor_;
+  std::optional<TriggerContextCollector> trigger_context_collector_;
   bool in_explicit_transaction_{false};
   bool expect_rollback_{false};
 

src/query/v2/metadata.cpp

@@ -72,6 +72,10 @@ constexpr std::string_view GetCodeString(const NotificationCode code) {
       return "ReplicaPortWarning"sv;
     case NotificationCode::SET_REPLICA:
       return "SetReplica"sv;
+    case NotificationCode::SHOW_SCHEMA:
+      return "ShowSchema"sv;
+    case NotificationCode::SHOW_SCHEMAS:
+      return "ShowSchemas"sv;
     case NotificationCode::START_STREAM:
       return "StartStream"sv;
     case NotificationCode::START_ALL_STREAMS:

src/query/v2/metadata.hpp

@@ -17,7 +17,7 @@
 #include <string_view>
 #include <type_traits>
 
-#include "query/v2/bindings/typed_value.hpp"
+#include "query/v2/typed_value.hpp"
 
 namespace memgraph::query::v2 {
 
@@ -44,6 +44,8 @@ enum class NotificationCode : uint8_t {
   REPLICA_PORT_WARNING,
   REGISTER_REPLICA,
   SET_REPLICA,
+  SHOW_SCHEMA,
+  SHOW_SCHEMAS,
   START_STREAM,
   START_ALL_STREAMS,
   STOP_STREAM,

src/query/v2/plan/cost_estimator.hpp

@@ -11,11 +11,10 @@
 
 #pragma once
 
-#include "query/v2/bindings/typed_value.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
 #include "query/v2/parameters.hpp"
 #include "query/v2/plan/operator.hpp"
-#include "storage/v3/conversions.hpp"
+#include "query/v2/typed_value.hpp"
 
 namespace memgraph::query::v2::plan {
 
@@ -249,7 +248,7 @@ class CostEstimator : public HierarchicalLogicalOperatorVisitor {
   // return nullopt.
   std::optional<storage::v3::PropertyValue> ConstPropertyValue(const Expression *expression) {
     if (auto *literal = utils::Downcast<const PrimitiveLiteral>(expression)) {
-      return storage::v3::TypedToPropertyValue(literal->value_);
+      return literal->value_;
     } else if (auto *param_lookup = utils::Downcast<const ParameterLookup>(expression)) {
       return parameters.AtTokenPosition(param_lookup->token_position_);
     }

src/query/v2/plan/operator.lcp

@@ -24,21 +24,14 @@
 
 #include "query/v2/common.hpp"
 #include "query/v2/frontend/ast/ast.hpp"
-#include "expr/semantic/symbol.hpp"
-#include "query/v2/bindings/typed_value.hpp"
-#include "query/v2/bindings/frame.hpp"
-#include "query/v2/bindings/symbol_table.hpp"
+#include "query/v2/frontend/semantic/symbol.hpp"
+#include "query/v2/typed_value.hpp"
 #include "storage/v3/id_types.hpp"
 #include "utils/bound.hpp"
 #include "utils/fnv.hpp"
 #include "utils/memory.hpp"
 #include "utils/visitor.hpp"
 #include "utils/logging.hpp"
-#include "query/v2/accessors.hpp"
-
-using VertexAccessor = memgraph::query::v2::accessors::VertexAccessor;
-using EdgeAccessor = memgraph::query::v2::accessors::EdgeAccessor;
-using Path = memgraph::query::v2::accessors::Path;
 cpp<#
 
 (lcp:namespace memgraph)
@@ -47,6 +40,9 @@ cpp<#
 
 #>cpp
 struct ExecutionContext;
+class ExpressionEvaluator;
+class Frame;
+class SymbolTable;
 cpp<#
 
 (lcp:namespace plan)