Merge branch 'T0919-MG-implement-get-properties-storage' into T1172-MG-implement-get-properties-on-qe

.github/workflows/diff.yaml

@@ -99,7 +99,7 @@ jobs:
             echo ${file}
             if [[ ${file} == *.py ]]; then
               python3 -m black --check --diff ${file}
-              python3 -m isort --check-only --diff ${file}
+              python3 -m isort --check-only --profile "black" --diff ${file}
             fi
           done
 

.pre-commit-config.yaml

@@ -14,6 +14,7 @@ repos:
     hooks:
       - id: isort
         name: isort (python)
+        args: ["--profile", "black"]
   - repo: https://github.com/pre-commit/mirrors-clang-format
     rev: v13.0.0
     hooks:

CMakeLists.txt

@@ -182,7 +182,8 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 # c99-designator is disabled because of required mixture of designated and
 # non-designated initializers in Python Query Module code (`py_module.cpp`).
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall \
-    -Werror=switch -Werror=switch-bool -Werror=return-type \
+    -Werror=switch -Werror=switch-bool -Werror=implicit-fallthrough \
+    -Werror=return-type \
     -Werror=return-stack-address \
     -Wno-c99-designator \
     -DBOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT")

src/CMakeLists.txt

@@ -21,6 +21,7 @@ add_subdirectory(auth)
 add_subdirectory(parser)
 add_subdirectory(expr)
 add_subdirectory(coordinator)
+add_subdirectory(functions)
 
 if (MG_ENTERPRISE)
   add_subdirectory(audit)

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

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

src/expr/CMakeLists.txt

@@ -17,4 +17,4 @@ 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)
+target_link_libraries(mg-expr cppitertools Boost::headers mg-utils mg-parser mg-functions)

src/expr/interpret/eval.hpp

@@ -24,6 +24,7 @@
 #include "expr/exceptions.hpp"
 #include "expr/interpret/frame.hpp"
 #include "expr/semantic/symbol_table.hpp"
+#include "functions/awesome_memgraph_functions.hpp"
 #include "utils/exceptions.hpp"
 
 namespace memgraph::expr {
@@ -427,8 +428,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
             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;
+    return vertex.HasLabel(label);
   }
 
   TypedValue Visit(LabelsTest &labels_test) override {
@@ -491,7 +491,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
   }
 
   TypedValue Visit(Function &function) override {
-    FunctionContext function_ctx{dba_, ctx_->memory, ctx_->timestamp, &ctx_->counters, view_};
+    functions::FunctionContext<DbAccessor> function_ctx{dba_, ctx_->memory, ctx_->timestamp, &ctx_->counters, view_};
     // Stack allocate evaluated arguments when there's a small number of them.
     if (function.arguments_.size() <= 8) {
       TypedValue arguments[8] = {TypedValue(ctx_->memory), TypedValue(ctx_->memory), TypedValue(ctx_->memory),

src/functions/CMakeLists.txt

@@ -0,0 +1 @@
+add_library(mg-functions INTERFACE)

src/glue/v2/communication.cpp

@@ -18,8 +18,8 @@
 #include "common/errors.hpp"
 #include "coordinator/shard_map.hpp"
 #include "query/v2/accessors.hpp"
+#include "query/v2/request_router.hpp"
 #include "query/v2/requests.hpp"
-#include "query/v2/shard_request_manager.hpp"
 #include "storage/v3/edge_accessor.hpp"
 #include "storage/v3/id_types.hpp"
 #include "storage/v3/shard.hpp"
@@ -72,7 +72,7 @@ query::v2::TypedValue ToTypedValue(const Value &value) {
 }
 
 communication::bolt::Vertex ToBoltVertex(const query::v2::accessors::VertexAccessor &vertex,
-                                         const msgs::ShardRequestManagerInterface *shard_request_manager,
+                                         const query::v2::RequestRouterInterface *request_router,
                                          storage::v3::View /*view*/) {
   auto id = communication::bolt::Id::FromUint(0);
 
@@ -80,43 +80,43 @@ communication::bolt::Vertex ToBoltVertex(const query::v2::accessors::VertexAcces
   std::vector<std::string> new_labels;
   new_labels.reserve(labels.size());
   for (const auto &label : labels) {
-    new_labels.push_back(shard_request_manager->LabelToName(label.id));
+    new_labels.push_back(request_router->LabelToName(label.id));
   }
 
   auto properties = vertex.Properties();
   std::map<std::string, Value> new_properties;
   for (const auto &[prop, property_value] : properties) {
-    new_properties[shard_request_manager->PropertyToName(prop)] = ToBoltValue(property_value);
+    new_properties[request_router->PropertyToName(prop)] = ToBoltValue(property_value);
   }
   return communication::bolt::Vertex{id, new_labels, new_properties};
 }
 
 communication::bolt::Edge ToBoltEdge(const query::v2::accessors::EdgeAccessor &edge,
-                                     const msgs::ShardRequestManagerInterface *shard_request_manager,
+                                     const query::v2::RequestRouterInterface *request_router,
                                      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 auto &type = shard_request_manager->EdgeTypeToName(edge.EdgeType());
+  const auto &type = request_router->EdgeTypeToName(edge.EdgeType());
 
   auto properties = edge.Properties();
   std::map<std::string, Value> new_properties;
   for (const auto &[prop, property_value] : properties) {
-    new_properties[shard_request_manager->PropertyToName(prop)] = ToBoltValue(property_value);
+    new_properties[request_router->PropertyToName(prop)] = ToBoltValue(property_value);
   }
   return communication::bolt::Edge{id, from, to, type, new_properties};
 }
 
 communication::bolt::Path ToBoltPath(const query::v2::accessors::Path & /*edge*/,
-                                     const msgs::ShardRequestManagerInterface * /*shard_request_manager*/,
+                                     const query::v2::RequestRouterInterface * /*request_router*/,
                                      storage::v3::View /*view*/) {
   // TODO(jbajic) Fix bolt communication
   MG_ASSERT(false, "Path is unimplemented!");
   return {};
 }
 
-Value ToBoltValue(const query::v2::TypedValue &value, const msgs::ShardRequestManagerInterface *shard_request_manager,
+Value ToBoltValue(const query::v2::TypedValue &value, const query::v2::RequestRouterInterface *request_router,
                   storage::v3::View view) {
   switch (value.type()) {
     case query::v2::TypedValue::Type::Null:
@@ -133,7 +133,7 @@ Value ToBoltValue(const query::v2::TypedValue &value, const msgs::ShardRequestMa
       std::vector<Value> values;
       values.reserve(value.ValueList().size());
       for (const auto &v : value.ValueList()) {
-        auto value = ToBoltValue(v, shard_request_manager, view);
+        auto value = ToBoltValue(v, request_router, view);
         values.emplace_back(std::move(value));
       }
       return {std::move(values)};
@@ -141,21 +141,21 @@ Value ToBoltValue(const query::v2::TypedValue &value, const msgs::ShardRequestMa
     case query::v2::TypedValue::Type::Map: {
       std::map<std::string, Value> map;
       for (const auto &kv : value.ValueMap()) {
-        auto value = ToBoltValue(kv.second, shard_request_manager, view);
+        auto value = ToBoltValue(kv.second, request_router, view);
         map.emplace(kv.first, std::move(value));
       }
       return {std::move(map)};
     }
     case query::v2::TypedValue::Type::Vertex: {
-      auto vertex = ToBoltVertex(value.ValueVertex(), shard_request_manager, view);
+      auto vertex = ToBoltVertex(value.ValueVertex(), request_router, view);
       return {std::move(vertex)};
     }
     case query::v2::TypedValue::Type::Edge: {
-      auto edge = ToBoltEdge(value.ValueEdge(), shard_request_manager, view);
+      auto edge = ToBoltEdge(value.ValueEdge(), request_router, view);
       return {std::move(edge)};
     }
     case query::v2::TypedValue::Type::Path: {
-      auto path = ToBoltPath(value.ValuePath(), shard_request_manager, view);
+      auto path = ToBoltPath(value.ValuePath(), request_router, view);
       return {std::move(path)};
     }
     case query::v2::TypedValue::Type::Date:

src/glue/v2/communication.hpp

@@ -15,7 +15,7 @@
 #include "communication/bolt/v1/value.hpp"
 #include "coordinator/shard_map.hpp"
 #include "query/v2/bindings/typed_value.hpp"
-#include "query/v2/shard_request_manager.hpp"
+#include "query/v2/request_router.hpp"
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/result.hpp"
 #include "storage/v3/shard.hpp"
@@ -32,40 +32,37 @@ namespace memgraph::glue::v2 {
 
 /// @param storage::v3::VertexAccessor for converting to
 ///        communication::bolt::Vertex.
-/// @param msgs::ShardRequestManagerInterface *shard_request_manager getting label and property names.
+/// @param query::v2::RequestRouterInterface *request_router getting label and property names.
 /// @param storage::v3::View for deciding which vertex attributes are visible.
 ///
 /// @throw std::bad_alloc
 communication::bolt::Vertex ToBoltVertex(const storage::v3::VertexAccessor &vertex,
-                                         const msgs::ShardRequestManagerInterface *shard_request_manager,
+                                         const query::v2::RequestRouterInterface *request_router,
                                          storage::v3::View view);
 
 /// @param storage::v3::EdgeAccessor for converting to communication::bolt::Edge.
-/// @param msgs::ShardRequestManagerInterface *shard_request_manager getting edge type and property names.
+/// @param query::v2::RequestRouterInterface *request_router getting edge type and property names.
 /// @param storage::v3::View for deciding which edge attributes are visible.
 ///
 /// @throw std::bad_alloc
 communication::bolt::Edge ToBoltEdge(const storage::v3::EdgeAccessor &edge,
-                                     const msgs::ShardRequestManagerInterface *shard_request_manager,
-                                     storage::v3::View view);
+                                     const query::v2::RequestRouterInterface *request_router, storage::v3::View view);
 
 /// @param query::v2::Path for converting to communication::bolt::Path.
-/// @param msgs::ShardRequestManagerInterface *shard_request_manager ToBoltVertex and ToBoltEdge.
+/// @param query::v2::RequestRouterInterface *request_router ToBoltVertex and ToBoltEdge.
 /// @param storage::v3::View for ToBoltVertex and ToBoltEdge.
 ///
 /// @throw std::bad_alloc
 communication::bolt::Path ToBoltPath(const query::v2::accessors::Path &path,
-                                     const msgs::ShardRequestManagerInterface *shard_request_manager,
-                                     storage::v3::View view);
+                                     const query::v2::RequestRouterInterface *request_router, storage::v3::View view);
 
 /// @param query::v2::TypedValue for converting to communication::bolt::Value.
-/// @param msgs::ShardRequestManagerInterface *shard_request_manager ToBoltVertex and ToBoltEdge.
+/// @param query::v2::RequestRouterInterface *request_router ToBoltVertex and ToBoltEdge.
 /// @param storage::v3::View for ToBoltVertex and ToBoltEdge.
 ///
 /// @throw std::bad_alloc
 communication::bolt::Value ToBoltValue(const query::v2::TypedValue &value,
-                                       const msgs::ShardRequestManagerInterface *shard_request_manager,
-                                       storage::v3::View view);
+                                       const query::v2::RequestRouterInterface *request_router, storage::v3::View view);
 
 query::v2::TypedValue ToTypedValue(const communication::bolt::Value &value);
 
@@ -75,8 +72,7 @@ storage::v3::PropertyValue ToPropertyValue(const communication::bolt::Value &val
 
 communication::bolt::Value ToBoltValue(msgs::Value value);
 
-communication::bolt::Value ToBoltValue(msgs::Value value,
-                                       const msgs::ShardRequestManagerInterface *shard_request_manager,
+communication::bolt::Value ToBoltValue(msgs::Value value, const query::v2::RequestRouterInterface *request_router,
                                        storage::v3::View view);
 
 }  // namespace memgraph::glue::v2

src/io/rsm/rsm_client.hpp

@@ -14,6 +14,7 @@
 #include <iostream>
 #include <optional>
 #include <type_traits>
+#include <unordered_map>
 #include <vector>
 
 #include "io/address.hpp"
@@ -36,6 +37,21 @@ using memgraph::io::rsm::WriteRequest;
 using memgraph::io::rsm::WriteResponse;
 using memgraph::utils::BasicResult;
 
+class AsyncRequestToken {
+  size_t id_;
+
+ public:
+  explicit AsyncRequestToken(size_t id) : id_(id) {}
+  size_t GetId() const { return id_; }
+};
+
+template <typename RequestT, typename ResponseT>
+struct AsyncRequest {
+  Time start_time;
+  RequestT request;
+  ResponseFuture<ResponseT> future;
+};
+
 template <typename IoImpl, typename WriteRequestT, typename WriteResponseT, typename ReadRequestT,
           typename ReadResponseT>
 class RsmClient {
@@ -47,23 +63,17 @@ class RsmClient {
 
   /// State for single async read/write operations. In the future this could become a map
   /// of async operations that can be accessed via an ID etc...
-  std::optional<Time> async_read_before_;
-  std::optional<ResponseFuture<ReadResponse<ReadResponseT>>> async_read_;
-  ReadRequestT current_read_request_;
+  std::unordered_map<size_t, AsyncRequest<ReadRequestT, ReadResponse<ReadResponseT>>> async_reads_;
+  std::unordered_map<size_t, AsyncRequest<WriteRequestT, WriteResponse<WriteResponseT>>> async_writes_;
 
-  std::optional<Time> async_write_before_;
-  std::optional<ResponseFuture<WriteResponse<WriteResponseT>>> async_write_;
-  WriteRequestT current_write_request_;
+  size_t async_token_generator_ = 0;
 
   void SelectRandomLeader() {
     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());
+    spdlog::debug("selecting a random leader at index {} with address {}", addr_index, leader_.ToString());
   }
 
   template <typename ResponseT>
@@ -91,107 +101,74 @@ class RsmClient {
   ~RsmClient() = default;
 
   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{};
+    auto token = SendAsyncWriteRequest(req);
+    auto poll_result = AwaitAsyncWriteRequest(token);
+    while (!poll_result) {
+      poll_result = AwaitAsyncWriteRequest(token);
+    }
+    return poll_result.value();
   }
 
   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{};
+    auto token = SendAsyncReadRequest(req);
+    auto poll_result = AwaitAsyncReadRequest(token);
+    while (!poll_result) {
+      poll_result = AwaitAsyncReadRequest(token);
+    }
+    return poll_result.value();
   }
 
   /// AsyncRead methods
-  void SendAsyncReadRequest(const ReadRequestT &req) {
-    MG_ASSERT(!async_read_);
+  AsyncRequestToken SendAsyncReadRequest(const ReadRequestT &req) {
+    size_t token = async_token_generator_++;
 
     ReadRequest<ReadRequestT> read_req = {.operation = req};
 
-    if (!async_read_before_) {
-      async_read_before_ = io_.Now();
-    }
-    current_read_request_ = std::move(req);
-    async_read_ = io_.template Request<ReadRequest<ReadRequestT>, ReadResponse<ReadResponseT>>(leader_, read_req);
+    AsyncRequest<ReadRequestT, ReadResponse<ReadResponseT>> async_request{
+        .start_time = io_.Now(),
+        .request = std::move(req),
+        .future = io_.template Request<ReadRequest<ReadRequestT>, ReadResponse<ReadResponseT>>(leader_, read_req),
+    };
+
+    async_reads_.emplace(token, std::move(async_request));
+
+    return AsyncRequestToken{token};
   }
 
-  std::optional<BasicResult<TimedOut, ReadResponseT>> PollAsyncReadRequest() {
-    MG_ASSERT(async_read_);
+  void ResendAsyncReadRequest(const AsyncRequestToken &token) {
+    auto &async_request = async_reads_.at(token.GetId());
 
-    if (!async_read_->IsReady()) {
+    ReadRequest<ReadRequestT> read_req = {.operation = async_request.request};
+
+    async_request.future =
+        io_.template Request<ReadRequest<ReadRequestT>, ReadResponse<ReadResponseT>>(leader_, read_req);
+  }
+
+  std::optional<BasicResult<TimedOut, ReadResponseT>> PollAsyncReadRequest(const AsyncRequestToken &token) {
+    auto &async_request = async_reads_.at(token.GetId());
+
+    if (!async_request.future.IsReady()) {
       return std::nullopt;
     }
 
     return AwaitAsyncReadRequest();
   }
 
-  std::optional<BasicResult<TimedOut, ReadResponseT>> AwaitAsyncReadRequest() {
-    ResponseResult<ReadResponse<ReadResponseT>> get_response_result = std::move(*async_read_).Wait();
-    async_read_.reset();
+  std::optional<BasicResult<TimedOut, ReadResponseT>> AwaitAsyncReadRequest(const AsyncRequestToken &token) {
+    auto &async_request = async_reads_.at(token.GetId());
+    ResponseResult<ReadResponse<ReadResponseT>> get_response_result = std::move(async_request.future).Wait();
 
     const Duration overall_timeout = io_.GetDefaultTimeout();
-    const bool past_time_out = io_.Now() < *async_read_before_ + overall_timeout;
+    const bool past_time_out = io_.Now() > async_request.start_time + overall_timeout;
     const bool result_has_error = get_response_result.HasError();
 
     if (result_has_error && past_time_out) {
       // TODO static assert the exact type of error.
       spdlog::debug("client timed out while trying to communicate with leader server {}", leader_.ToString());
-      async_read_before_ = std::nullopt;
+      async_reads_.erase(token.GetId());
       return TimedOut{};
     }
+
     if (!result_has_error) {
       ResponseEnvelope<ReadResponse<ReadResponseT>> &&get_response_envelope = std::move(get_response_result.GetValue());
       ReadResponse<ReadResponseT> &&read_get_response = std::move(get_response_envelope.message);
@@ -199,54 +176,70 @@ class RsmClient {
       PossiblyRedirectLeader(read_get_response);
 
       if (read_get_response.success) {
-        async_read_before_ = std::nullopt;
+        async_reads_.erase(token.GetId());
+        spdlog::debug("returning read_return for RSM request");
         return std::move(read_get_response.read_return);
       }
-      SendAsyncReadRequest(current_read_request_);
-    } else if (result_has_error) {
+    } else {
       SelectRandomLeader();
-      SendAsyncReadRequest(current_read_request_);
     }
+
+    ResendAsyncReadRequest(token);
+
     return std::nullopt;
   }
 
   /// AsyncWrite methods
-  void SendAsyncWriteRequest(const WriteRequestT &req) {
-    MG_ASSERT(!async_write_);
+  AsyncRequestToken SendAsyncWriteRequest(const WriteRequestT &req) {
+    size_t token = async_token_generator_++;
 
     WriteRequest<WriteRequestT> write_req = {.operation = req};
 
-    if (!async_write_before_) {
-      async_write_before_ = io_.Now();
-    }
-    current_write_request_ = std::move(req);
-    async_write_ = io_.template Request<WriteRequest<WriteRequestT>, WriteResponse<WriteResponseT>>(leader_, write_req);
+    AsyncRequest<WriteRequestT, WriteResponse<WriteResponseT>> async_request{
+        .start_time = io_.Now(),
+        .request = std::move(req),
+        .future = io_.template Request<WriteRequest<WriteRequestT>, WriteResponse<WriteResponseT>>(leader_, write_req),
+    };
+
+    async_writes_.emplace(token, std::move(async_request));
+
+    return AsyncRequestToken{token};
   }
 
-  std::optional<BasicResult<TimedOut, WriteResponseT>> PollAsyncWriteRequest() {
-    MG_ASSERT(async_write_);
+  void ResendAsyncWriteRequest(const AsyncRequestToken &token) {
+    auto &async_request = async_writes_.at(token.GetId());
 
-    if (!async_write_->IsReady()) {
+    WriteRequest<WriteRequestT> write_req = {.operation = async_request.request};
+
+    async_request.future =
+        io_.template Request<WriteRequest<WriteRequestT>, WriteResponse<WriteResponseT>>(leader_, write_req);
+  }
+
+  std::optional<BasicResult<TimedOut, WriteResponseT>> PollAsyncWriteRequest(const AsyncRequestToken &token) {
+    auto &async_request = async_writes_.at(token.GetId());
+
+    if (!async_request.future.IsReady()) {
       return std::nullopt;
     }
 
     return AwaitAsyncWriteRequest();
   }
 
-  std::optional<BasicResult<TimedOut, WriteResponseT>> AwaitAsyncWriteRequest() {
-    ResponseResult<WriteResponse<WriteResponseT>> get_response_result = std::move(*async_write_).Wait();
-    async_write_.reset();
+  std::optional<BasicResult<TimedOut, WriteResponseT>> AwaitAsyncWriteRequest(const AsyncRequestToken &token) {
+    auto &async_request = async_writes_.at(token.GetId());
+    ResponseResult<WriteResponse<WriteResponseT>> get_response_result = std::move(async_request.future).Wait();
 
     const Duration overall_timeout = io_.GetDefaultTimeout();
-    const bool past_time_out = io_.Now() < *async_write_before_ + overall_timeout;
+    const bool past_time_out = io_.Now() > async_request.start_time + overall_timeout;
     const bool result_has_error = get_response_result.HasError();
 
     if (result_has_error && past_time_out) {
       // TODO static assert the exact type of error.
       spdlog::debug("client timed out while trying to communicate with leader server {}", leader_.ToString());
-      async_write_before_ = std::nullopt;
+      async_writes_.erase(token.GetId());
       return TimedOut{};
     }
+
     if (!result_has_error) {
       ResponseEnvelope<WriteResponse<WriteResponseT>> &&get_response_envelope =
           std::move(get_response_result.GetValue());
@@ -255,14 +248,15 @@ class RsmClient {
       PossiblyRedirectLeader(write_get_response);
 
       if (write_get_response.success) {
-        async_write_before_ = std::nullopt;
+        async_writes_.erase(token.GetId());
         return std::move(write_get_response.write_return);
       }
-      SendAsyncWriteRequest(current_write_request_);
-    } else if (result_has_error) {
+    } else {
       SelectRandomLeader();
-      SendAsyncWriteRequest(current_write_request_);
     }
+
+    ResendAsyncWriteRequest(token);
+
     return std::nullopt;
   }
 };

src/memgraph.cpp

@@ -454,7 +454,7 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
 
   std::map<std::string, memgraph::communication::bolt::Value> Pull(TEncoder *encoder, std::optional<int> n,
                                                                    std::optional<int> qid) override {
-    TypedValueResultStream stream(encoder, interpreter_.GetShardRequestManager());
+    TypedValueResultStream stream(encoder, interpreter_.GetRequestRouter());
     return PullResults(stream, n, qid);
   }
 
@@ -481,7 +481,7 @@ 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 bolt_value = memgraph::glue::v2::ToBoltValue(kv.second, interpreter_.GetShardRequestManager(),
+        auto bolt_value = memgraph::glue::v2::ToBoltValue(kv.second, interpreter_.GetRequestRouter(),
                                                           memgraph::storage::v3::View::NEW);
         decoded_summary.emplace(kv.first, std::move(bolt_value));
       }
@@ -497,14 +497,14 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
   /// before forwarding the calls to original TEncoder.
   class TypedValueResultStream {
    public:
-    TypedValueResultStream(TEncoder *encoder, const memgraph::msgs::ShardRequestManagerInterface *shard_request_manager)
-        : encoder_(encoder), shard_request_manager_(shard_request_manager) {}
+    TypedValueResultStream(TEncoder *encoder, const memgraph::query::v2::RequestRouterInterface *request_router)
+        : encoder_(encoder), request_router_(request_router) {}
 
     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 bolt_value = memgraph::glue::v2::ToBoltValue(v, shard_request_manager_, memgraph::storage::v3::View::NEW);
+        auto bolt_value = memgraph::glue::v2::ToBoltValue(v, request_router_, memgraph::storage::v3::View::NEW);
         decoded_values.emplace_back(std::move(bolt_value));
       }
       encoder_->MessageRecord(decoded_values);
@@ -512,7 +512,7 @@ class BoltSession final : public memgraph::communication::bolt::Session<memgraph
 
    private:
     TEncoder *encoder_;
-    const memgraph::msgs::ShardRequestManagerInterface *shard_request_manager_{nullptr};
+    const memgraph::query::v2::RequestRouterInterface *request_router_{nullptr};
   };
   memgraph::query::v2::Interpreter interpreter_;
   memgraph::communication::v2::ServerEndpoint endpoint_;

src/query/v2/CMakeLists.txt

@@ -11,7 +11,6 @@ set(mg_query_v2_sources
     cypher_query_interpreter.cpp
     frontend/semantic/required_privileges.cpp
     frontend/stripped.cpp
-    interpret/awesome_memgraph_functions.cpp
     interpreter.cpp
     metadata.cpp
     plan/operator.cpp
@@ -34,7 +33,7 @@ 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 mg-coordinator)
-target_link_libraries(mg-query-v2 mg-expr)
+target_link_libraries(mg-query-v2 mg-expr mg-functions)
 
 if(NOT "${MG_PYTHON_PATH}" STREQUAL "")
     set(Python3_ROOT_DIR "${MG_PYTHON_PATH}")

src/query/v2/accessors.cpp

@@ -10,24 +10,25 @@
 // licenses/APL.txt.
 
 #include "query/v2/accessors.hpp"
+#include "query/v2/request_router.hpp"
 #include "query/v2/requests.hpp"
-#include "query/v2/shard_request_manager.hpp"
 #include "storage/v3/id_types.hpp"
 
 namespace memgraph::query::v2::accessors {
-EdgeAccessor::EdgeAccessor(Edge edge, const msgs::ShardRequestManagerInterface *manager)
-    : edge(std::move(edge)), manager_(manager) {}
+EdgeAccessor::EdgeAccessor(Edge edge, const RequestRouterInterface *request_router)
+    : edge(std::move(edge)), request_router_(request_router) {}
 
 EdgeTypeId EdgeAccessor::EdgeType() const { return edge.type.id; }
 
 const std::vector<std::pair<PropertyId, Value>> &EdgeAccessor::Properties() const { return edge.properties; }
 
 Value EdgeAccessor::GetProperty(const std::string &prop_name) const {
-  auto prop_id = manager_->NameToProperty(prop_name);
-  auto it = std::find_if(edge.properties.begin(), edge.properties.end(), [&](auto &pr) { return prop_id == pr.first; });
-  if (it == edge.properties.end()) {
+  auto maybe_prop = request_router_->MaybeNameToProperty(prop_name);
+  if (!maybe_prop) {
     return {};
   }
+  const auto prop_id = *maybe_prop;
+  auto it = std::find_if(edge.properties.begin(), edge.properties.end(), [&](auto &pr) { return prop_id == pr.first; });
   return it->second;
 }
 
@@ -35,21 +36,23 @@ const Edge &EdgeAccessor::GetEdge() const { return edge; }
 
 bool EdgeAccessor::IsCycle() const { return edge.src == edge.dst; };
 
+size_t EdgeAccessor::CypherId() const { return edge.id.gid; }
+
 VertexAccessor EdgeAccessor::To() const {
-  return VertexAccessor(Vertex{edge.dst}, std::vector<std::pair<PropertyId, msgs::Value>>{}, manager_);
+  return VertexAccessor(Vertex{edge.dst}, std::vector<std::pair<PropertyId, msgs::Value>>{}, request_router_);
 }
 
 VertexAccessor EdgeAccessor::From() const {
-  return VertexAccessor(Vertex{edge.src}, std::vector<std::pair<PropertyId, msgs::Value>>{}, manager_);
+  return VertexAccessor(Vertex{edge.src}, std::vector<std::pair<PropertyId, msgs::Value>>{}, request_router_);
 }
 
 VertexAccessor::VertexAccessor(Vertex v, std::vector<std::pair<PropertyId, Value>> props,
-                               const msgs::ShardRequestManagerInterface *manager)
-    : vertex(std::move(v)), properties(std::move(props)), manager_(manager) {}
+                               const RequestRouterInterface *request_router)
+    : vertex(std::move(v)), properties(std::move(props)), request_router_(request_router) {}
 
 VertexAccessor::VertexAccessor(Vertex v, std::map<PropertyId, Value> &&props,
-                               const msgs::ShardRequestManagerInterface *manager)
-    : vertex(std::move(v)), manager_(manager) {
+                               const RequestRouterInterface *request_router)
+    : vertex(std::move(v)), request_router_(request_router) {
   properties.reserve(props.size());
   for (auto &[id, value] : props) {
     properties.emplace_back(std::make_pair(id, std::move(value)));
@@ -57,8 +60,8 @@ VertexAccessor::VertexAccessor(Vertex v, std::map<PropertyId, Value> &&props,
 }
 
 VertexAccessor::VertexAccessor(Vertex v, const std::map<PropertyId, Value> &props,
-                               const msgs::ShardRequestManagerInterface *manager)
-    : vertex(std::move(v)), manager_(manager) {
+                               const RequestRouterInterface *request_router)
+    : vertex(std::move(v)), request_router_(request_router) {
   properties.reserve(props.size());
   for (const auto &[id, value] : props) {
     properties.emplace_back(std::make_pair(id, value));
@@ -88,7 +91,11 @@ Value VertexAccessor::GetProperty(PropertyId prop_id) const {
 
 // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
 Value VertexAccessor::GetProperty(const std::string &prop_name) const {
-  return GetProperty(manager_->NameToProperty(prop_name));
+  auto maybe_prop = request_router_->MaybeNameToProperty(prop_name);
+  if (!maybe_prop) {
+    return {};
+  }
+  return GetProperty(*maybe_prop);
 }
 
 msgs::Vertex VertexAccessor::GetVertex() const { return vertex; }

src/query/v2/accessors.hpp

@@ -24,24 +24,24 @@
 #include "utils/memory.hpp"
 #include "utils/memory_tracker.hpp"
 
-namespace memgraph::msgs {
-class ShardRequestManagerInterface;
-}  // namespace memgraph::msgs
+namespace memgraph::query::v2 {
+class RequestRouterInterface;
+}  // namespace memgraph::query::v2
 
 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;
-using EdgeTypeId = memgraph::msgs::EdgeTypeId;
+using Value = msgs::Value;
+using Edge = msgs::Edge;
+using Vertex = msgs::Vertex;
+using Label = msgs::Label;
+using PropertyId = msgs::PropertyId;
+using EdgeTypeId = msgs::EdgeTypeId;
 
 class VertexAccessor;
 
 class EdgeAccessor final {
  public:
-  explicit EdgeAccessor(Edge edge, const msgs::ShardRequestManagerInterface *manager);
+  explicit EdgeAccessor(Edge edge, const RequestRouterInterface *request_router);
 
   [[nodiscard]] EdgeTypeId EdgeType() const;
 
@@ -53,12 +53,7 @@ class EdgeAccessor final {
 
   [[nodiscard]] bool IsCycle() const;
 
-  // Dummy function
-  // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
-  [[nodiscard]] size_t CypherId() const { return 10; }
-
-  //  bool HasSrcAccessor const { return src == nullptr; }
-  //  bool HasDstAccessor const { return dst == nullptr; }
+  [[nodiscard]] size_t CypherId() const;
 
   [[nodiscard]] VertexAccessor To() const;
   [[nodiscard]] VertexAccessor From() const;
@@ -69,7 +64,7 @@ class EdgeAccessor final {
 
  private:
   Edge edge;
-  const msgs::ShardRequestManagerInterface *manager_;
+  const RequestRouterInterface *request_router_;
 };
 
 class VertexAccessor final {
@@ -78,10 +73,10 @@ class VertexAccessor final {
   using Label = msgs::Label;
   using VertexId = msgs::VertexId;
   VertexAccessor(Vertex v, std::vector<std::pair<PropertyId, Value>> props,
-                 const msgs::ShardRequestManagerInterface *manager);
+                 const RequestRouterInterface *request_router);
 
-  VertexAccessor(Vertex v, std::map<PropertyId, Value> &&props, const msgs::ShardRequestManagerInterface *manager);
-  VertexAccessor(Vertex v, const std::map<PropertyId, Value> &props, const msgs::ShardRequestManagerInterface *manager);
+  VertexAccessor(Vertex v, std::map<PropertyId, Value> &&props, const RequestRouterInterface *request_router);
+  VertexAccessor(Vertex v, const std::map<PropertyId, Value> &props, const RequestRouterInterface *request_router);
 
   [[nodiscard]] Label PrimaryLabel() const;
 
@@ -98,48 +93,11 @@ class VertexAccessor final {
 
   [[nodiscard]] msgs::Vertex GetVertex() const;
 
-  // Dummy function
   // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
-  [[nodiscard]] size_t CypherId() const { return 10; }
+  [[nodiscard]] size_t InDegree() const { throw utils::NotYetImplemented("InDegree() not yet implemented"); }
 
-  //  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); }
-  //
+  // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
+  [[nodiscard]] size_t OutDegree() const { throw utils::NotYetImplemented("OutDegree() not yet implemented"); }
 
   friend bool operator==(const VertexAccessor &lhs, const VertexAccessor &rhs) {
     return lhs.vertex == rhs.vertex && lhs.properties == rhs.properties;
@@ -150,13 +108,9 @@ class VertexAccessor final {
  private:
   Vertex vertex;
   std::vector<std::pair<PropertyId, Value>> properties;
-  const msgs::ShardRequestManagerInterface *manager_;
+  const RequestRouterInterface *request_router_;
 };
 
-// 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:
@@ -197,7 +151,14 @@ class Path {
   friend bool operator==(const Path & /*lhs*/, const Path & /*rhs*/) { return true; };
   utils::MemoryResource *GetMemoryResource() { return mem; }
 
+  auto &vertices() { return vertices_; }
+  auto &edges() { return edges_; }
+  const auto &vertices() const { return vertices_; }
+  const auto &edges() const { return edges_; }
+
  private:
+  std::vector<VertexAccessor> vertices_;
+  std::vector<EdgeAccessor> edges_;
   utils::MemoryResource *mem = utils::NewDeleteResource();
 };
 }  // namespace memgraph::query::v2::accessors

src/query/v2/bindings/eval.hpp

@@ -24,27 +24,24 @@
 #include "storage/v3/result.hpp"
 #include "storage/v3/view.hpp"
 
-namespace memgraph::msgs {
-class ShardRequestManagerInterface;
-}  // namespace memgraph::msgs
-
 namespace memgraph::query::v2 {
 
-inline const auto lam = [](const auto &val) { return ValueToTypedValue(val); };
+class RequestRouterInterface;
+
 namespace detail {
 class Callable {
  public:
-  auto operator()(const memgraph::storage::v3::PropertyValue &val) const {
-    return memgraph::storage::v3::PropertyToTypedValue<TypedValue>(val);
+  auto operator()(const storage::v3::PropertyValue &val) const {
+    return storage::v3::PropertyToTypedValue<TypedValue>(val);
   };
-  auto operator()(const msgs::Value &val, memgraph::msgs::ShardRequestManagerInterface *manager) const {
-    return ValueToTypedValue(val, manager);
+  auto operator()(const msgs::Value &val, RequestRouterInterface *request_router) const {
+    return ValueToTypedValue(val, request_router);
   };
 };
 
 }  // namespace detail
-using ExpressionEvaluator = memgraph::expr::ExpressionEvaluator<
-    TypedValue, memgraph::query::v2::EvaluationContext, memgraph::msgs::ShardRequestManagerInterface, storage::v3::View,
-    storage::v3::LabelId, msgs::Value, detail::Callable, common::ErrorCode, memgraph::expr::QueryEngineTag>;
+using ExpressionEvaluator = expr::ExpressionEvaluator<TypedValue, query::v2::EvaluationContext, RequestRouterInterface,
+                                                      storage::v3::View, storage::v3::LabelId, msgs::Value,
+                                                      detail::Callable, common::ErrorCode, expr::QueryEngineTag>;
 
 }  // namespace memgraph::query::v2

src/query/v2/context.hpp

@@ -20,7 +20,7 @@
 #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/request_router.hpp"
 #include "utils/async_timer.hpp"
 
 namespace memgraph::query::v2 {
@@ -60,27 +60,27 @@ struct EvaluationContext {
   mutable std::unordered_map<std::string, int64_t> counters;
 };
 
-inline std::vector<storage::v3::PropertyId> NamesToProperties(
-    const std::vector<std::string> &property_names, msgs::ShardRequestManagerInterface *shard_request_manager) {
+inline std::vector<storage::v3::PropertyId> NamesToProperties(const std::vector<std::string> &property_names,
+                                                              RequestRouterInterface *request_router) {
   std::vector<storage::v3::PropertyId> properties;
   // TODO Fix by using reference
   properties.reserve(property_names.size());
-  if (shard_request_manager != nullptr) {
+  if (request_router != nullptr) {
     for (const auto &name : property_names) {
-      properties.push_back(shard_request_manager->NameToProperty(name));
+      properties.push_back(request_router->NameToProperty(name));
     }
   }
   return properties;
 }
 
 inline std::vector<storage::v3::LabelId> NamesToLabels(const std::vector<std::string> &label_names,
-                                                       msgs::ShardRequestManagerInterface *shard_request_manager) {
+                                                       RequestRouterInterface *request_router) {
   std::vector<storage::v3::LabelId> labels;
   labels.reserve(label_names.size());
   // TODO Fix by using reference
-  if (shard_request_manager != nullptr) {
+  if (request_router != nullptr) {
     for (const auto &name : label_names) {
-      labels.push_back(shard_request_manager->NameToLabel(name));
+      labels.push_back(request_router->NameToLabel(name));
     }
   }
   return labels;
@@ -97,7 +97,7 @@ struct ExecutionContext {
   plan::ProfilingStats *stats_root{nullptr};
   ExecutionStats execution_stats;
   utils::AsyncTimer timer;
-  msgs::ShardRequestManagerInterface *shard_request_manager{nullptr};
+  RequestRouterInterface *request_router{nullptr};
   IdAllocator *edge_ids_alloc;
 };
 

src/query/v2/conversions.hpp

@@ -12,12 +12,12 @@
 #pragma once
 #include "bindings/typed_value.hpp"
 #include "query/v2/accessors.hpp"
+#include "query/v2/request_router.hpp"
 #include "query/v2/requests.hpp"
-#include "query/v2/shard_request_manager.hpp"
 
 namespace memgraph::query::v2 {
 
-inline TypedValue ValueToTypedValue(const msgs::Value &value, msgs::ShardRequestManagerInterface *manager) {
+inline TypedValue ValueToTypedValue(const msgs::Value &value, RequestRouterInterface *request_router) {
   using Value = msgs::Value;
   switch (value.type) {
     case Value::Type::Null:
@@ -35,7 +35,7 @@ inline TypedValue ValueToTypedValue(const msgs::Value &value, msgs::ShardRequest
       std::vector<TypedValue> dst;
       dst.reserve(lst.size());
       for (const auto &elem : lst) {
-        dst.push_back(ValueToTypedValue(elem, manager));
+        dst.push_back(ValueToTypedValue(elem, request_router));
       }
       return TypedValue(std::move(dst));
     }
@@ -43,19 +43,23 @@ inline TypedValue ValueToTypedValue(const msgs::Value &value, msgs::ShardRequest
       const auto &value_map = value.map_v;
       std::map<std::string, TypedValue> dst;
       for (const auto &[key, val] : value_map) {
-        dst[key] = ValueToTypedValue(val, manager);
+        dst[key] = ValueToTypedValue(val, request_router);
       }
       return TypedValue(std::move(dst));
     }
     case Value::Type::Vertex:
       return TypedValue(accessors::VertexAccessor(
-          value.vertex_v, std::vector<std::pair<storage::v3::PropertyId, msgs::Value>>{}, manager));
+          value.vertex_v, std::vector<std::pair<storage::v3::PropertyId, msgs::Value>>{}, request_router));
     case Value::Type::Edge:
-      return TypedValue(accessors::EdgeAccessor(value.edge_v, manager));
+      return TypedValue(accessors::EdgeAccessor(value.edge_v, request_router));
   }
   throw std::runtime_error("Incorrect type in conversion");
 }
 
+inline const auto ValueToTypedValueFunctor = [](const msgs::Value &value, RequestRouterInterface *request_router) {
+  return ValueToTypedValue(value, request_router);
+};
+
 inline msgs::Value TypedValueToValue(const TypedValue &value) {
   using Value = msgs::Value;
   switch (value.type()) {

src/query/v2/cypher_query_interpreter.cpp

@@ -11,7 +11,7 @@
 
 #include "query/v2/cypher_query_interpreter.hpp"
 #include "query/v2/bindings/symbol_generator.hpp"
-#include "query/v2/shard_request_manager.hpp"
+#include "query/v2/request_router.hpp"
 
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
 DEFINE_HIDDEN_bool(query_cost_planner, true, "Use the cost-estimating query planner.");
@@ -118,9 +118,9 @@ ParsedQuery ParseQuery(const std::string &query_string, const std::map<std::stri
 }
 
 std::unique_ptr<LogicalPlan> MakeLogicalPlan(AstStorage ast_storage, CypherQuery *query, const Parameters &parameters,
-                                             msgs::ShardRequestManagerInterface *shard_manager,
+                                             RequestRouterInterface *request_router,
                                              const std::vector<Identifier *> &predefined_identifiers) {
-  auto vertex_counts = plan::MakeVertexCountCache(shard_manager);
+  auto vertex_counts = plan::MakeVertexCountCache(request_router);
   auto symbol_table = expr::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);
@@ -130,7 +130,7 @@ std::unique_ptr<LogicalPlan> MakeLogicalPlan(AstStorage ast_storage, CypherQuery
 
 std::shared_ptr<CachedPlan> CypherQueryToPlan(uint64_t hash, AstStorage ast_storage, CypherQuery *query,
                                               const Parameters &parameters, utils::SkipList<PlanCacheEntry> *plan_cache,
-                                              msgs::ShardRequestManagerInterface *shard_manager,
+                                              RequestRouterInterface *request_router,
                                               const std::vector<Identifier *> &predefined_identifiers) {
   std::optional<utils::SkipList<PlanCacheEntry>::Accessor> plan_cache_access;
   if (plan_cache) {
@@ -146,7 +146,7 @@ std::shared_ptr<CachedPlan> CypherQueryToPlan(uint64_t hash, AstStorage ast_stor
   }
 
   auto plan = std::make_shared<CachedPlan>(
-      MakeLogicalPlan(std::move(ast_storage), query, parameters, shard_manager, predefined_identifiers));
+      MakeLogicalPlan(std::move(ast_storage), query, parameters, request_router, predefined_identifiers));
   if (plan_cache_access) {
     plan_cache_access->insert({hash, plan});
   }

src/query/v2/cypher_query_interpreter.hpp

@@ -132,7 +132,7 @@ class SingleNodeLogicalPlan final : public LogicalPlan {
 };
 
 std::unique_ptr<LogicalPlan> MakeLogicalPlan(AstStorage ast_storage, CypherQuery *query, const Parameters &parameters,
-                                             msgs::ShardRequestManagerInterface *shard_manager,
+                                             RequestRouterInterface *request_router,
                                              const std::vector<Identifier *> &predefined_identifiers);
 
 /**
@@ -145,7 +145,7 @@ std::unique_ptr<LogicalPlan> MakeLogicalPlan(AstStorage ast_storage, CypherQuery
  */
 std::shared_ptr<CachedPlan> CypherQueryToPlan(uint64_t hash, AstStorage ast_storage, CypherQuery *query,
                                               const Parameters &parameters, utils::SkipList<PlanCacheEntry> *plan_cache,
-                                              msgs::ShardRequestManagerInterface *shard_manager,
+                                              RequestRouterInterface *request_router,
                                               const std::vector<Identifier *> &predefined_identifiers = {});
 
 }  // namespace memgraph::query::v2

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

@@ -20,11 +20,13 @@
 #include "query/v2/bindings/ast_visitor.hpp"
 #include "common/types.hpp"
 #include "query/v2/bindings/symbol.hpp"
-#include "query/v2/interpret/awesome_memgraph_functions.hpp"
+#include "functions/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/request_router.hpp"
 #include "utils/typeinfo.hpp"
+#include "query/v2/conversions.hpp"
 
 cpp<#
 
@@ -836,13 +838,15 @@ cpp<#
               :slk-load (slk-load-ast-vector "Expression"))
    (function-name "std::string" :scope :public)
    (function "std::function<TypedValue(const TypedValue *, int64_t,
-                                       const FunctionContext &)>"
+                                       const functions::FunctionContext<RequestRouterInterface> &)>"
              :scope :public
              :dont-save t
              :clone :copy
              :slk-load (lambda (member)
                         #>cpp
-                        self->${member} = query::v2::NameToFunction(self->function_name_);
+                        self->${member} = functions::NameToFunction<TypedValue,
+                                            functions::FunctionContext<RequestRouterInterface>,
+                                            functions::QueryEngineTag, decltype(ValueToTypedValueFunctor)>(self->function_name_);
                         cpp<#)))
   (:public
     #>cpp
@@ -865,7 +869,8 @@ cpp<#
              const std::vector<Expression *> &arguments)
         : arguments_(arguments),
           function_name_(function_name),
-          function_(NameToFunction(function_name_)) {
+          function_(functions::NameToFunction<TypedValue, functions::FunctionContext<RequestRouterInterface>,
+                                              functions::QueryEngineTag, decltype(ValueToTypedValueFunctor)>(function_name_)) {
       if (!function_) {
         throw SemanticException("Function '{}' doesn't exist.", function_name);
       }

src/query/v2/interpret/awesome_memgraph_functions.hpp

@@ -20,12 +20,10 @@
 #include "storage/v3/view.hpp"
 #include "utils/memory.hpp"
 
-namespace memgraph::msgs {
-class ShardRequestManagerInterface;
-} // namespace memgraph::msgs
-
 namespace memgraph::query::v2 {
 
+class RequestRouterInterface;
+
 namespace {
 const char kStartsWith[] = "STARTSWITH";
 const char kEndsWith[] = "ENDSWITH";
@@ -34,9 +32,9 @@ const char kId[] = "ID";
 }  // namespace
 
 struct FunctionContext {
-  // TODO(kostasrim) consider optional here. ShardRequestManager does not exist on the storage.
+  // TODO(kostasrim) consider optional here. RequestRouter does not exist on the storage.
   // DbAccessor *db_accessor;
-  msgs::ShardRequestManagerInterface *manager;
+  RequestRouterInterface *request_router;
   utils::MemoryResource *memory;
   int64_t timestamp;
   std::unordered_map<std::string, int64_t> *counters;

src/query/v2/interpreter.cpp

@@ -44,7 +44,7 @@
 #include "query/v2/plan/planner.hpp"
 #include "query/v2/plan/profile.hpp"
 #include "query/v2/plan/vertex_count_cache.hpp"
-#include "query/v2/shard_request_manager.hpp"
+#include "query/v2/request_router.hpp"
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/shard.hpp"
 #include "utils/algorithm.hpp"
@@ -143,7 +143,7 @@ class ReplQueryHandler final : public query::v2::ReplicationQueryHandler {
 /// @throw QueryRuntimeException if an error ocurred.
 
 Callback HandleAuthQuery(AuthQuery *auth_query, AuthQueryHandler *auth, const Parameters &parameters,
-                         msgs::ShardRequestManagerInterface *manager) {
+                         RequestRouterInterface *request_router) {
   // Empty frame for evaluation of password expression. This is OK since
   // password should be either null or string literal and it's evaluation
   // should not depend on frame.
@@ -154,7 +154,7 @@ Callback HandleAuthQuery(AuthQuery *auth_query, AuthQueryHandler *auth, const Pa
   // the argument to Callback.
   evaluation_context.timestamp = QueryTimestamp();
   evaluation_context.parameters = parameters;
-  ExpressionEvaluator evaluator(&frame, symbol_table, evaluation_context, manager, storage::v3::View::OLD);
+  ExpressionEvaluator evaluator(&frame, symbol_table, evaluation_context, request_router, storage::v3::View::OLD);
 
   std::string username = auth_query->user_;
   std::string rolename = auth_query->role_;
@@ -312,7 +312,7 @@ Callback HandleAuthQuery(AuthQuery *auth_query, AuthQueryHandler *auth, const Pa
 }
 
 Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &parameters,
-                                InterpreterContext *interpreter_context, msgs::ShardRequestManagerInterface *manager,
+                                InterpreterContext *interpreter_context, RequestRouterInterface *request_router,
                                 std::vector<Notification> *notifications) {
   expr::Frame<TypedValue> frame(0);
   SymbolTable symbol_table;
@@ -321,7 +321,7 @@ Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &
   // the argument to Callback.
   evaluation_context.timestamp = QueryTimestamp();
   evaluation_context.parameters = parameters;
-  ExpressionEvaluator evaluator(&frame, symbol_table, evaluation_context, manager, storage::v3::View::OLD);
+  ExpressionEvaluator evaluator(&frame, symbol_table, evaluation_context, request_router, storage::v3::View::OLD);
 
   Callback callback;
   switch (repl_query->action_) {
@@ -448,7 +448,7 @@ Callback HandleReplicationQuery(ReplicationQuery *repl_query, const Parameters &
 }
 
 Callback HandleSettingQuery(SettingQuery *setting_query, const Parameters &parameters,
-                            msgs::ShardRequestManagerInterface *manager) {
+                            RequestRouterInterface *request_router) {
   expr::Frame<TypedValue> frame(0);
   SymbolTable symbol_table;
   EvaluationContext evaluation_context;
@@ -458,7 +458,7 @@ Callback HandleSettingQuery(SettingQuery *setting_query, const Parameters &param
       std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
           .count();
   evaluation_context.parameters = parameters;
-  ExpressionEvaluator evaluator(&frame, symbol_table, evaluation_context, manager, storage::v3::View::OLD);
+  ExpressionEvaluator evaluator(&frame, symbol_table, evaluation_context, request_router, storage::v3::View::OLD);
 
   Callback callback;
   switch (setting_query->action_) {
@@ -649,7 +649,7 @@ struct PullPlanVector {
 struct PullPlan {
   explicit PullPlan(std::shared_ptr<CachedPlan> plan, const Parameters &parameters, bool is_profile_query,
                     DbAccessor *dba, InterpreterContext *interpreter_context, utils::MemoryResource *execution_memory,
-                    msgs::ShardRequestManagerInterface *shard_request_manager = nullptr,
+                    RequestRouterInterface *request_router = nullptr,
                     //                    TriggerContextCollector *trigger_context_collector = nullptr,
                     std::optional<size_t> memory_limit = {});
   std::optional<plan::ProfilingStatsWithTotalTime> Pull(AnyStream *stream, std::optional<int> n,
@@ -679,7 +679,7 @@ struct PullPlan {
 
 PullPlan::PullPlan(const std::shared_ptr<CachedPlan> plan, const Parameters &parameters, const bool is_profile_query,
                    DbAccessor *dba, InterpreterContext *interpreter_context, utils::MemoryResource *execution_memory,
-                   msgs::ShardRequestManagerInterface *shard_request_manager, const std::optional<size_t> memory_limit)
+                   RequestRouterInterface *request_router, const std::optional<size_t> memory_limit)
     : plan_(plan),
       cursor_(plan->plan().MakeCursor(execution_memory)),
       frame_(plan->symbol_table().max_position(), execution_memory),
@@ -688,14 +688,14 @@ PullPlan::PullPlan(const std::shared_ptr<CachedPlan> plan, const Parameters &par
   ctx_.symbol_table = plan->symbol_table();
   ctx_.evaluation_context.timestamp = QueryTimestamp();
   ctx_.evaluation_context.parameters = parameters;
-  ctx_.evaluation_context.properties = NamesToProperties(plan->ast_storage().properties_, shard_request_manager);
-  ctx_.evaluation_context.labels = NamesToLabels(plan->ast_storage().labels_, shard_request_manager);
+  ctx_.evaluation_context.properties = NamesToProperties(plan->ast_storage().properties_, request_router);
+  ctx_.evaluation_context.labels = NamesToLabels(plan->ast_storage().labels_, request_router);
   if (interpreter_context->config.execution_timeout_sec > 0) {
     ctx_.timer = utils::AsyncTimer{interpreter_context->config.execution_timeout_sec};
   }
   ctx_.is_shutting_down = &interpreter_context->is_shutting_down;
   ctx_.is_profile_query = is_profile_query;
-  ctx_.shard_request_manager = shard_request_manager;
+  ctx_.request_router = request_router;
   ctx_.edge_ids_alloc = &interpreter_context->edge_ids_alloc;
 }
 
@@ -804,7 +804,7 @@ Interpreter::Interpreter(InterpreterContext *interpreter_context) : interpreter_
   auto random_uuid = boost::uuids::uuid{boost::uuids::random_generator()()};
   auto query_io = interpreter_context_->io.ForkLocal(random_uuid);
 
-  shard_request_manager_ = std::make_unique<msgs::ShardRequestManager<io::local_transport::LocalTransport>>(
+  request_router_ = std::make_unique<RequestRouter<io::local_transport::LocalTransport>>(
       coordinator::CoordinatorClient<io::local_transport::LocalTransport>(
           query_io, interpreter_context_->coordinator_address, std::vector{interpreter_context_->coordinator_address}),
       std::move(query_io));
@@ -881,7 +881,7 @@ PreparedQuery Interpreter::PrepareTransactionQuery(std::string_view query_upper)
 PreparedQuery PrepareCypherQuery(ParsedQuery parsed_query, std::map<std::string, TypedValue> *summary,
                                  InterpreterContext *interpreter_context, DbAccessor *dba,
                                  utils::MemoryResource *execution_memory, std::vector<Notification> *notifications,
-                                 msgs::ShardRequestManagerInterface *shard_request_manager) {
+                                 RequestRouterInterface *request_router) {
   //                                 TriggerContextCollector *trigger_context_collector = nullptr) {
   auto *cypher_query = utils::Downcast<CypherQuery>(parsed_query.query);
 
@@ -890,8 +890,7 @@ PreparedQuery PrepareCypherQuery(ParsedQuery parsed_query, std::map<std::string,
   EvaluationContext evaluation_context;
   evaluation_context.timestamp = QueryTimestamp();
   evaluation_context.parameters = parsed_query.parameters;
-  ExpressionEvaluator evaluator(&frame, symbol_table, evaluation_context, shard_request_manager,
-                                storage::v3::View::OLD);
+  ExpressionEvaluator evaluator(&frame, symbol_table, evaluation_context, request_router, storage::v3::View::OLD);
   const auto memory_limit =
       expr::EvaluateMemoryLimit(&evaluator, cypher_query->memory_limit_, cypher_query->memory_scale_);
   if (memory_limit) {
@@ -906,9 +905,9 @@ PreparedQuery PrepareCypherQuery(ParsedQuery parsed_query, std::map<std::string,
         "convert the parsed row values to the appropriate type. This can be done using the built-in "
         "conversion functions such as ToInteger, ToFloat, ToBoolean etc.");
   }
-  auto plan = CypherQueryToPlan(
-      parsed_query.stripped_query.hash(), std::move(parsed_query.ast_storage), cypher_query, parsed_query.parameters,
-      parsed_query.is_cacheable ? &interpreter_context->plan_cache : nullptr, shard_request_manager);
+  auto plan = CypherQueryToPlan(parsed_query.stripped_query.hash(), std::move(parsed_query.ast_storage), cypher_query,
+                                parsed_query.parameters,
+                                parsed_query.is_cacheable ? &interpreter_context->plan_cache : nullptr, request_router);
 
   summary->insert_or_assign("cost_estimate", plan->cost());
   auto rw_type_checker = plan::ReadWriteTypeChecker();
@@ -927,7 +926,7 @@ PreparedQuery PrepareCypherQuery(ParsedQuery parsed_query, std::map<std::string,
         utils::FindOr(parsed_query.stripped_query.named_expressions(), symbol.token_position(), symbol.name()).first);
   }
   auto pull_plan = std::make_shared<PullPlan>(plan, parsed_query.parameters, false, dba, interpreter_context,
-                                              execution_memory, shard_request_manager, memory_limit);
+                                              execution_memory, request_router, memory_limit);
   //                                              execution_memory, trigger_context_collector, memory_limit);
   return PreparedQuery{std::move(header), std::move(parsed_query.required_privileges),
                        [pull_plan = std::move(pull_plan), output_symbols = std::move(output_symbols), summary](
@@ -941,8 +940,7 @@ PreparedQuery PrepareCypherQuery(ParsedQuery parsed_query, std::map<std::string,
 }
 
 PreparedQuery PrepareExplainQuery(ParsedQuery parsed_query, std::map<std::string, TypedValue> *summary,
-                                  InterpreterContext *interpreter_context,
-                                  msgs::ShardRequestManagerInterface *shard_request_manager,
+                                  InterpreterContext *interpreter_context, RequestRouterInterface *request_router,
                                   utils::MemoryResource *execution_memory) {
   const std::string kExplainQueryStart = "explain ";
   MG_ASSERT(utils::StartsWith(utils::ToLowerCase(parsed_query.stripped_query.query()), kExplainQueryStart),
@@ -961,20 +959,20 @@ PreparedQuery PrepareExplainQuery(ParsedQuery parsed_query, std::map<std::string
   auto *cypher_query = utils::Downcast<CypherQuery>(parsed_inner_query.query);
   MG_ASSERT(cypher_query, "Cypher grammar should not allow other queries in EXPLAIN");
 
-  auto cypher_query_plan = CypherQueryToPlan(
-      parsed_inner_query.stripped_query.hash(), std::move(parsed_inner_query.ast_storage), cypher_query,
-      parsed_inner_query.parameters, parsed_inner_query.is_cacheable ? &interpreter_context->plan_cache : nullptr,
-      shard_request_manager);
+  auto cypher_query_plan =
+      CypherQueryToPlan(parsed_inner_query.stripped_query.hash(), std::move(parsed_inner_query.ast_storage),
+                        cypher_query, parsed_inner_query.parameters,
+                        parsed_inner_query.is_cacheable ? &interpreter_context->plan_cache : nullptr, request_router);
 
   std::stringstream printed_plan;
-  plan::PrettyPrint(*shard_request_manager, &cypher_query_plan->plan(), &printed_plan);
+  plan::PrettyPrint(*request_router, &cypher_query_plan->plan(), &printed_plan);
 
   std::vector<std::vector<TypedValue>> printed_plan_rows;
   for (const auto &row : utils::Split(utils::RTrim(printed_plan.str()), "\n")) {
     printed_plan_rows.push_back(std::vector<TypedValue>{TypedValue(row)});
   }
 
-  summary->insert_or_assign("explain", plan::PlanToJson(*shard_request_manager, &cypher_query_plan->plan()).dump());
+  summary->insert_or_assign("explain", plan::PlanToJson(*request_router, &cypher_query_plan->plan()).dump());
 
   return PreparedQuery{{"QUERY PLAN"},
                        std::move(parsed_query.required_privileges),
@@ -991,7 +989,7 @@ PreparedQuery PrepareExplainQuery(ParsedQuery parsed_query, std::map<std::string
 PreparedQuery PrepareProfileQuery(ParsedQuery parsed_query, bool in_explicit_transaction,
                                   std::map<std::string, TypedValue> *summary, InterpreterContext *interpreter_context,
                                   DbAccessor *dba, utils::MemoryResource *execution_memory,
-                                  msgs::ShardRequestManagerInterface *shard_request_manager = nullptr) {
+                                  RequestRouterInterface *request_router = nullptr) {
   const std::string kProfileQueryStart = "profile ";
 
   MG_ASSERT(utils::StartsWith(utils::ToLowerCase(parsed_query.stripped_query.query()), kProfileQueryStart),
@@ -1034,22 +1032,21 @@ PreparedQuery PrepareProfileQuery(ParsedQuery parsed_query, bool in_explicit_tra
   EvaluationContext evaluation_context;
   evaluation_context.timestamp = QueryTimestamp();
   evaluation_context.parameters = parsed_inner_query.parameters;
-  ExpressionEvaluator evaluator(&frame, symbol_table, evaluation_context, shard_request_manager,
-                                storage::v3::View::OLD);
+  ExpressionEvaluator evaluator(&frame, symbol_table, evaluation_context, request_router, storage::v3::View::OLD);
   const auto memory_limit =
       expr::EvaluateMemoryLimit(&evaluator, cypher_query->memory_limit_, cypher_query->memory_scale_);
 
-  auto cypher_query_plan = CypherQueryToPlan(
-      parsed_inner_query.stripped_query.hash(), std::move(parsed_inner_query.ast_storage), cypher_query,
-      parsed_inner_query.parameters, parsed_inner_query.is_cacheable ? &interpreter_context->plan_cache : nullptr,
-      shard_request_manager);
+  auto cypher_query_plan =
+      CypherQueryToPlan(parsed_inner_query.stripped_query.hash(), std::move(parsed_inner_query.ast_storage),
+                        cypher_query, parsed_inner_query.parameters,
+                        parsed_inner_query.is_cacheable ? &interpreter_context->plan_cache : nullptr, request_router);
   auto rw_type_checker = plan::ReadWriteTypeChecker();
   rw_type_checker.InferRWType(const_cast<plan::LogicalOperator &>(cypher_query_plan->plan()));
 
   return PreparedQuery{{"OPERATOR", "ACTUAL HITS", "RELATIVE TIME", "ABSOLUTE TIME", "CUSTOM DATA"},
                        std::move(parsed_query.required_privileges),
                        [plan = std::move(cypher_query_plan), parameters = std::move(parsed_inner_query.parameters),
-                        summary, dba, interpreter_context, execution_memory, memory_limit, shard_request_manager,
+                        summary, dba, interpreter_context, execution_memory, memory_limit, request_router,
                         // We want to execute the query we are profiling lazily, so we delay
                         // the construction of the corresponding context.
                         stats_and_total_time = std::optional<plan::ProfilingStatsWithTotalTime>{},
@@ -1058,7 +1055,7 @@ PreparedQuery PrepareProfileQuery(ParsedQuery parsed_query, bool in_explicit_tra
                          // No output symbols are given so that nothing is streamed.
                          if (!stats_and_total_time) {
                            stats_and_total_time = PullPlan(plan, parameters, true, dba, interpreter_context,
-                                                           execution_memory, shard_request_manager, memory_limit)
+                                                           execution_memory, request_router, memory_limit)
                                                       .Pull(stream, {}, {}, summary);
                            pull_plan = std::make_shared<PullPlanVector>(ProfilingStatsToTable(*stats_and_total_time));
                          }
@@ -1185,14 +1182,14 @@ PreparedQuery PrepareIndexQuery(ParsedQuery parsed_query, bool in_explicit_trans
 PreparedQuery PrepareAuthQuery(ParsedQuery parsed_query, bool in_explicit_transaction,
                                std::map<std::string, TypedValue> *summary, InterpreterContext *interpreter_context,
                                DbAccessor *dba, utils::MemoryResource *execution_memory,
-                               msgs::ShardRequestManagerInterface *manager) {
+                               RequestRouterInterface *request_router) {
   if (in_explicit_transaction) {
     throw UserModificationInMulticommandTxException();
   }
 
   auto *auth_query = utils::Downcast<AuthQuery>(parsed_query.query);
 
-  auto callback = HandleAuthQuery(auth_query, interpreter_context->auth, parsed_query.parameters, manager);
+  auto callback = HandleAuthQuery(auth_query, interpreter_context->auth, parsed_query.parameters, request_router);
 
   SymbolTable symbol_table;
   std::vector<Symbol> output_symbols;
@@ -1221,14 +1218,14 @@ PreparedQuery PrepareAuthQuery(ParsedQuery parsed_query, bool in_explicit_transa
 
 PreparedQuery PrepareReplicationQuery(ParsedQuery parsed_query, const bool in_explicit_transaction,
                                       std::vector<Notification> *notifications, InterpreterContext *interpreter_context,
-                                      msgs::ShardRequestManagerInterface *manager) {
+                                      RequestRouterInterface *request_router) {
   if (in_explicit_transaction) {
     throw ReplicationModificationInMulticommandTxException();
   }
 
   auto *replication_query = utils::Downcast<ReplicationQuery>(parsed_query.query);
-  auto callback =
-      HandleReplicationQuery(replication_query, parsed_query.parameters, interpreter_context, manager, notifications);
+  auto callback = HandleReplicationQuery(replication_query, parsed_query.parameters, interpreter_context,
+                                         request_router, notifications);
 
   return PreparedQuery{callback.header, std::move(parsed_query.required_privileges),
                        [callback_fn = std::move(callback.fn), pull_plan = std::shared_ptr<PullPlanVector>{nullptr}](
@@ -1317,14 +1314,14 @@ PreparedQuery PrepareCreateSnapshotQuery(ParsedQuery parsed_query, bool in_expli
 }
 
 PreparedQuery PrepareSettingQuery(ParsedQuery parsed_query, const bool in_explicit_transaction,
-                                  msgs::ShardRequestManagerInterface *manager) {
+                                  RequestRouterInterface *request_router) {
   if (in_explicit_transaction) {
     throw SettingConfigInMulticommandTxException{};
   }
 
   auto *setting_query = utils::Downcast<SettingQuery>(parsed_query.query);
   MG_ASSERT(setting_query);
-  auto callback = HandleSettingQuery(setting_query, parsed_query.parameters, manager);
+  auto callback = HandleSettingQuery(setting_query, parsed_query.parameters, request_router);
 
   return PreparedQuery{std::move(callback.header), std::move(parsed_query.required_privileges),
                        [callback_fn = std::move(callback.fn), pull_plan = std::shared_ptr<PullPlanVector>{nullptr}](
@@ -1521,7 +1518,7 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
     if (!in_explicit_transaction_ &&
         (utils::Downcast<CypherQuery>(parsed_query.query) || utils::Downcast<ExplainQuery>(parsed_query.query) ||
          utils::Downcast<ProfileQuery>(parsed_query.query))) {
-      shard_request_manager_->StartTransaction();
+      request_router_->StartTransaction();
     }
 
     utils::Timer planning_timer;
@@ -1530,14 +1527,14 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
     if (utils::Downcast<CypherQuery>(parsed_query.query)) {
       prepared_query = PrepareCypherQuery(std::move(parsed_query), &query_execution->summary, interpreter_context_,
                                           &*execution_db_accessor_, &query_execution->execution_memory,
-                                          &query_execution->notifications, shard_request_manager_.get());
+                                          &query_execution->notifications, request_router_.get());
     } else if (utils::Downcast<ExplainQuery>(parsed_query.query)) {
       prepared_query = PrepareExplainQuery(std::move(parsed_query), &query_execution->summary, interpreter_context_,
-                                           &*shard_request_manager_, &query_execution->execution_memory_with_exception);
+                                           &*request_router_, &query_execution->execution_memory_with_exception);
     } else if (utils::Downcast<ProfileQuery>(parsed_query.query)) {
-      prepared_query = PrepareProfileQuery(
-          std::move(parsed_query), in_explicit_transaction_, &query_execution->summary, interpreter_context_,
-          &*execution_db_accessor_, &query_execution->execution_memory_with_exception, shard_request_manager_.get());
+      prepared_query = PrepareProfileQuery(std::move(parsed_query), in_explicit_transaction_, &query_execution->summary,
+                                           interpreter_context_, &*execution_db_accessor_,
+                                           &query_execution->execution_memory_with_exception, request_router_.get());
     } else if (utils::Downcast<DumpQuery>(parsed_query.query)) {
       prepared_query = PrepareDumpQuery(std::move(parsed_query), &query_execution->summary, &*execution_db_accessor_,
                                         &query_execution->execution_memory);
@@ -1545,9 +1542,9 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
       prepared_query = PrepareIndexQuery(std::move(parsed_query), in_explicit_transaction_,
                                          &query_execution->notifications, interpreter_context_);
     } else if (utils::Downcast<AuthQuery>(parsed_query.query)) {
-      prepared_query = PrepareAuthQuery(
-          std::move(parsed_query), in_explicit_transaction_, &query_execution->summary, interpreter_context_,
-          &*execution_db_accessor_, &query_execution->execution_memory_with_exception, shard_request_manager_.get());
+      prepared_query = PrepareAuthQuery(std::move(parsed_query), in_explicit_transaction_, &query_execution->summary,
+                                        interpreter_context_, &*execution_db_accessor_,
+                                        &query_execution->execution_memory_with_exception, request_router_.get());
     } else if (utils::Downcast<InfoQuery>(parsed_query.query)) {
       prepared_query = PrepareInfoQuery(std::move(parsed_query), in_explicit_transaction_, &query_execution->summary,
                                         interpreter_context_, interpreter_context_->db,
@@ -1558,7 +1555,7 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
     } else if (utils::Downcast<ReplicationQuery>(parsed_query.query)) {
       prepared_query =
           PrepareReplicationQuery(std::move(parsed_query), in_explicit_transaction_, &query_execution->notifications,
-                                  interpreter_context_, shard_request_manager_.get());
+                                  interpreter_context_, request_router_.get());
     } else if (utils::Downcast<LockPathQuery>(parsed_query.query)) {
       prepared_query = PrepareLockPathQuery(std::move(parsed_query), in_explicit_transaction_, interpreter_context_,
                                             &*execution_db_accessor_);
@@ -1575,8 +1572,7 @@ Interpreter::PrepareResult Interpreter::Prepare(const std::string &query_string,
       prepared_query =
           PrepareCreateSnapshotQuery(std::move(parsed_query), in_explicit_transaction_, interpreter_context_);
     } else if (utils::Downcast<SettingQuery>(parsed_query.query)) {
-      prepared_query =
-          PrepareSettingQuery(std::move(parsed_query), in_explicit_transaction_, shard_request_manager_.get());
+      prepared_query = PrepareSettingQuery(std::move(parsed_query), in_explicit_transaction_, request_router_.get());
     } else if (utils::Downcast<VersionQuery>(parsed_query.query)) {
       prepared_query = PrepareVersionQuery(std::move(parsed_query), in_explicit_transaction_);
     } else if (utils::Downcast<SchemaQuery>(parsed_query.query)) {
@@ -1617,7 +1613,7 @@ void Interpreter::Commit() {
   // For now, we will not check if there are some unfinished queries.
   // We should document clearly that all results should be pulled to complete
   // a query.
-  shard_request_manager_->Commit();
+  request_router_->Commit();
   if (!db_accessor_) return;
 
   const auto reset_necessary_members = [this]() {

src/query/v2/interpreter.hpp

@@ -296,7 +296,7 @@ class Interpreter final {
    */
   void Abort();
 
-  const msgs::ShardRequestManagerInterface *GetShardRequestManager() const { return shard_request_manager_.get(); }
+  const RequestRouterInterface *GetRequestRouter() const { return request_router_.get(); }
 
  private:
   struct QueryExecution {
@@ -342,7 +342,7 @@ class Interpreter final {
   // move this unique_ptr into a shared_ptr.
   std::unique_ptr<storage::v3::Shard::Accessor> db_accessor_;
   std::optional<DbAccessor> execution_db_accessor_;
-  std::unique_ptr<msgs::ShardRequestManagerInterface> shard_request_manager_;
+  std::unique_ptr<RequestRouterInterface> request_router_;
   bool in_explicit_transaction_{false};
   bool expect_rollback_{false};
 

src/query/v2/plan/operator.cpp

@@ -39,8 +39,8 @@
 #include "query/v2/frontend/ast/ast.hpp"
 #include "query/v2/path.hpp"
 #include "query/v2/plan/scoped_profile.hpp"
+#include "query/v2/request_router.hpp"
 #include "query/v2/requests.hpp"
-#include "query/v2/shard_request_manager.hpp"
 #include "storage/v3/conversions.hpp"
 #include "storage/v3/property_value.hpp"
 #include "utils/algorithm.hpp"
@@ -177,10 +177,10 @@ class DistributedCreateNodeCursor : public Cursor {
   bool Pull(Frame &frame, ExecutionContext &context) override {
     SCOPED_PROFILE_OP("CreateNode");
     if (input_cursor_->Pull(frame, context)) {
-      auto &shard_manager = context.shard_request_manager;
+      auto &request_router = context.request_router;
       {
         SCOPED_REQUEST_WAIT_PROFILE;
-        shard_manager->Request(state_, NodeCreationInfoToRequest(context, frame));
+        request_router->CreateVertices(NodeCreationInfoToRequest(context, frame));
       }
       PlaceNodeOnTheFrame(frame, context);
       return true;
@@ -191,14 +191,14 @@ class DistributedCreateNodeCursor : public Cursor {
 
   void Shutdown() override { input_cursor_->Shutdown(); }
 
-  void Reset() override { state_ = {}; }
+  void Reset() override {}
 
   void PlaceNodeOnTheFrame(Frame &frame, ExecutionContext &context) {
     // TODO(kostasrim) Make this work with batching
     const auto primary_label = msgs::Label{.id = nodes_info_[0]->labels[0]};
     msgs::Vertex v{.id = std::make_pair(primary_label, primary_keys_[0])};
-    frame[nodes_info_.front()->symbol] = TypedValue(
-        query::v2::accessors::VertexAccessor(std::move(v), src_vertex_props_[0], context.shard_request_manager));
+    frame[nodes_info_.front()->symbol] =
+        TypedValue(query::v2::accessors::VertexAccessor(std::move(v), src_vertex_props_[0], context.request_router));
   }
 
   std::vector<msgs::NewVertex> NodeCreationInfoToRequest(ExecutionContext &context, Frame &frame) {
@@ -218,7 +218,7 @@ class DistributedCreateNodeCursor : public Cursor {
       if (const auto *node_info_properties = std::get_if<PropertiesMapList>(&node_info->properties)) {
         for (const auto &[key, value_expression] : *node_info_properties) {
           TypedValue val = value_expression->Accept(evaluator);
-          if (context.shard_request_manager->IsPrimaryKey(primary_label, key)) {
+          if (context.request_router->IsPrimaryKey(primary_label, key)) {
             rqst.primary_key.push_back(TypedValueToValue(val));
             pk.push_back(TypedValueToValue(val));
           }
@@ -227,8 +227,8 @@ class DistributedCreateNodeCursor : public Cursor {
         auto property_map = evaluator.Visit(*std::get<ParameterLookup *>(node_info->properties)).ValueMap();
         for (const auto &[key, value] : property_map) {
           auto key_str = std::string(key);
-          auto property_id = context.shard_request_manager->NameToProperty(key_str);
-          if (context.shard_request_manager->IsPrimaryKey(primary_label, property_id)) {
+          auto property_id = context.request_router->NameToProperty(key_str);
+          if (context.request_router->IsPrimaryKey(primary_label, property_id)) {
             rqst.primary_key.push_back(TypedValueToValue(value));
             pk.push_back(TypedValueToValue(value));
           }
@@ -252,7 +252,6 @@ class DistributedCreateNodeCursor : public Cursor {
   std::vector<const NodeCreationInfo *> nodes_info_;
   std::vector<std::vector<std::pair<storage::v3::PropertyId, msgs::Value>>> src_vertex_props_;
   std::vector<msgs::PrimaryKey> primary_keys_;
-  msgs::ExecutionState<msgs::CreateVerticesRequest> state_;
 };
 
 bool Once::OnceCursor::Pull(Frame &, ExecutionContext &context) {
@@ -365,7 +364,6 @@ class ScanAllCursor : public Cursor {
   std::optional<decltype(vertices_.value().begin())> vertices_it_;
   const char *op_name_;
   std::vector<msgs::ScanVerticesResponse> current_batch;
-  msgs::ExecutionState<msgs::ScanVerticesRequest> request_state;
 };
 
 class DistributedScanAllAndFilterCursor : public Cursor {
@@ -384,37 +382,41 @@ class DistributedScanAllAndFilterCursor : public Cursor {
     ResetExecutionState();
   }
 
+  enum class State : int8_t { INITIALIZING, COMPLETED };
+
   using VertexAccessor = accessors::VertexAccessor;
 
-  bool MakeRequest(msgs::ShardRequestManagerInterface &shard_manager, ExecutionContext &context) {
+  bool MakeRequest(RequestRouterInterface &request_router, ExecutionContext &context) {
     {
       SCOPED_REQUEST_WAIT_PROFILE;
-      current_batch = shard_manager.Request(request_state_);
+      std::optional<std::string> request_label = std::nullopt;
+      if (label_.has_value()) {
+        request_label = request_router.LabelToName(*label_);
+      }
+      current_batch = request_router.ScanVertices(request_label);
     }
     current_vertex_it = current_batch.begin();
+    request_state_ = State::COMPLETED;
     return !current_batch.empty();
   }
 
   bool Pull(Frame &frame, ExecutionContext &context) override {
     SCOPED_PROFILE_OP(op_name_);
 
-    auto &shard_manager = *context.shard_request_manager;
+    auto &request_router = *context.request_router;
     while (true) {
       if (MustAbort(context)) {
         throw HintedAbortError();
       }
-      using State = msgs::ExecutionState<msgs::ScanVerticesRequest>;
 
-      if (request_state_.state == State::INITIALIZING) {
+      if (request_state_ == State::INITIALIZING) {
         if (!input_cursor_->Pull(frame, context)) {
           return false;
         }
       }
 
-      request_state_.label = label_.has_value() ? std::make_optional(shard_manager.LabelToName(*label_)) : std::nullopt;
-
       if (current_vertex_it == current_batch.end() &&
-          (request_state_.state == State::COMPLETED || !MakeRequest(shard_manager, context))) {
+          (request_state_ == State::COMPLETED || !MakeRequest(request_router, context))) {
         ResetExecutionState();
         continue;
       }
@@ -430,7 +432,7 @@ class DistributedScanAllAndFilterCursor : public Cursor {
   void ResetExecutionState() {
     current_batch.clear();
     current_vertex_it = current_batch.end();
-    request_state_ = msgs::ExecutionState<msgs::ScanVerticesRequest>{};
+    request_state_ = State::INITIALIZING;
   }
 
   void Reset() override {
@@ -444,7 +446,7 @@ class DistributedScanAllAndFilterCursor : public Cursor {
   const char *op_name_;
   std::vector<VertexAccessor> current_batch;
   std::vector<VertexAccessor>::iterator current_vertex_it;
-  msgs::ExecutionState<msgs::ScanVerticesRequest> request_state_;
+  State request_state_ = State::INITIALIZING;
   std::optional<storage::v3::LabelId> label_;
   std::optional<std::pair<storage::v3::PropertyId, Expression *>> property_expression_pair_;
   std::optional<std::vector<Expression *>> filter_expressions_;
@@ -696,7 +698,7 @@ bool Filter::FilterCursor::Pull(Frame &frame, ExecutionContext &context) {
 
   // Like all filters, newly set values should not affect filtering of old
   // nodes and edges.
-  ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.shard_request_manager,
+  ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.request_router,
                                 storage::v3::View::OLD);
   while (input_cursor_->Pull(frame, context)) {
     if (EvaluateFilter(evaluator, self_.expression_)) return true;
@@ -737,8 +739,8 @@ bool Produce::ProduceCursor::Pull(Frame &frame, ExecutionContext &context) {
 
   if (input_cursor_->Pull(frame, context)) {
     // Produce should always yield the latest results.
-    ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context,
-                                  context.shard_request_manager, storage::v3::View::NEW);
+    ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.request_router,
+                                  storage::v3::View::NEW);
     for (auto named_expr : self_.named_expressions_) named_expr->Accept(evaluator);
 
     return true;
@@ -1122,8 +1124,8 @@ class AggregateCursor : public Cursor {
    * aggregation results, and not on the number of inputs.
    */
   void ProcessAll(Frame *frame, ExecutionContext *context) {
-    ExpressionEvaluator evaluator(frame, context->symbol_table, context->evaluation_context,
-                                  context->shard_request_manager, storage::v3::View::NEW);
+    ExpressionEvaluator evaluator(frame, context->symbol_table, context->evaluation_context, context->request_router,
+                                  storage::v3::View::NEW);
     while (input_cursor_->Pull(*frame, *context)) {
       ProcessOne(*frame, &evaluator);
     }
@@ -1343,8 +1345,8 @@ bool Skip::SkipCursor::Pull(Frame &frame, ExecutionContext &context) {
       // First successful pull from the input, evaluate the skip expression.
       // The skip expression doesn't contain identifiers so graph view
       // parameter is not important.
-      ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context,
-                                    context.shard_request_manager, storage::v3::View::OLD);
+      ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.request_router,
+                                    storage::v3::View::OLD);
       TypedValue to_skip = self_.expression_->Accept(evaluator);
       if (to_skip.type() != TypedValue::Type::Int)
         throw QueryRuntimeException("Number of elements to skip must be an integer.");
@@ -1398,8 +1400,8 @@ bool Limit::LimitCursor::Pull(Frame &frame, ExecutionContext &context) {
   if (limit_ == -1) {
     // Limit expression doesn't contain identifiers so graph view is not
     // important.
-    ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context,
-                                  context.shard_request_manager, storage::v3::View::OLD);
+    ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.request_router,
+                                  storage::v3::View::OLD);
     TypedValue limit = self_.expression_->Accept(evaluator);
     if (limit.type() != TypedValue::Type::Int)
       throw QueryRuntimeException("Limit on number of returned elements must be an integer.");
@@ -1454,8 +1456,8 @@ class OrderByCursor : public Cursor {
     SCOPED_PROFILE_OP("OrderBy");
 
     if (!did_pull_all_) {
-      ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context,
-                                    context.shard_request_manager, storage::v3::View::OLD);
+      ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.request_router,
+                                    storage::v3::View::OLD);
       auto *mem = cache_.get_allocator().GetMemoryResource();
       while (input_cursor_->Pull(frame, context)) {
         // collect the order_by elements
@@ -1712,8 +1714,8 @@ class UnwindCursor : public Cursor {
         if (!input_cursor_->Pull(frame, context)) return false;
 
         // successful pull from input, initialize value and iterator
-        ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context,
-                                      context.shard_request_manager, storage::v3::View::OLD);
+        ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.request_router,
+                                      storage::v3::View::OLD);
         TypedValue input_value = self_.input_expression_->Accept(evaluator);
         if (input_value.type() != TypedValue::Type::List)
           throw QueryRuntimeException("Argument of UNWIND must be a list, but '{}' was provided.", input_value.type());
@@ -2224,7 +2226,7 @@ class LoadCsvCursor : public Cursor {
     Frame frame(0);
     SymbolTable symbol_table;
     auto evaluator =
-        ExpressionEvaluator(&frame, symbol_table, eval_context, context.shard_request_manager, storage::v3::View::OLD);
+        ExpressionEvaluator(&frame, symbol_table, eval_context, context.request_router, storage::v3::View::OLD);
 
     auto maybe_file = ToOptionalString(&evaluator, self_->file_);
     auto maybe_delim = ToOptionalString(&evaluator, self_->delimiter_);
@@ -2261,8 +2263,8 @@ class ForeachCursor : public Cursor {
       return false;
     }
 
-    ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context,
-                                  context.shard_request_manager, storage::v3::View::NEW);
+    ExpressionEvaluator evaluator(&frame, context.symbol_table, context.evaluation_context, context.request_router,
+                                  storage::v3::View::NEW);
     TypedValue expr_result = expression->Accept(evaluator);
 
     if (expr_result.IsNull()) {
@@ -2338,11 +2340,11 @@ class DistributedCreateExpandCursor : public Cursor {
     if (!input_cursor_->Pull(frame, context)) {
       return false;
     }
-    auto &shard_manager = context.shard_request_manager;
+    auto &request_router = context.request_router;
     ResetExecutionState();
     {
       SCOPED_REQUEST_WAIT_PROFILE;
-      shard_manager->Request(state_, ExpandCreationInfoToRequest(context, frame));
+      request_router->CreateExpand(ExpandCreationInfoToRequest(context, frame));
     }
     return true;
   }
@@ -2379,7 +2381,7 @@ class DistributedCreateExpandCursor : public Cursor {
         // handle parameter
         auto property_map = evaluator.Visit(*std::get<ParameterLookup *>(edge_info.properties)).ValueMap();
         for (const auto &[property, value] : property_map) {
-          const auto property_id = context.shard_request_manager->NameToProperty(std::string(property));
+          const auto property_id = context.request_router->NameToProperty(std::string(property));
           request.properties.emplace_back(property_id, storage::v3::TypedValueToValue(value));
         }
       }
@@ -2394,7 +2396,7 @@ class DistributedCreateExpandCursor : public Cursor {
       const auto set_vertex = [&context](const auto &vertex, auto &vertex_id) {
         vertex_id.first = vertex.PrimaryLabel();
         for (const auto &[key, val] : vertex.Properties()) {
-          if (context.shard_request_manager->IsPrimaryKey(vertex_id.first.id, key)) {
+          if (context.request_router->IsPrimaryKey(vertex_id.first.id, key)) {
             vertex_id.second.push_back(val);
           }
         }
@@ -2422,11 +2424,10 @@ class DistributedCreateExpandCursor : public Cursor {
   }
 
  private:
-  void ResetExecutionState() { state_ = {}; }
+  void ResetExecutionState() {}
 
   const UniqueCursorPtr input_cursor_;
   const CreateExpand &self_;
-  msgs::ExecutionState<msgs::CreateExpandRequest> state_;
 };
 
 class DistributedExpandCursor : public Cursor {
@@ -2473,12 +2474,11 @@ class DistributedExpandCursor : public Cursor {
     request.edge_properties.emplace();
     request.src_vertices.push_back(get_dst_vertex(edge, direction));
     request.direction = (direction == EdgeAtom::Direction::IN) ? msgs::EdgeDirection::OUT : msgs::EdgeDirection::IN;
-    msgs::ExecutionState<msgs::ExpandOneRequest> request_state;
-    auto result_rows = context.shard_request_manager->Request(request_state, std::move(request));
+    auto result_rows = context.request_router->ExpandOne(std::move(request));
     MG_ASSERT(result_rows.size() == 1);
     auto &result_row = result_rows.front();
     frame[self_.common_.node_symbol] = accessors::VertexAccessor(
-        msgs::Vertex{result_row.src_vertex}, result_row.src_vertex_properties, context.shard_request_manager);
+        msgs::Vertex{result_row.src_vertex}, result_row.src_vertex_properties, context.request_router);
   }
 
   bool InitEdges(Frame &frame, ExecutionContext &context) {
@@ -2499,10 +2499,9 @@ class DistributedExpandCursor : public Cursor {
       // to not fetch any properties of the edges
       request.edge_properties.emplace();
       request.src_vertices.push_back(vertex.Id());
-      msgs::ExecutionState<msgs::ExpandOneRequest> request_state;
-      auto result_rows = std::invoke([&context, &request_state, &request]() mutable {
+      auto result_rows = std::invoke([&context, &request]() mutable {
         SCOPED_REQUEST_WAIT_PROFILE;
-        return context.shard_request_manager->Request(request_state, std::move(request));
+        return context.request_router->ExpandOne(std::move(request));
       });
       MG_ASSERT(result_rows.size() == 1);
       auto &result_row = result_rows.front();
@@ -2525,14 +2524,14 @@ class DistributedExpandCursor : public Cursor {
           case EdgeAtom::Direction::IN: {
             for (auto &edge : edge_messages) {
               edge_accessors.emplace_back(msgs::Edge{std::move(edge.other_end), vertex.Id(), {}, {edge.gid}, edge.type},
-                                          context.shard_request_manager);
+                                          context.request_router);
             }
             break;
           }
           case EdgeAtom::Direction::OUT: {
             for (auto &edge : edge_messages) {
               edge_accessors.emplace_back(msgs::Edge{vertex.Id(), std::move(edge.other_end), {}, {edge.gid}, edge.type},
-                                          context.shard_request_manager);
+                                          context.request_router);
             }
             break;
           }

src/query/v2/plan/preprocess.cpp

@@ -398,7 +398,7 @@ void Filters::AnalyzeAndStoreFilter(Expression *expr, const SymbolTable &symbol_
   auto add_id_equal = [&](auto *maybe_id_fun, auto *val_expr) -> bool {
     auto *id_fun = utils::Downcast<Function>(maybe_id_fun);
     if (!id_fun) return false;
-    if (id_fun->function_name_ != kId) return false;
+    if (id_fun->function_name_ != functions::kId) return false;
     if (id_fun->arguments_.size() != 1U) return false;
     auto *ident = utils::Downcast<Identifier>(id_fun->arguments_.front());
     if (!ident) return false;

src/query/v2/plan/pretty_print.cpp

@@ -14,13 +14,13 @@
 
 #include "query/v2/bindings/pretty_print.hpp"
 #include "query/v2/db_accessor.hpp"
-#include "query/v2/shard_request_manager.hpp"
+#include "query/v2/request_router.hpp"
 #include "utils/string.hpp"
 
 namespace memgraph::query::v2::plan {
 
-PlanPrinter::PlanPrinter(const msgs::ShardRequestManagerInterface *request_manager, std::ostream *out)
-    : request_manager_(request_manager), out_(out) {}
+PlanPrinter::PlanPrinter(const RequestRouterInterface *request_router, std::ostream *out)
+    : request_router_(request_router), out_(out) {}
 
 #define PRE_VISIT(TOp)                                   \
   bool PlanPrinter::PreVisit(TOp &) {                    \
@@ -34,7 +34,7 @@ bool PlanPrinter::PreVisit(CreateExpand &op) {
   WithPrintLn([&](auto &out) {
     out << "* CreateExpand (" << op.input_symbol_.name() << ")"
         << (op.edge_info_.direction == query::v2::EdgeAtom::Direction::IN ? "<-" : "-") << "["
-        << op.edge_info_.symbol.name() << ":" << request_manager_->EdgeTypeToName(op.edge_info_.edge_type) << "]"
+        << op.edge_info_.symbol.name() << ":" << request_router_->EdgeTypeToName(op.edge_info_.edge_type) << "]"
         << (op.edge_info_.direction == query::v2::EdgeAtom::Direction::OUT ? "->" : "-") << "("
         << op.node_info_.symbol.name() << ")";
   });
@@ -54,7 +54,7 @@ bool PlanPrinter::PreVisit(query::v2::plan::ScanAll &op) {
 bool PlanPrinter::PreVisit(query::v2::plan::ScanAllByLabel &op) {
   WithPrintLn([&](auto &out) {
     out << "* ScanAllByLabel"
-        << " (" << op.output_symbol_.name() << " :" << request_manager_->LabelToName(op.label_) << ")";
+        << " (" << op.output_symbol_.name() << " :" << request_router_->LabelToName(op.label_) << ")";
   });
   return true;
 }
@@ -62,8 +62,8 @@ bool PlanPrinter::PreVisit(query::v2::plan::ScanAllByLabel &op) {
 bool PlanPrinter::PreVisit(query::v2::plan::ScanAllByLabelPropertyValue &op) {
   WithPrintLn([&](auto &out) {
     out << "* ScanAllByLabelPropertyValue"
-        << " (" << op.output_symbol_.name() << " :" << request_manager_->LabelToName(op.label_) << " {"
-        << request_manager_->PropertyToName(op.property_) << "})";
+        << " (" << op.output_symbol_.name() << " :" << request_router_->LabelToName(op.label_) << " {"
+        << request_router_->PropertyToName(op.property_) << "})";
   });
   return true;
 }
@@ -71,8 +71,8 @@ bool PlanPrinter::PreVisit(query::v2::plan::ScanAllByLabelPropertyValue &op) {
 bool PlanPrinter::PreVisit(query::v2::plan::ScanAllByLabelPropertyRange &op) {
   WithPrintLn([&](auto &out) {
     out << "* ScanAllByLabelPropertyRange"
-        << " (" << op.output_symbol_.name() << " :" << request_manager_->LabelToName(op.label_) << " {"
-        << request_manager_->PropertyToName(op.property_) << "})";
+        << " (" << op.output_symbol_.name() << " :" << request_router_->LabelToName(op.label_) << " {"
+        << request_router_->PropertyToName(op.property_) << "})";
   });
   return true;
 }
@@ -80,8 +80,8 @@ bool PlanPrinter::PreVisit(query::v2::plan::ScanAllByLabelPropertyRange &op) {
 bool PlanPrinter::PreVisit(query::v2::plan::ScanAllByLabelProperty &op) {
   WithPrintLn([&](auto &out) {
     out << "* ScanAllByLabelProperty"
-        << " (" << op.output_symbol_.name() << " :" << request_manager_->LabelToName(op.label_) << " {"
-        << request_manager_->PropertyToName(op.property_) << "})";
+        << " (" << op.output_symbol_.name() << " :" << request_router_->LabelToName(op.label_) << " {"
+        << request_router_->PropertyToName(op.property_) << "})";
   });
   return true;
 }
@@ -100,7 +100,7 @@ bool PlanPrinter::PreVisit(query::v2::plan::Expand &op) {
           << (op.common_.direction == query::v2::EdgeAtom::Direction::IN ? "<-" : "-") << "["
           << op.common_.edge_symbol.name();
     utils::PrintIterable(*out_, op.common_.edge_types, "|", [this](auto &stream, const auto &edge_type) {
-      stream << ":" << request_manager_->EdgeTypeToName(edge_type);
+      stream << ":" << request_router_->EdgeTypeToName(edge_type);
     });
     *out_ << "]" << (op.common_.direction == query::v2::EdgeAtom::Direction::OUT ? "->" : "-") << "("
           << op.common_.node_symbol.name() << ")";
@@ -129,7 +129,7 @@ bool PlanPrinter::PreVisit(query::v2::plan::ExpandVariable &op) {
           << (op.common_.direction == query::v2::EdgeAtom::Direction::IN ? "<-" : "-") << "["
           << op.common_.edge_symbol.name();
     utils::PrintIterable(*out_, op.common_.edge_types, "|", [this](auto &stream, const auto &edge_type) {
-      stream << ":" << request_manager_->EdgeTypeToName(edge_type);
+      stream << ":" << request_router_->EdgeTypeToName(edge_type);
     });
     *out_ << "]" << (op.common_.direction == query::v2::EdgeAtom::Direction::OUT ? "->" : "-") << "("
           << op.common_.node_symbol.name() << ")";
@@ -263,15 +263,14 @@ void PlanPrinter::Branch(query::v2::plan::LogicalOperator &op, const std::string
   --depth_;
 }
 
-void PrettyPrint(const msgs::ShardRequestManagerInterface &request_manager, const LogicalOperator *plan_root,
-                 std::ostream *out) {
-  PlanPrinter printer(&request_manager, out);
+void PrettyPrint(const RequestRouterInterface &request_router, const LogicalOperator *plan_root, std::ostream *out) {
+  PlanPrinter printer(&request_router, out);
   // FIXME(mtomic): We should make visitors that take const arguments.
   const_cast<LogicalOperator *>(plan_root)->Accept(printer);
 }
 
-nlohmann::json PlanToJson(const msgs::ShardRequestManagerInterface &request_manager, const LogicalOperator *plan_root) {
-  impl::PlanToJsonVisitor visitor(&request_manager);
+nlohmann::json PlanToJson(const RequestRouterInterface &request_router, const LogicalOperator *plan_root) {
+  impl::PlanToJsonVisitor visitor(&request_router);
   // FIXME(mtomic): We should make visitors that take const arguments.
   const_cast<LogicalOperator *>(plan_root)->Accept(visitor);
   return visitor.output();
@@ -349,16 +348,16 @@ json ToJson(const utils::Bound<Expression *> &bound) {
 
 json ToJson(const Symbol &symbol) { return symbol.name(); }
 
-json ToJson(storage::v3::EdgeTypeId edge_type, const msgs::ShardRequestManagerInterface &request_manager) {
-  return request_manager.EdgeTypeToName(edge_type);
+json ToJson(storage::v3::EdgeTypeId edge_type, const RequestRouterInterface &request_router) {
+  return request_router.EdgeTypeToName(edge_type);
 }
 
-json ToJson(storage::v3::LabelId label, const msgs::ShardRequestManagerInterface &request_manager) {
-  return request_manager.LabelToName(label);
+json ToJson(storage::v3::LabelId label, const RequestRouterInterface &request_router) {
+  return request_router.LabelToName(label);
 }
 
-json ToJson(storage::v3::PropertyId property, const msgs::ShardRequestManagerInterface &request_manager) {
-  return request_manager.PropertyToName(property);
+json ToJson(storage::v3::PropertyId property, const RequestRouterInterface &request_router) {
+  return request_router.PropertyToName(property);
 }
 
 json ToJson(NamedExpression *nexpr) {
@@ -369,29 +368,29 @@ json ToJson(NamedExpression *nexpr) {
 }
 
 json ToJson(const std::vector<std::pair<storage::v3::PropertyId, Expression *>> &properties,
-            const msgs::ShardRequestManagerInterface &request_manager) {
+            const RequestRouterInterface &request_router) {
   json json;
   for (const auto &prop_pair : properties) {
-    json.emplace(ToJson(prop_pair.first, request_manager), ToJson(prop_pair.second));
+    json.emplace(ToJson(prop_pair.first, request_router), ToJson(prop_pair.second));
   }
   return json;
 }
 
-json ToJson(const NodeCreationInfo &node_info, const msgs::ShardRequestManagerInterface &request_manager) {
+json ToJson(const NodeCreationInfo &node_info, const RequestRouterInterface &request_router) {
   json self;
   self["symbol"] = ToJson(node_info.symbol);
-  self["labels"] = ToJson(node_info.labels, request_manager);
+  self["labels"] = ToJson(node_info.labels, request_router);
   const auto *props = std::get_if<PropertiesMapList>(&node_info.properties);
-  self["properties"] = ToJson(props ? *props : PropertiesMapList{}, request_manager);
+  self["properties"] = ToJson(props ? *props : PropertiesMapList{}, request_router);
   return self;
 }
 
-json ToJson(const EdgeCreationInfo &edge_info, const msgs::ShardRequestManagerInterface &request_manager) {
+json ToJson(const EdgeCreationInfo &edge_info, const RequestRouterInterface &request_router) {
   json self;
   self["symbol"] = ToJson(edge_info.symbol);
   const auto *props = std::get_if<PropertiesMapList>(&edge_info.properties);
-  self["properties"] = ToJson(props ? *props : PropertiesMapList{}, request_manager);
-  self["edge_type"] = ToJson(edge_info.edge_type, request_manager);
+  self["properties"] = ToJson(props ? *props : PropertiesMapList{}, request_router);
+  self["edge_type"] = ToJson(edge_info.edge_type, request_router);
   self["direction"] = ToString(edge_info.direction);
   return self;
 }
@@ -433,7 +432,7 @@ bool PlanToJsonVisitor::PreVisit(ScanAll &op) {
 bool PlanToJsonVisitor::PreVisit(ScanAllByLabel &op) {
   json self;
   self["name"] = "ScanAllByLabel";
-  self["label"] = ToJson(op.label_, *request_manager_);
+  self["label"] = ToJson(op.label_, *request_router_);
   self["output_symbol"] = ToJson(op.output_symbol_);
 
   op.input_->Accept(*this);
@@ -446,8 +445,8 @@ bool PlanToJsonVisitor::PreVisit(ScanAllByLabel &op) {
 bool PlanToJsonVisitor::PreVisit(ScanAllByLabelPropertyRange &op) {
   json self;
   self["name"] = "ScanAllByLabelPropertyRange";
-  self["label"] = ToJson(op.label_, *request_manager_);
-  self["property"] = ToJson(op.property_, *request_manager_);
+  self["label"] = ToJson(op.label_, *request_router_);
+  self["property"] = ToJson(op.property_, *request_router_);
   self["lower_bound"] = op.lower_bound_ ? ToJson(*op.lower_bound_) : json();
   self["upper_bound"] = op.upper_bound_ ? ToJson(*op.upper_bound_) : json();
   self["output_symbol"] = ToJson(op.output_symbol_);
@@ -462,8 +461,8 @@ bool PlanToJsonVisitor::PreVisit(ScanAllByLabelPropertyRange &op) {
 bool PlanToJsonVisitor::PreVisit(ScanAllByLabelPropertyValue &op) {
   json self;
   self["name"] = "ScanAllByLabelPropertyValue";
-  self["label"] = ToJson(op.label_, *request_manager_);
-  self["property"] = ToJson(op.property_, *request_manager_);
+  self["label"] = ToJson(op.label_, *request_router_);
+  self["property"] = ToJson(op.property_, *request_router_);
   self["expression"] = ToJson(op.expression_);
   self["output_symbol"] = ToJson(op.output_symbol_);
 
@@ -477,8 +476,8 @@ bool PlanToJsonVisitor::PreVisit(ScanAllByLabelPropertyValue &op) {
 bool PlanToJsonVisitor::PreVisit(ScanAllByLabelProperty &op) {
   json self;
   self["name"] = "ScanAllByLabelProperty";
-  self["label"] = ToJson(op.label_, *request_manager_);
-  self["property"] = ToJson(op.property_, *request_manager_);
+  self["label"] = ToJson(op.label_, *request_router_);
+  self["property"] = ToJson(op.property_, *request_router_);
   self["output_symbol"] = ToJson(op.output_symbol_);
 
   op.input_->Accept(*this);
@@ -501,7 +500,7 @@ bool PlanToJsonVisitor::PreVisit(ScanAllById &op) {
 bool PlanToJsonVisitor::PreVisit(CreateNode &op) {
   json self;
   self["name"] = "CreateNode";
-  self["node_info"] = ToJson(op.node_info_, *request_manager_);
+  self["node_info"] = ToJson(op.node_info_, *request_router_);
 
   op.input_->Accept(*this);
   self["input"] = PopOutput();
@@ -514,8 +513,8 @@ bool PlanToJsonVisitor::PreVisit(CreateExpand &op) {
   json self;
   self["name"] = "CreateExpand";
   self["input_symbol"] = ToJson(op.input_symbol_);
-  self["node_info"] = ToJson(op.node_info_, *request_manager_);
-  self["edge_info"] = ToJson(op.edge_info_, *request_manager_);
+  self["node_info"] = ToJson(op.node_info_, *request_router_);
+  self["edge_info"] = ToJson(op.edge_info_, *request_router_);
   self["existing_node"] = op.existing_node_;
 
   op.input_->Accept(*this);
@@ -531,7 +530,7 @@ bool PlanToJsonVisitor::PreVisit(Expand &op) {
   self["input_symbol"] = ToJson(op.input_symbol_);
   self["node_symbol"] = ToJson(op.common_.node_symbol);
   self["edge_symbol"] = ToJson(op.common_.edge_symbol);
-  self["edge_types"] = ToJson(op.common_.edge_types, *request_manager_);
+  self["edge_types"] = ToJson(op.common_.edge_types, *request_router_);
   self["direction"] = ToString(op.common_.direction);
   self["existing_node"] = op.common_.existing_node;
 
@@ -548,7 +547,7 @@ bool PlanToJsonVisitor::PreVisit(ExpandVariable &op) {
   self["input_symbol"] = ToJson(op.input_symbol_);
   self["node_symbol"] = ToJson(op.common_.node_symbol);
   self["edge_symbol"] = ToJson(op.common_.edge_symbol);
-  self["edge_types"] = ToJson(op.common_.edge_types, *request_manager_);
+  self["edge_types"] = ToJson(op.common_.edge_types, *request_router_);
   self["direction"] = ToString(op.common_.direction);
   self["type"] = ToString(op.type_);
   self["is_reverse"] = op.is_reverse_;
@@ -623,7 +622,7 @@ bool PlanToJsonVisitor::PreVisit(Delete &op) {
 bool PlanToJsonVisitor::PreVisit(SetProperty &op) {
   json self;
   self["name"] = "SetProperty";
-  self["property"] = ToJson(op.property_, *request_manager_);
+  self["property"] = ToJson(op.property_, *request_router_);
   self["lhs"] = ToJson(op.lhs_);
   self["rhs"] = ToJson(op.rhs_);
 
@@ -660,7 +659,7 @@ bool PlanToJsonVisitor::PreVisit(SetLabels &op) {
   json self;
   self["name"] = "SetLabels";
   self["input_symbol"] = ToJson(op.input_symbol_);
-  self["labels"] = ToJson(op.labels_, *request_manager_);
+  self["labels"] = ToJson(op.labels_, *request_router_);
 
   op.input_->Accept(*this);
   self["input"] = PopOutput();
@@ -672,7 +671,7 @@ bool PlanToJsonVisitor::PreVisit(SetLabels &op) {
 bool PlanToJsonVisitor::PreVisit(RemoveProperty &op) {
   json self;
   self["name"] = "RemoveProperty";
-  self["property"] = ToJson(op.property_, *request_manager_);
+  self["property"] = ToJson(op.property_, *request_router_);
   self["lhs"] = ToJson(op.lhs_);
 
   op.input_->Accept(*this);
@@ -686,7 +685,7 @@ bool PlanToJsonVisitor::PreVisit(RemoveLabels &op) {
   json self;
   self["name"] = "RemoveLabels";
   self["input_symbol"] = ToJson(op.input_symbol_);
-  self["labels"] = ToJson(op.labels_, *request_manager_);
+  self["labels"] = ToJson(op.labels_, *request_router_);
 
   op.input_->Accept(*this);
   self["input"] = PopOutput();

src/query/v2/plan/pretty_print.hpp

@@ -18,7 +18,7 @@
 
 #include "query/v2/frontend/ast/ast.hpp"
 #include "query/v2/plan/operator.hpp"
-#include "query/v2/shard_request_manager.hpp"
+#include "query/v2/request_router.hpp"
 
 namespace memgraph::query::v2 {
 
@@ -27,20 +27,19 @@ namespace plan {
 class LogicalOperator;
 
 /// Pretty print a `LogicalOperator` plan to a `std::ostream`.
-/// ShardRequestManager is needed for resolving label and property names.
+/// RequestRouter is needed for resolving label and property names.
 /// Note that `plan_root` isn't modified, but we can't take it as a const
 /// because we don't have support for visiting a const LogicalOperator.
-void PrettyPrint(const msgs::ShardRequestManagerInterface &request_manager, const LogicalOperator *plan_root,
-                 std::ostream *out);
+void PrettyPrint(const RequestRouterInterface &request_router, const LogicalOperator *plan_root, std::ostream *out);
 
 /// Overload of `PrettyPrint` which defaults the `std::ostream` to `std::cout`.
-inline void PrettyPrint(const msgs::ShardRequestManagerInterface &request_manager, const LogicalOperator *plan_root) {
-  PrettyPrint(request_manager, plan_root, &std::cout);
+inline void PrettyPrint(const RequestRouterInterface &request_router, const LogicalOperator *plan_root) {
+  PrettyPrint(request_router, plan_root, &std::cout);
 }
 
 /// Convert a `LogicalOperator` plan to a JSON representation.
 /// DbAccessor is needed for resolving label and property names.
-nlohmann::json PlanToJson(const msgs::ShardRequestManagerInterface &request_manager, const LogicalOperator *plan_root);
+nlohmann::json PlanToJson(const RequestRouterInterface &request_router, const LogicalOperator *plan_root);
 
 class PlanPrinter : public virtual HierarchicalLogicalOperatorVisitor {
  public:
@@ -48,7 +47,7 @@ class PlanPrinter : public virtual HierarchicalLogicalOperatorVisitor {
   using HierarchicalLogicalOperatorVisitor::PreVisit;
   using HierarchicalLogicalOperatorVisitor::Visit;
 
-  PlanPrinter(const msgs::ShardRequestManagerInterface *request_manager, std::ostream *out);
+  PlanPrinter(const RequestRouterInterface *request_router, std::ostream *out);
 
   bool DefaultPreVisit() override;
 
@@ -115,7 +114,7 @@ class PlanPrinter : public virtual HierarchicalLogicalOperatorVisitor {
   void Branch(LogicalOperator &op, const std::string &branch_name = "");
 
   int64_t depth_{0};
-  const msgs::ShardRequestManagerInterface *request_manager_{nullptr};
+  const RequestRouterInterface *request_router_{nullptr};
   std::ostream *out_{nullptr};
 };
 
@@ -133,20 +132,20 @@ nlohmann::json ToJson(const utils::Bound<Expression *> &bound);
 
 nlohmann::json ToJson(const Symbol &symbol);
 
-nlohmann::json ToJson(storage::v3::EdgeTypeId edge_type, const msgs::ShardRequestManagerInterface &request_manager);
+nlohmann::json ToJson(storage::v3::EdgeTypeId edge_type, const RequestRouterInterface &request_router);
 
-nlohmann::json ToJson(storage::v3::LabelId label, const msgs::ShardRequestManagerInterface &request_manager);
+nlohmann::json ToJson(storage::v3::LabelId label, const RequestRouterInterface &request_router);
 
-nlohmann::json ToJson(storage::v3::PropertyId property, const msgs::ShardRequestManagerInterface &request_manager);
+nlohmann::json ToJson(storage::v3::PropertyId property, const RequestRouterInterface &request_router);
 
 nlohmann::json ToJson(NamedExpression *nexpr);
 
 nlohmann::json ToJson(const std::vector<std::pair<storage::v3::PropertyId, Expression *>> &properties,
-                      const msgs::ShardRequestManagerInterface &request_manager);
+                      const RequestRouterInterface &request_router);
 
-nlohmann::json ToJson(const NodeCreationInfo &node_info, const msgs::ShardRequestManagerInterface &request_manager);
+nlohmann::json ToJson(const NodeCreationInfo &node_info, const RequestRouterInterface &request_router);
 
-nlohmann::json ToJson(const EdgeCreationInfo &edge_info, const msgs::ShardRequestManagerInterface &request_manager);
+nlohmann::json ToJson(const EdgeCreationInfo &edge_info, const RequestRouterInterface &request_router);
 
 nlohmann::json ToJson(const Aggregate::Element &elem);
 
@@ -161,8 +160,7 @@ nlohmann::json ToJson(const std::vector<T> &items, Args &&...args) {
 
 class PlanToJsonVisitor : public virtual HierarchicalLogicalOperatorVisitor {
  public:
-  explicit PlanToJsonVisitor(const msgs::ShardRequestManagerInterface *request_manager)
-      : request_manager_(request_manager) {}
+  explicit PlanToJsonVisitor(const RequestRouterInterface *request_router) : request_router_(request_router) {}
 
   using HierarchicalLogicalOperatorVisitor::PostVisit;
   using HierarchicalLogicalOperatorVisitor::PreVisit;
@@ -218,7 +216,7 @@ class PlanToJsonVisitor : public virtual HierarchicalLogicalOperatorVisitor {
 
  protected:
   nlohmann::json output_;
-  const msgs::ShardRequestManagerInterface *request_manager_;
+  const RequestRouterInterface *request_router_;
 
   nlohmann::json PopOutput() {
     nlohmann::json tmp;

src/query/v2/plan/rule_based_planner.hpp

@@ -272,7 +272,7 @@ class RuleBasedPlanner {
           PropertiesMapList vector_props;
           vector_props.reserve(node_properties->size());
           for (const auto &kv : *node_properties) {
-            // TODO(kostasrim) GetProperty should be implemented in terms of ShardRequestManager NameToProperty
+            // TODO(kostasrim) GetProperty should be implemented in terms of RequestRouter NameToProperty
             vector_props.push_back({GetProperty(kv.first), kv.second});
           }
           return std::move(vector_props);

src/query/v2/plan/vertex_count_cache.hpp

@@ -15,7 +15,7 @@
 #include <optional>
 
 #include "query/v2/bindings/typed_value.hpp"
-#include "query/v2/shard_request_manager.hpp"
+#include "query/v2/request_router.hpp"
 #include "storage/v3/conversions.hpp"
 #include "storage/v3/id_types.hpp"
 #include "storage/v3/property_value.hpp"
@@ -29,11 +29,11 @@ namespace memgraph::query::v2::plan {
 template <class TDbAccessor>
 class VertexCountCache {
  public:
-  explicit VertexCountCache(TDbAccessor *shard_request_manager) : shard_request_manager_{shard_request_manager} {}
+  explicit VertexCountCache(TDbAccessor *request_router) : request_router_{request_router} {}
 
-  auto NameToLabel(const std::string &name) { return shard_request_manager_->NameToLabel(name); }
-  auto NameToProperty(const std::string &name) { return shard_request_manager_->NameToProperty(name); }
-  auto NameToEdgeType(const std::string &name) { return shard_request_manager_->NameToEdgeType(name); }
+  auto NameToLabel(const std::string &name) { return request_router_->NameToLabel(name); }
+  auto NameToProperty(const std::string &name) { return request_router_->NameToProperty(name); }
+  auto NameToEdgeType(const std::string &name) { return request_router_->NameToEdgeType(name); }
 
   int64_t VerticesCount() { return 1; }
 
@@ -53,11 +53,11 @@ class VertexCountCache {
   }
 
   // For now return true if label is primary label
-  bool LabelIndexExists(storage::v3::LabelId label) { return shard_request_manager_->IsPrimaryLabel(label); }
+  bool LabelIndexExists(storage::v3::LabelId label) { return request_router_->IsPrimaryLabel(label); }
 
   bool LabelPropertyIndexExists(storage::v3::LabelId /*label*/, storage::v3::PropertyId /*property*/) { return false; }
 
-  msgs::ShardRequestManagerInterface *shard_request_manager_;
+  RequestRouterInterface *request_router_;
 };
 
 template <class TDbAccessor>

src/query/v2/request_router.hpp

@@ -0,0 +1,670 @@
+// 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 <algorithm>
+#include <chrono>
+#include <deque>
+#include <iostream>
+#include <iterator>
+#include <map>
+#include <numeric>
+#include <optional>
+#include <random>
+#include <set>
+#include <stdexcept>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "coordinator/coordinator.hpp"
+#include "coordinator/coordinator_client.hpp"
+#include "coordinator/coordinator_rsm.hpp"
+#include "coordinator/shard_map.hpp"
+#include "io/address.hpp"
+#include "io/errors.hpp"
+#include "io/rsm/raft.hpp"
+#include "io/rsm/rsm_client.hpp"
+#include "io/rsm/shard_rsm.hpp"
+#include "io/simulator/simulator.hpp"
+#include "io/simulator/simulator_transport.hpp"
+#include "query/v2/accessors.hpp"
+#include "query/v2/requests.hpp"
+#include "storage/v3/id_types.hpp"
+#include "storage/v3/value_conversions.hpp"
+#include "utils/result.hpp"
+
+namespace memgraph::query::v2 {
+template <typename TStorageClient>
+class RsmStorageClientManager {
+ public:
+  using CompoundKey = io::rsm::ShardRsmKey;
+  using Shard = coordinator::Shard;
+  RsmStorageClientManager() = default;
+  RsmStorageClientManager(const RsmStorageClientManager &) = delete;
+  RsmStorageClientManager(RsmStorageClientManager &&) = delete;
+  RsmStorageClientManager &operator=(const RsmStorageClientManager &) = delete;
+  RsmStorageClientManager &operator=(RsmStorageClientManager &&) = delete;
+  ~RsmStorageClientManager() = default;
+
+  void AddClient(Shard key, TStorageClient client) { cli_cache_.emplace(std::move(key), std::move(client)); }
+
+  bool Exists(const Shard &key) { return cli_cache_.contains(key); }
+
+  void PurgeCache() { cli_cache_.clear(); }
+
+  TStorageClient &GetClient(const Shard &key) {
+    auto it = cli_cache_.find(key);
+    MG_ASSERT(it != cli_cache_.end(), "Non-existing shard client");
+    return it->second;
+  }
+
+ private:
+  std::map<Shard, TStorageClient> cli_cache_;
+};
+
+template <typename TRequest>
+struct ShardRequestState {
+  memgraph::coordinator::Shard shard;
+  TRequest request;
+  std::optional<io::rsm::AsyncRequestToken> async_request_token;
+};
+
+template <typename TRequest>
+struct ExecutionState {
+  using CompoundKey = io::rsm::ShardRsmKey;
+  using Shard = coordinator::Shard;
+
+  // label is optional because some operators can create/remove etc, vertices. These kind of requests contain the label
+  // on the request itself.
+  std::optional<std::string> label;
+  // Transaction id to be filled by the RequestRouter implementation
+  coordinator::Hlc transaction_id;
+  // Initialized by RequestRouter implementation. This vector is filled with the shards that
+  // the RequestRouter impl will send requests to. When a request to a shard exhausts it, meaning that
+  // it pulled all the requested data from the given Shard, it will be removed from the Vector. When the Vector becomes
+  // empty, it means that all of the requests have completed succefully.
+  std::vector<ShardRequestState<TRequest>> requests;
+};
+
+class RequestRouterInterface {
+ public:
+  using VertexAccessor = query::v2::accessors::VertexAccessor;
+  RequestRouterInterface() = default;
+  RequestRouterInterface(const RequestRouterInterface &) = delete;
+  RequestRouterInterface(RequestRouterInterface &&) = delete;
+  RequestRouterInterface &operator=(const RequestRouterInterface &) = delete;
+  RequestRouterInterface &&operator=(RequestRouterInterface &&) = delete;
+
+  virtual ~RequestRouterInterface() = default;
+
+  virtual void StartTransaction() = 0;
+  virtual void Commit() = 0;
+  virtual std::vector<VertexAccessor> ScanVertices(std::optional<std::string> label) = 0;
+  virtual std::vector<msgs::CreateVerticesResponse> CreateVertices(std::vector<msgs::NewVertex> new_vertices) = 0;
+  virtual std::vector<msgs::ExpandOneResultRow> ExpandOne(msgs::ExpandOneRequest request) = 0;
+  virtual std::vector<msgs::CreateExpandResponse> CreateExpand(std::vector<msgs::NewExpand> new_edges) = 0;
+  virtual std::vector<msgs::GetPropertiesResultRow> GetProperties(msgs::GetPropertiesRequest request) = 0;
+
+  virtual storage::v3::EdgeTypeId NameToEdgeType(const std::string &name) const = 0;
+  virtual storage::v3::PropertyId NameToProperty(const std::string &name) const = 0;
+  virtual storage::v3::LabelId NameToLabel(const std::string &name) const = 0;
+  virtual const std::string &PropertyToName(memgraph::storage::v3::PropertyId prop) const = 0;
+  virtual const std::string &LabelToName(memgraph::storage::v3::LabelId label) const = 0;
+  virtual const std::string &EdgeTypeToName(memgraph::storage::v3::EdgeTypeId type) const = 0;
+  virtual std::optional<storage::v3::PropertyId> MaybeNameToProperty(const std::string &name) const = 0;
+  virtual std::optional<storage::v3::EdgeTypeId> MaybeNameToEdgeType(const std::string &name) const = 0;
+  virtual std::optional<storage::v3::LabelId> MaybeNameToLabel(const std::string &name) const = 0;
+  virtual bool IsPrimaryLabel(storage::v3::LabelId label) const = 0;
+  virtual bool IsPrimaryKey(storage::v3::LabelId primary_label, storage::v3::PropertyId property) const = 0;
+};
+
+// TODO(kostasrim)rename this class template
+template <typename TTransport>
+class RequestRouter : public RequestRouterInterface {
+ public:
+  using StorageClient = coordinator::RsmClient<TTransport, msgs::WriteRequests, msgs::WriteResponses,
+                                               msgs::ReadRequests, msgs::ReadResponses>;
+  using CoordinatorWriteRequests = coordinator::CoordinatorWriteRequests;
+  using CoordinatorClient = coordinator::CoordinatorClient<TTransport>;
+  using Address = io::Address;
+  using Shard = coordinator::Shard;
+  using ShardMap = coordinator::ShardMap;
+  using CompoundKey = coordinator::PrimaryKey;
+  using VertexAccessor = query::v2::accessors::VertexAccessor;
+  RequestRouter(CoordinatorClient coord, io::Io<TTransport> &&io) : coord_cli_(std::move(coord)), io_(std::move(io)) {}
+
+  RequestRouter(const RequestRouter &) = delete;
+  RequestRouter(RequestRouter &&) = delete;
+  RequestRouter &operator=(const RequestRouter &) = delete;
+  RequestRouter &operator=(RequestRouter &&) = delete;
+
+  ~RequestRouter() override {}
+
+  void StartTransaction() override {
+    coordinator::HlcRequest req{.last_shard_map_version = shards_map_.GetHlc()};
+    CoordinatorWriteRequests write_req = req;
+    auto write_res = coord_cli_.SendWriteRequest(write_req);
+    if (write_res.HasError()) {
+      throw std::runtime_error("HLC request failed");
+    }
+    auto coordinator_write_response = write_res.GetValue();
+    auto hlc_response = std::get<coordinator::HlcResponse>(coordinator_write_response);
+
+    // Transaction ID to be used later...
+    transaction_id_ = hlc_response.new_hlc;
+
+    if (hlc_response.fresher_shard_map) {
+      shards_map_ = hlc_response.fresher_shard_map.value();
+      SetUpNameIdMappers();
+    }
+  }
+
+  void Commit() override {
+    coordinator::HlcRequest req{.last_shard_map_version = shards_map_.GetHlc()};
+    CoordinatorWriteRequests write_req = req;
+    auto write_res = coord_cli_.SendWriteRequest(write_req);
+    if (write_res.HasError()) {
+      throw std::runtime_error("HLC request for commit failed");
+    }
+    auto coordinator_write_response = write_res.GetValue();
+    auto hlc_response = std::get<coordinator::HlcResponse>(coordinator_write_response);
+
+    if (hlc_response.fresher_shard_map) {
+      shards_map_ = hlc_response.fresher_shard_map.value();
+      SetUpNameIdMappers();
+    }
+    auto commit_timestamp = hlc_response.new_hlc;
+
+    msgs::CommitRequest commit_req{.transaction_id = transaction_id_, .commit_timestamp = commit_timestamp};
+
+    for (const auto &[label, space] : shards_map_.label_spaces) {
+      for (const auto &[key, shard] : space.shards) {
+        auto &storage_client = GetStorageClientForShard(shard);
+        // TODO(kostasrim) Currently requests return the result directly. Adjust this when the API works MgFuture
+        // instead.
+        auto commit_response = storage_client.SendWriteRequest(commit_req);
+        // RETRY on timeouts?
+        // Sometimes this produces a timeout. Temporary solution is to use a while(true) as was done in shard_map test
+        if (commit_response.HasError()) {
+          throw std::runtime_error("Commit request timed out");
+        }
+        msgs::WriteResponses write_response_variant = commit_response.GetValue();
+        auto &response = std::get<msgs::CommitResponse>(write_response_variant);
+        if (response.error) {
+          throw std::runtime_error("Commit request did not succeed");
+        }
+      }
+    }
+  }
+
+  storage::v3::EdgeTypeId NameToEdgeType(const std::string &name) const override {
+    return shards_map_.GetEdgeTypeId(name).value();
+  }
+
+  storage::v3::PropertyId NameToProperty(const std::string &name) const override {
+    return shards_map_.GetPropertyId(name).value();
+  }
+
+  storage::v3::LabelId NameToLabel(const std::string &name) const override {
+    return shards_map_.GetLabelId(name).value();
+  }
+
+  const std::string &PropertyToName(storage::v3::PropertyId id) const override {
+    return properties_.IdToName(id.AsUint());
+  }
+  const std::string &LabelToName(storage::v3::LabelId id) const override { return labels_.IdToName(id.AsUint()); }
+  const std::string &EdgeTypeToName(storage::v3::EdgeTypeId id) const override {
+    return edge_types_.IdToName(id.AsUint());
+  }
+
+  bool IsPrimaryKey(storage::v3::LabelId primary_label, storage::v3::PropertyId property) const override {
+    const auto schema_it = shards_map_.schemas.find(primary_label);
+    MG_ASSERT(schema_it != shards_map_.schemas.end(), "Invalid primary label id: {}", primary_label.AsUint());
+
+    return std::find_if(schema_it->second.begin(), schema_it->second.end(), [property](const auto &schema_prop) {
+             return schema_prop.property_id == property;
+           }) != schema_it->second.end();
+  }
+
+  bool IsPrimaryLabel(storage::v3::LabelId label) const override { return shards_map_.label_spaces.contains(label); }
+
+  // TODO(kostasrim) Simplify return result
+  std::vector<VertexAccessor> ScanVertices(std::optional<std::string> label) override {
+    ExecutionState<msgs::ScanVerticesRequest> state = {};
+    state.label = label;
+
+    // create requests
+    InitializeExecutionState(state);
+
+    // begin all requests in parallel
+    for (auto &request : state.requests) {
+      auto &storage_client = GetStorageClientForShard(request.shard);
+      msgs::ReadRequests req = request.request;
+
+      request.async_request_token = storage_client.SendAsyncReadRequest(request.request);
+    }
+
+    // drive requests to completion
+    std::vector<msgs::ScanVerticesResponse> responses;
+    responses.reserve(state.requests.size());
+    do {
+      DriveReadResponses(state, responses);
+    } while (!state.requests.empty());
+
+    // convert responses into VertexAccessor objects to return
+    std::vector<VertexAccessor> accessors;
+    accessors.reserve(responses.size());
+    for (auto &response : responses) {
+      for (auto &result_row : response.results) {
+        accessors.emplace_back(VertexAccessor(std::move(result_row.vertex), std::move(result_row.props), this));
+      }
+    }
+
+    return accessors;
+  }
+
+  std::vector<msgs::CreateVerticesResponse> CreateVertices(std::vector<msgs::NewVertex> new_vertices) override {
+    ExecutionState<msgs::CreateVerticesRequest> state = {};
+    MG_ASSERT(!new_vertices.empty());
+
+    // create requests
+    InitializeExecutionState(state, new_vertices);
+
+    // begin all requests in parallel
+    for (auto &request : state.requests) {
+      auto req_deep_copy = request.request;
+
+      for (auto &new_vertex : req_deep_copy.new_vertices) {
+        new_vertex.label_ids.erase(new_vertex.label_ids.begin());
+      }
+
+      auto &storage_client = GetStorageClientForShard(request.shard);
+
+      msgs::WriteRequests req = req_deep_copy;
+      request.async_request_token = storage_client.SendAsyncWriteRequest(req);
+    }
+
+    // drive requests to completion
+    std::vector<msgs::CreateVerticesResponse> responses;
+    responses.reserve(state.requests.size());
+    do {
+      DriveWriteResponses(state, responses);
+    } while (!state.requests.empty());
+
+    return responses;
+  }
+
+  std::vector<msgs::CreateExpandResponse> CreateExpand(std::vector<msgs::NewExpand> new_edges) override {
+    ExecutionState<msgs::CreateExpandRequest> state = {};
+    MG_ASSERT(!new_edges.empty());
+
+    // create requests
+    InitializeExecutionState(state, new_edges);
+
+    // begin all requests in parallel
+    for (auto &request : state.requests) {
+      auto &storage_client = GetStorageClientForShard(request.shard);
+      msgs::WriteRequests req = request.request;
+      request.async_request_token = storage_client.SendAsyncWriteRequest(req);
+    }
+
+    // drive requests to completion
+    std::vector<msgs::CreateExpandResponse> responses;
+    responses.reserve(state.requests.size());
+    do {
+      DriveWriteResponses(state, responses);
+    } while (!state.requests.empty());
+
+    return responses;
+  }
+
+  std::vector<msgs::ExpandOneResultRow> ExpandOne(msgs::ExpandOneRequest request) override {
+    ExecutionState<msgs::ExpandOneRequest> state = {};
+    // TODO(kostasrim)Update to limit the batch size here
+    // Expansions of the destination must be handled by the caller. For example
+    // match (u:L1 { prop : 1 })-[:Friend]-(v:L1)
+    // For each vertex U, the ExpandOne will result in <U, Edges>. The destination vertex and its properties
+    // must be fetched again with an ExpandOne(Edges.dst)
+
+    // create requests
+    InitializeExecutionState(state, std::move(request));
+
+    // begin all requests in parallel
+    for (auto &request : state.requests) {
+      auto &storage_client = GetStorageClientForShard(request.shard);
+      msgs::ReadRequests req = request.request;
+      request.async_request_token = storage_client.SendAsyncReadRequest(req);
+    }
+
+    // drive requests to completion
+    std::vector<msgs::ExpandOneResponse> responses;
+    responses.reserve(state.requests.size());
+    do {
+      DriveReadResponses(state, responses);
+    } while (!state.requests.empty());
+
+    // post-process responses
+    std::vector<msgs::ExpandOneResultRow> result_rows;
+    const auto total_row_count = std::accumulate(responses.begin(), responses.end(), 0,
+                                                 [](const int64_t partial_count, const msgs::ExpandOneResponse &resp) {
+                                                   return partial_count + resp.result.size();
+                                                 });
+    result_rows.reserve(total_row_count);
+
+    for (auto &response : responses) {
+      result_rows.insert(result_rows.end(), std::make_move_iterator(response.result.begin()),
+                         std::make_move_iterator(response.result.end()));
+    }
+
+    return result_rows;
+  }
+
+  std::vector<msgs::GetPropertiesResultRow> GetProperties(msgs::GetPropertiesRequest requests) override {
+    ExecutionState<msgs::GetPropertiesRequest> state = {};
+    InitializeExecutionState(state, std::move(requests));
+    for (auto &request : state.requests) {
+      auto &storage_client = GetStorageClientForShard(request.shard);
+      msgs::ReadRequests req = request.request;
+      request.async_request_token = storage_client.SendAsyncReadRequest(req);
+    }
+
+    std::vector<msgs::GetPropertiesResponse> responses;
+    do {
+      DriveReadResponses(state, responses);
+    } while (!state.requests.empty());
+
+    std::vector<msgs::GetPropertiesResultRow> result;
+    for (auto &res : responses) {
+      std::move(res.result_row.begin(), res.result_row.end(), std::back_inserter(result));
+    }
+
+    return result;
+  }
+
+  std::optional<storage::v3::PropertyId> MaybeNameToProperty(const std::string &name) const override {
+    return shards_map_.GetPropertyId(name);
+  }
+
+  std::optional<storage::v3::EdgeTypeId> MaybeNameToEdgeType(const std::string &name) const override {
+    return shards_map_.GetEdgeTypeId(name);
+  }
+
+  std::optional<storage::v3::LabelId> MaybeNameToLabel(const std::string &name) const override {
+    return shards_map_.GetLabelId(name);
+  }
+
+ private:
+  void InitializeExecutionState(ExecutionState<msgs::CreateVerticesRequest> &state,
+                                std::vector<msgs::NewVertex> new_vertices) {
+    state.transaction_id = transaction_id_;
+
+    std::map<Shard, msgs::CreateVerticesRequest> per_shard_request_table;
+
+    for (auto &new_vertex : new_vertices) {
+      MG_ASSERT(!new_vertex.label_ids.empty(), "No label_ids provided for new vertex in RequestRouter::CreateVertices");
+      auto shard = shards_map_.GetShardForKey(new_vertex.label_ids[0].id,
+                                              storage::conversions::ConvertPropertyVector(new_vertex.primary_key));
+      if (!per_shard_request_table.contains(shard)) {
+        msgs::CreateVerticesRequest create_v_rqst{.transaction_id = transaction_id_};
+        per_shard_request_table.insert(std::pair(shard, std::move(create_v_rqst)));
+      }
+      per_shard_request_table[shard].new_vertices.push_back(std::move(new_vertex));
+    }
+
+    for (auto &[shard, request] : per_shard_request_table) {
+      ShardRequestState<msgs::CreateVerticesRequest> shard_request_state{
+          .shard = shard,
+          .request = request,
+          .async_request_token = std::nullopt,
+      };
+      state.requests.emplace_back(std::move(shard_request_state));
+    }
+  }
+
+  void InitializeExecutionState(ExecutionState<msgs::CreateExpandRequest> &state,
+                                std::vector<msgs::NewExpand> new_expands) {
+    state.transaction_id = transaction_id_;
+
+    std::map<Shard, msgs::CreateExpandRequest> per_shard_request_table;
+    auto ensure_shard_exists_in_table = [&per_shard_request_table,
+                                         transaction_id = transaction_id_](const Shard &shard) {
+      if (!per_shard_request_table.contains(shard)) {
+        msgs::CreateExpandRequest create_expand_request{.transaction_id = transaction_id};
+        per_shard_request_table.insert({shard, std::move(create_expand_request)});
+      }
+    };
+
+    for (auto &new_expand : new_expands) {
+      const auto shard_src_vertex = shards_map_.GetShardForKey(
+          new_expand.src_vertex.first.id, storage::conversions::ConvertPropertyVector(new_expand.src_vertex.second));
+      const auto shard_dest_vertex = shards_map_.GetShardForKey(
+          new_expand.dest_vertex.first.id, storage::conversions::ConvertPropertyVector(new_expand.dest_vertex.second));
+
+      ensure_shard_exists_in_table(shard_src_vertex);
+
+      if (shard_src_vertex != shard_dest_vertex) {
+        ensure_shard_exists_in_table(shard_dest_vertex);
+        per_shard_request_table[shard_dest_vertex].new_expands.push_back(new_expand);
+      }
+      per_shard_request_table[shard_src_vertex].new_expands.push_back(std::move(new_expand));
+    }
+
+    for (auto &[shard, request] : per_shard_request_table) {
+      ShardRequestState<msgs::CreateExpandRequest> shard_request_state{
+          .shard = shard,
+          .request = request,
+          .async_request_token = std::nullopt,
+      };
+      state.requests.emplace_back(std::move(shard_request_state));
+    }
+  }
+
+  void InitializeExecutionState(ExecutionState<msgs::ScanVerticesRequest> &state) {
+    std::vector<coordinator::Shards> multi_shards;
+    state.transaction_id = transaction_id_;
+    if (!state.label) {
+      multi_shards = shards_map_.GetAllShards();
+    } else {
+      const auto label_id = shards_map_.GetLabelId(*state.label);
+      MG_ASSERT(label_id);
+      MG_ASSERT(IsPrimaryLabel(*label_id));
+      multi_shards = {shards_map_.GetShardsForLabel(*state.label)};
+    }
+    for (auto &shards : multi_shards) {
+      for (auto &[key, shard] : shards) {
+        MG_ASSERT(!shard.empty());
+
+        msgs::ScanVerticesRequest request;
+        request.transaction_id = transaction_id_;
+        request.start_id.second = storage::conversions::ConvertValueVector(key);
+
+        ShardRequestState<msgs::ScanVerticesRequest> shard_request_state{
+            .shard = shard,
+            .request = std::move(request),
+            .async_request_token = std::nullopt,
+        };
+
+        state.requests.emplace_back(std::move(shard_request_state));
+      }
+    }
+  }
+
+  void InitializeExecutionState(ExecutionState<msgs::ExpandOneRequest> &state, msgs::ExpandOneRequest request) {
+    state.transaction_id = transaction_id_;
+
+    std::map<Shard, msgs::ExpandOneRequest> per_shard_request_table;
+    auto top_level_rqst_template = request;
+    top_level_rqst_template.transaction_id = transaction_id_;
+    top_level_rqst_template.src_vertices.clear();
+    state.requests.clear();
+    for (auto &vertex : request.src_vertices) {
+      auto shard =
+          shards_map_.GetShardForKey(vertex.first.id, storage::conversions::ConvertPropertyVector(vertex.second));
+      if (!per_shard_request_table.contains(shard)) {
+        per_shard_request_table.insert(std::pair(shard, top_level_rqst_template));
+      }
+      per_shard_request_table[shard].src_vertices.push_back(vertex);
+    }
+
+    for (auto &[shard, request] : per_shard_request_table) {
+      ShardRequestState<msgs::ExpandOneRequest> shard_request_state{
+          .shard = shard,
+          .request = request,
+          .async_request_token = std::nullopt,
+      };
+
+      state.requests.emplace_back(std::move(shard_request_state));
+    }
+  }
+
+  void InitializeExecutionState(ExecutionState<msgs::GetPropertiesRequest> &state, msgs::GetPropertiesRequest request) {
+    std::map<Shard, msgs::GetPropertiesRequest> per_shard_request_table;
+    auto top_level_rqst_template = request;
+    top_level_rqst_template.transaction_id = transaction_id_;
+    top_level_rqst_template.vertex_ids.clear();
+    top_level_rqst_template.vertices_and_edges.clear();
+
+    state.transaction_id = transaction_id_;
+
+    for (auto &vertex : request.vertex_ids) {
+      auto shard =
+          shards_map_.GetShardForKey(vertex.first.id, storage::conversions::ConvertPropertyVector(vertex.second));
+      if (!per_shard_request_table.contains(shard)) {
+        per_shard_request_table.insert(std::pair(shard, top_level_rqst_template));
+      }
+      per_shard_request_table[shard].vertex_ids.emplace_back(std::move(vertex));
+    }
+
+    for (auto &[vertex, maybe_edge] : request.vertices_and_edges) {
+      auto shard =
+          shards_map_.GetShardForKey(vertex.first.id, storage::conversions::ConvertPropertyVector(vertex.second));
+      if (!per_shard_request_table.contains(shard)) {
+        per_shard_request_table.insert(std::pair(shard, top_level_rqst_template));
+      }
+      per_shard_request_table[shard].vertices_and_edges.emplace_back(std::move(vertex), maybe_edge);
+    }
+
+    for (auto &[shard, rqst] : per_shard_request_table) {
+      ShardRequestState<msgs::GetPropertiesRequest> shard_request_state{
+          .shard = shard,
+          .request = std::move(rqst),
+          .async_request_token = std::nullopt,
+      };
+
+      state.requests.emplace_back(std::move(shard_request_state));
+    }
+  }
+
+  StorageClient &GetStorageClientForShard(Shard shard) {
+    if (!storage_cli_manager_.Exists(shard)) {
+      AddStorageClientToManager(shard);
+    }
+    return storage_cli_manager_.GetClient(shard);
+  }
+
+  StorageClient &GetStorageClientForShard(const std::string &label, const CompoundKey &key) {
+    auto shard = shards_map_.GetShardForKey(label, key);
+    return GetStorageClientForShard(std::move(shard));
+  }
+
+  void AddStorageClientToManager(Shard target_shard) {
+    MG_ASSERT(!target_shard.empty());
+    auto leader_addr = target_shard.front();
+    std::vector<Address> addresses;
+    addresses.reserve(target_shard.size());
+    for (auto &address : target_shard) {
+      addresses.push_back(std::move(address.address));
+    }
+    auto cli = StorageClient(io_, std::move(leader_addr.address), std::move(addresses));
+    storage_cli_manager_.AddClient(target_shard, std::move(cli));
+  }
+
+  template <typename RequestT, typename ResponseT>
+  void DriveReadResponses(ExecutionState<RequestT> &state, std::vector<ResponseT> &responses) {
+    for (auto &request : state.requests) {
+      auto &storage_client = GetStorageClientForShard(request.shard);
+
+      auto poll_result = storage_client.AwaitAsyncReadRequest(request.async_request_token.value());
+      while (!poll_result) {
+        poll_result = storage_client.AwaitAsyncReadRequest(request.async_request_token.value());
+      }
+
+      if (poll_result->HasError()) {
+        throw std::runtime_error("RequestRouter Read request timed out");
+      }
+
+      msgs::ReadResponses response_variant = poll_result->GetValue();
+      auto response = std::get<ResponseT>(response_variant);
+      if (response.error) {
+        throw std::runtime_error("RequestRouter Read request did not succeed");
+      }
+
+      responses.push_back(std::move(response));
+    }
+    state.requests.clear();
+  }
+
+  template <typename RequestT, typename ResponseT>
+  void DriveWriteResponses(ExecutionState<RequestT> &state, std::vector<ResponseT> &responses) {
+    for (auto &request : state.requests) {
+      auto &storage_client = GetStorageClientForShard(request.shard);
+
+      auto poll_result = storage_client.AwaitAsyncWriteRequest(request.async_request_token.value());
+      while (!poll_result) {
+        poll_result = storage_client.AwaitAsyncWriteRequest(request.async_request_token.value());
+      }
+
+      if (poll_result->HasError()) {
+        throw std::runtime_error("RequestRouter Write request timed out");
+      }
+
+      msgs::WriteResponses response_variant = poll_result->GetValue();
+      auto response = std::get<ResponseT>(response_variant);
+      if (response.error) {
+        throw std::runtime_error("RequestRouter Write request did not succeed");
+      }
+
+      responses.push_back(std::move(response));
+    }
+    state.requests.clear();
+  }
+
+  void SetUpNameIdMappers() {
+    std::unordered_map<uint64_t, std::string> id_to_name;
+    for (const auto &[name, id] : shards_map_.labels) {
+      id_to_name.emplace(id.AsUint(), name);
+    }
+    labels_.StoreMapping(std::move(id_to_name));
+    id_to_name.clear();
+    for (const auto &[name, id] : shards_map_.properties) {
+      id_to_name.emplace(id.AsUint(), name);
+    }
+    properties_.StoreMapping(std::move(id_to_name));
+    id_to_name.clear();
+    for (const auto &[name, id] : shards_map_.edge_types) {
+      id_to_name.emplace(id.AsUint(), name);
+    }
+    edge_types_.StoreMapping(std::move(id_to_name));
+  }
+
+  ShardMap shards_map_;
+  storage::v3::NameIdMapper properties_;
+  storage::v3::NameIdMapper edge_types_;
+  storage::v3::NameIdMapper labels_;
+  CoordinatorClient coord_cli_;
+  RsmStorageClientManager<StorageClient> storage_cli_manager_;
+  io::Io<TTransport> io_;
+  coordinator::Hlc transaction_id_;
+  // TODO(kostasrim) Add batch prefetching
+};
+}  // namespace memgraph::query::v2

src/query/v2/requests.hpp

@@ -368,16 +368,12 @@ struct ScanVerticesResponse {
   std::vector<ScanResultRow> results;
 };
 
-struct VertexAndEdgeId {
-  VertexId vertex;
-  std::optional<EdgeTypeId> edge;
-};
-
 struct GetPropertiesRequest {
   Hlc transaction_id;
-  std::vector<VertexAndEdgeId> vertices_and_edges;
+  std::vector<VertexId> vertex_ids;
+  std::vector<std::pair<VertexId, EdgeId>> vertices_and_edges;
 
-  std::vector<PropertyId> property_ids;
+  std::optional<std::vector<PropertyId>> property_ids;
   std::vector<std::string> expressions;
 
   std::vector<OrderBy> order_by;
@@ -388,22 +384,16 @@ struct GetPropertiesRequest {
   std::optional<std::string> filter;
 };
 
-struct PropIdValue {
-  std::vector<PropertyId> ids;
-  std::vector<Value> properties;
-};
-
 struct GetPropertiesResultRow {
-  VertexAndEdgeId vertex_and_edge;
+  VertexId vertex;
+  std::optional<EdgeId> edge;
 
-  PropIdValue properies_and_ids;
+  std::vector<std::pair<PropertyId, Value>> props;
   std::vector<Value> evaluated_expressions;
 };
 
 struct GetPropertiesResponse {
   std::vector<GetPropertiesResultRow> result_row;
-  enum RequestResult : uint16_t { OUT_OF_SHARD_RANGE, SUCCESS, FAILURE };
-  RequestResult result;
   std::optional<ShardError> error;
 };
 

src/storage/v2/constraints.cpp

@@ -97,15 +97,15 @@ bool LastCommittedVersionHasLabelProperty(const Vertex &vertex, LabelId label, c
         if (delta->label == label) {
           MG_ASSERT(!has_label, "Invalid database state!");
           has_label = true;
-          break;
         }
+        break;
       }
       case Delta::Action::REMOVE_LABEL: {
         if (delta->label == label) {
           MG_ASSERT(has_label, "Invalid database state!");
           has_label = false;
-          break;
         }
+        break;
       }
       case Delta::Action::ADD_IN_EDGE:
       case Delta::Action::ADD_OUT_EDGE:

src/storage/v3/CMakeLists.txt

@@ -31,4 +31,4 @@ target_link_libraries(mg-storage-v3 Threads::Threads mg-utils gflags)
 target_include_directories(mg-storage-v3 PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/bindings)
 
 add_dependencies(mg-storage-v3 generate_lcp_storage)
-target_link_libraries(mg-storage-v3 mg-slk mg-expr mg-io)
+target_link_libraries(mg-storage-v3 mg-slk mg-expr mg-io mg-functions)

src/storage/v3/bindings/ast/ast.lcp

@@ -24,6 +24,8 @@
 #include "storage/v3/conversions.hpp"
 #include "storage/v3/path.hpp"
 #include "utils/typeinfo.hpp"
+#include "utils/exceptions.hpp"
+#include "functions/awesome_memgraph_functions.hpp"
 
 cpp<#
 
@@ -178,14 +180,6 @@ cpp<#
   (:serialize (:slk :load-args '((storage "storage::v3::AstStorage *")))))
 
 #>cpp
-struct FunctionContext {
-  DbAccessor *db_accessor;
-  utils::MemoryResource *memory;
-  int64_t timestamp;
-  std::unordered_map<std::string, int64_t> *counters;
-  View view;
-};
-
 inline bool operator==(const LabelIx &a, const LabelIx &b) {
   return a.ix == b.ix && a.name == b.name;
 }
@@ -845,16 +839,24 @@ cpp<#
               :slk-load (slk-load-ast-vector "Expression"))
    (function-name "std::string" :scope :public)
    (function "std::function<TypedValue(const TypedValue *, int64_t,
-                                       const FunctionContext &)>"
+                                       const functions::FunctionContext<memgraph::storage::v3::DbAccessor> &)>"
              :scope :public
              :dont-save t
              :clone :copy
              :slk-load (lambda (member)
                         #>cpp
+                        self->${member} = functions::NameToFunction<memgraph::storage::v3::TypedValue,
+                                            functions::FunctionContext<memgraph::storage::v3::DbAccessor>,
+                                            functions::StorageEngineTag, Conv>(self->function_name_);
                         cpp<#)))
   (:public
     #>cpp
     Function() = default;
+    using Conv = decltype(PropertyToTypedValueFunctor<TypedValue>);
+    class SemanticException : public memgraph::utils::BasicException {
+      using utils::BasicException::BasicException;
+    };
+
 
     DEFVISITABLE(ExpressionVisitor<TypedValue>);
     DEFVISITABLE(ExpressionVisitor<void>);
@@ -872,7 +874,13 @@ cpp<#
     Function(const std::string &function_name,
              const std::vector<Expression *> &arguments)
         : arguments_(arguments),
-          function_name_(function_name) {
+          function_name_(function_name),
+          function_(functions::NameToFunction<memgraph::storage::v3::TypedValue,
+                                            functions::FunctionContext<memgraph::storage::v3::DbAccessor>,
+                                            functions::StorageEngineTag, Conv>(function_name_)) {
+      if (!function_) {
+        throw SemanticException("Function '{}' doesn't exist.", function_name);
+      }
     }
     cpp<#)
   (:private

src/storage/v3/bindings/db_accessor.hpp

@@ -88,7 +88,7 @@ class DbAccessor final {
   }
 
   storage::v3::ShardResult<std::optional<EdgeAccessor>> RemoveEdge(EdgeAccessor *edge) {
-    auto res = accessor_->DeleteEdge(edge->FromVertex(), edge->ToVertex(), edge->Gid());
+    auto res = accessor_->DeleteEdge(edge->From(), edge->To(), edge->Gid());
     if (res.HasError()) {
       return res.GetError();
     }

src/storage/v3/conversions.hpp

@@ -69,6 +69,10 @@ TTypedValue PropertyToTypedValue(const PropertyValue &value) {
   LOG_FATAL("Unsupported type");
 }
 
+template <typename TypedValueT>
+inline const auto PropertyToTypedValueFunctor =
+    [](const PropertyValue &value) { return PropertyToTypedValue<TypedValueT>(value); };
+
 template <typename TTypedValue>
 TTypedValue PropertyToTypedValue(const PropertyValue &value, utils::MemoryResource *mem) {
   switch (value.type()) {

src/storage/v3/edge_accessor.cpp

@@ -51,9 +51,9 @@ bool EdgeAccessor::IsVisible(const View view) const {
   return exists && (for_deleted_ || !deleted);
 }
 
-const VertexId &EdgeAccessor::FromVertex() const { return from_vertex_; }
+const VertexId &EdgeAccessor::From() const { return from_vertex_; }
 
-const VertexId &EdgeAccessor::ToVertex() const { return to_vertex_; }
+const VertexId &EdgeAccessor::To() const { return to_vertex_; }
 
 ShardResult<PropertyValue> EdgeAccessor::SetProperty(PropertyId property, const PropertyValue &value) {
   utils::MemoryTracker::OutOfMemoryExceptionEnabler oom_exception;
@@ -180,4 +180,7 @@ ShardResult<std::map<PropertyId, PropertyValue>> EdgeAccessor::Properties(View v
   return std::move(properties);
 }
 
+// NOLINTNEXTLINE(readability-convert-member-functions-to-static)
+size_t EdgeAccessor::CypherId() const { return Gid().AsUint(); }
+
 }  // namespace memgraph::storage::v3

src/storage/v3/edge_accessor.hpp

@@ -48,9 +48,9 @@ class EdgeAccessor final {
   /// @return true if the object is visible from the current transaction
   bool IsVisible(View view) const;
 
-  const VertexId &FromVertex() const;
+  const VertexId &From() const;
 
-  const VertexId &ToVertex() const;
+  const VertexId &To() const;
 
   EdgeTypeId EdgeType() const { return edge_type_; }
 
@@ -84,6 +84,9 @@ class EdgeAccessor final {
   }
   bool operator!=(const EdgeAccessor &other) const noexcept { return !(*this == other); }
 
+  // Dummy function
+  size_t CypherId() const;
+
  private:
   EdgeRef edge_;
   EdgeTypeId edge_type_;

src/storage/v3/expr.cpp

@@ -52,13 +52,12 @@ msgs::Value ConstructValueEdge(const EdgeAccessor &acc, View view) {
   msgs::EdgeType type = {.id = acc.EdgeType()};
   msgs::EdgeId gid = {.gid = acc.Gid().AsUint()};
 
-  msgs::Label src_prim_label = {.id = acc.FromVertex().primary_label};
+  msgs::Label src_prim_label = {.id = acc.From().primary_label};
   memgraph::msgs::VertexId src_vertex =
-      std::make_pair(src_prim_label, conversions::ConvertValueVector(acc.FromVertex().primary_key));
+      std::make_pair(src_prim_label, conversions::ConvertValueVector(acc.From().primary_key));
 
-  msgs::Label dst_prim_label = {.id = acc.ToVertex().primary_label};
-  msgs::VertexId dst_vertex =
-      std::make_pair(dst_prim_label, conversions::ConvertValueVector(acc.ToVertex().primary_key));
+  msgs::Label dst_prim_label = {.id = acc.To().primary_label};
+  msgs::VertexId dst_vertex = std::make_pair(dst_prim_label, conversions::ConvertValueVector(acc.To().primary_key));
 
   auto properties = acc.Properties(view);
 

src/storage/v3/request_helper.cpp

@@ -221,30 +221,39 @@ std::vector<TypedValue> EvaluateVertexExpressions(DbAccessor &dba, const VertexA
   return evaluated_expressions;
 }
 
+std::vector<TypedValue> EvaluateEdgeExpressions(DbAccessor &dba, const VertexAccessor &v_acc, const EdgeAccessor &e_acc,
+                                                const std::vector<std::string> &expressions) {
+  std::vector<TypedValue> evaluated_expressions;
+  evaluated_expressions.reserve(expressions.size());
+
+  std::transform(expressions.begin(), expressions.end(), std::back_inserter(evaluated_expressions),
+                 [&dba, &v_acc, &e_acc](const auto &expression) {
+                   return ComputeExpression(dba, v_acc, e_acc, expression, expr::identifier_node_symbol,
+                                            expr::identifier_edge_symbol);
+                 });
+
+  return evaluated_expressions;
+}
+
 ShardResult<std::map<PropertyId, Value>> CollectAllPropertiesFromAccessor(const VertexAccessor &acc, View view,
                                                                           const Schemas::Schema &schema) {
-  std::map<PropertyId, Value> ret;
-  auto props = acc.Properties(view);
-  if (props.HasError()) {
-    spdlog::debug("Encountered an error while trying to get vertex properties.");
-    return props.GetError();
+  auto ret = impl::CollectAllPropertiesImpl<VertexAccessor>(acc, view);
+  if (ret.HasError()) {
+    return ret.GetError();
   }
 
-  auto &properties = props.GetValue();
-  std::transform(properties.begin(), properties.end(), std::inserter(ret, ret.begin()),
-                 [](std::pair<const PropertyId, PropertyValue> &pair) {
-                   return std::make_pair(pair.first, FromPropertyValueToValue(std::move(pair.second)));
-                 });
-  properties.clear();
-
   auto pks = PrimaryKeysFromAccessor(acc, view, schema);
   if (pks) {
-    ret.merge(*pks);
+    ret.GetValue().merge(std::move(*pks));
   }
 
   return ret;
 }
 
+ShardResult<std::map<PropertyId, Value>> CollectAllPropertiesFromAccessor(const VertexAccessor &acc, View view) {
+  return impl::CollectAllPropertiesImpl(acc, view);
+}
+
 EdgeUniquenessFunction InitializeEdgeUniquenessFunction(bool only_unique_neighbor_rows) {
   // Functions to select connecting edges based on uniquness
   EdgeUniquenessFunction maybe_filter_based_on_edge_uniquness;
@@ -258,7 +267,7 @@ EdgeUniquenessFunction InitializeEdgeUniquenessFunction(bool only_unique_neighbo
         case msgs::EdgeDirection::OUT: {
           is_edge_unique = [](std::set<const storage::v3::VertexId *, VertexIdCmpr> &other_vertex_set,
                               const storage::v3::EdgeAccessor &edge_acc) {
-            auto [it, insertion_happened] = other_vertex_set.insert(&edge_acc.ToVertex());
+            auto [it, insertion_happened] = other_vertex_set.insert(&edge_acc.To());
             return insertion_happened;
           };
           break;
@@ -266,7 +275,7 @@ EdgeUniquenessFunction InitializeEdgeUniquenessFunction(bool only_unique_neighbo
         case msgs::EdgeDirection::IN: {
           is_edge_unique = [](std::set<const storage::v3::VertexId *, VertexIdCmpr> &other_vertex_set,
                               const storage::v3::EdgeAccessor &edge_acc) {
-            auto [it, insertion_happened] = other_vertex_set.insert(&edge_acc.FromVertex());
+            auto [it, insertion_happened] = other_vertex_set.insert(&edge_acc.From());
             return insertion_happened;
           };
           break;
@@ -312,8 +321,8 @@ EdgeFiller InitializeEdgeFillerFunction(const msgs::ExpandOneRequest &req) {
         value_properties.insert(std::make_pair(prop_key, FromPropertyValueToValue(std::move(prop_val))));
       }
       using EdgeWithAllProperties = msgs::ExpandOneResultRow::EdgeWithAllProperties;
-      EdgeWithAllProperties edges{ToMsgsVertexId(edge.FromVertex()), msgs::EdgeType{edge.EdgeType()},
-                                  edge.Gid().AsUint(), std::move(value_properties)};
+      EdgeWithAllProperties edges{ToMsgsVertexId(edge.From()), msgs::EdgeType{edge.EdgeType()}, edge.Gid().AsUint(),
+                                  std::move(value_properties)};
       if (is_in_edge) {
         result_row.in_edges_with_all_properties.push_back(std::move(edges));
       } else {
@@ -337,7 +346,7 @@ EdgeFiller InitializeEdgeFillerFunction(const msgs::ExpandOneRequest &req) {
         value_properties.emplace_back(FromPropertyValueToValue(std::move(property_result.GetValue())));
       }
       using EdgeWithSpecificProperties = msgs::ExpandOneResultRow::EdgeWithSpecificProperties;
-      EdgeWithSpecificProperties edges{ToMsgsVertexId(edge.FromVertex()), msgs::EdgeType{edge.EdgeType()},
+      EdgeWithSpecificProperties edges{ToMsgsVertexId(edge.From()), msgs::EdgeType{edge.EdgeType()},
                                        edge.Gid().AsUint(), std::move(value_properties)};
       if (is_in_edge) {
         result_row.in_edges_with_specific_properties.push_back(std::move(edges));
@@ -351,15 +360,19 @@ EdgeFiller InitializeEdgeFillerFunction(const msgs::ExpandOneRequest &req) {
   return edge_filler;
 }
 
-bool FilterOnVertex(DbAccessor &dba, const storage::v3::VertexAccessor &v_acc, const std::vector<std::string> &filters,
-                    const std::string_view node_name, const std::optional<EdgeAccessor> &e_acc) {
-  return std::ranges::all_of(filters, [&node_name, &dba, &v_acc, &e_acc](const auto &filter_expr) {
-    TypedValue result;
-    if (e_acc) {
-      result = ComputeExpression(dba, v_acc, e_acc, filter_expr, "", node_name);
-    } else {
-      result = ComputeExpression(dba, v_acc, e_acc, filter_expr, node_name, "");
-    }
+bool FilterOnVertex(DbAccessor &dba, const storage::v3::VertexAccessor &v_acc,
+                    const std::vector<std::string> &filters) {
+  return std::ranges::all_of(filters, [&dba, &v_acc](const auto &filter_expr) {
+    const auto result = ComputeExpression(dba, v_acc, std::nullopt, filter_expr, expr::identifier_node_symbol, "");
+    return result.IsBool() && result.ValueBool();
+  });
+}
+
+bool FilterOnEdge(DbAccessor &dba, const storage::v3::VertexAccessor &v_acc, const EdgeAccessor &e_acc,
+                  const std::vector<std::string> &filters) {
+  return std::ranges::all_of(filters, [&dba, &v_acc, &e_acc](const auto &filter_expr) {
+    const auto result =
+        ComputeExpression(dba, v_acc, e_acc, filter_expr, expr::identifier_node_symbol, expr::identifier_edge_symbol);
     return result.IsBool() && result.ValueBool();
   });
 }
@@ -444,61 +457,6 @@ ShardResult<msgs::ExpandOneResultRow> GetExpandOneResult(
   return result_row;
 }
 
-std::vector<GetPropElement> OrderByElements(DbAccessor &dba, std::vector<msgs::OrderBy> &order_by,
-                                            std::vector<GetPropElement> &&vertices) {
-  std::vector<Ordering> ordering;
-  ordering.reserve(order_by.size());
-  for (const auto &order : order_by) {
-    switch (order.direction) {
-      case memgraph::msgs::OrderingDirection::ASCENDING: {
-        ordering.push_back(Ordering::ASC);
-        break;
-      }
-      case memgraph::msgs::OrderingDirection::DESCENDING: {
-        ordering.push_back(Ordering::DESC);
-        break;
-      }
-    }
-  }
-  struct PropElement {
-    std::vector<TypedValue> properties_order_by;
-    VertexAccessor vertex_acc;
-    GetPropElement *original_element;
-  };
-
-  std::vector<PropElement> ordered;
-  auto compare_typed_values = TypedValueVectorCompare(ordering);
-  for (auto &vertex : vertices) {
-    std::vector<TypedValue> properties;
-    properties.reserve(order_by.size());
-    const auto *symbol = (vertex.edge_acc) ? expr::identifier_edge_symbol : expr::identifier_node_symbol;
-    for (const auto &order : order_by) {
-      TypedValue val;
-      if (vertex.edge_acc) {
-        val = ComputeExpression(dba, vertex.vertex_acc, vertex.edge_acc, order.expression.expression, "", symbol);
-      } else {
-        val = ComputeExpression(dba, vertex.vertex_acc, vertex.edge_acc, order.expression.expression, symbol, "");
-      }
-      properties.push_back(std::move(val));
-    }
-
-    ordered.push_back({std::move(properties), vertex.vertex_acc, &vertex});
-  }
-
-  std::sort(ordered.begin(), ordered.end(), [&compare_typed_values](const auto &lhs, const auto &rhs) {
-    return compare_typed_values(lhs.properties_order_by, rhs.properties_order_by);
-  });
-
-  std::vector<GetPropElement> results_ordered;
-  results_ordered.reserve(ordered.size());
-
-  for (auto &elem : ordered) {
-    results_ordered.push_back(std::move(*elem.original_element));
-  }
-
-  return results_ordered;
-}
-
 VerticesIterable::Iterator GetStartVertexIterator(VerticesIterable &vertex_iterable,
                                                   const std::vector<PropertyValue> &primary_key, const View view) {
   auto it = vertex_iterable.begin();
@@ -533,12 +491,14 @@ std::array<std::vector<EdgeAccessor>, 2> GetEdgesFromVertex(const VertexAccessor
       if (edges.HasValue()) {
         in_edges = edges.GetValue();
       }
+      break;
     }
     case memgraph::msgs::EdgeDirection::OUT: {
       auto edges = vertex_accessor.OutEdges(View::OLD);
       if (edges.HasValue()) {
         out_edges = edges.GetValue();
       }
+      break;
     }
     case memgraph::msgs::EdgeDirection::BOTH: {
       auto maybe_in_edges = vertex_accessor.InEdges(View::OLD);
@@ -550,6 +510,7 @@ std::array<std::vector<EdgeAccessor>, 2> GetEdgesFromVertex(const VertexAccessor
       if (maybe_out_edges.HasValue()) {
         out_edges = maybe_out_edges.GetValue();
       }
+      break;
     }
   }
 
@@ -584,4 +545,36 @@ std::vector<Element<EdgeAccessor>> OrderByEdges(DbAccessor &dba, std::vector<Edg
   return ordered;
 }
 
+std::vector<Element<std::pair<VertexAccessor, EdgeAccessor>>> OrderByEdges(
+    DbAccessor &dba, std::vector<EdgeAccessor> &iterable, std::vector<msgs::OrderBy> &order_by_edges,
+    const std::vector<VertexAccessor> &vertex_acc) {
+  MG_ASSERT(vertex_acc.size() == iterable.size());
+  std::vector<Ordering> ordering;
+  ordering.reserve(order_by_edges.size());
+  std::transform(order_by_edges.begin(), order_by_edges.end(), std::back_inserter(ordering),
+                 [](const auto &order_by) { return ConvertMsgsOrderByToOrdering(order_by.direction); });
+
+  std::vector<Element<std::pair<VertexAccessor, EdgeAccessor>>> ordered;
+  VertexAccessor current = vertex_acc.front();
+  size_t id = 0;
+  for (auto it = iterable.begin(); it != iterable.end(); it++, id++) {
+    current = vertex_acc[id];
+    std::vector<TypedValue> properties_order_by;
+    properties_order_by.reserve(order_by_edges.size());
+    std::transform(order_by_edges.begin(), order_by_edges.end(), std::back_inserter(properties_order_by),
+                   [&dba, it, current](const auto &order_by) {
+                     return ComputeExpression(dba, current, *it, order_by.expression.expression,
+                                              expr::identifier_node_symbol, expr::identifier_edge_symbol);
+                   });
+
+    ordered.push_back({std::move(properties_order_by), {current, *it}});
+  }
+
+  auto compare_typed_values = TypedValueVectorCompare(ordering);
+  std::sort(ordered.begin(), ordered.end(), [compare_typed_values](const auto &pair1, const auto &pair2) {
+    return compare_typed_values(pair1.properties_order_by, pair2.properties_order_by);
+  });
+  return ordered;
+}
+
 }  // namespace memgraph::storage::v3

src/storage/v3/request_helper.hpp

@@ -20,6 +20,7 @@
 #include "storage/v3/edge_accessor.hpp"
 #include "storage/v3/expr.hpp"
 #include "storage/v3/shard.hpp"
+#include "storage/v3/value_conversions.hpp"
 #include "storage/v3/vertex_accessor.hpp"
 #include "utils/template_utils.hpp"
 
@@ -31,7 +32,7 @@ using EdgeFiller =
 using msgs::Value;
 
 template <typename T>
-concept ObjectAccessor = utils::SameAsAnyOf<T, VertexAccessor, EdgeAccessor>;
+concept OrderableObject = utils::SameAsAnyOf<T, VertexAccessor, EdgeAccessor, std::pair<VertexAccessor, EdgeAccessor>>;
 
 inline bool TypedValueCompare(const TypedValue &a, const TypedValue &b) {
   // in ordering null comes after everything else
@@ -125,19 +126,12 @@ class TypedValueVectorCompare final {
   std::vector<Ordering> ordering_;
 };
 
-template <ObjectAccessor TObjectAccessor>
+template <OrderableObject TObjectAccessor>
 struct Element {
   std::vector<TypedValue> properties_order_by;
   TObjectAccessor object_acc;
 };
 
-struct GetPropElement {
-  std::vector<TypedValue> properties_order_by;
-  std::vector<PropertyId> ids;
-  VertexAccessor vertex_acc;
-  std::optional<EdgeAccessor> edge_acc;
-};
-
 template <typename T>
 concept VerticesIt = utils::SameAsAnyOf<T, VerticesIterable, std::vector<VertexAccessor>>;
 
@@ -174,8 +168,9 @@ std::vector<Element<EdgeAccessor>> OrderByEdges(DbAccessor &dba, std::vector<Edg
                                                 std::vector<msgs::OrderBy> &order_by_edges,
                                                 const VertexAccessor &vertex_acc);
 
-std::vector<GetPropElement> OrderByElements(DbAccessor &dba, std::vector<msgs::OrderBy> &order_bys,
-                                            std::vector<GetPropElement> &&vertices);
+std::vector<Element<std::pair<VertexAccessor, EdgeAccessor>>> OrderByEdges(
+    DbAccessor &dba, std::vector<EdgeAccessor> &iterable, std::vector<msgs::OrderBy> &order_by_edges,
+    const std::vector<VertexAccessor> &vertex_acc);
 
 VerticesIterable::Iterator GetStartVertexIterator(VerticesIterable &vertex_iterable,
                                                   const std::vector<PropertyValue> &primary_key, View view);
@@ -187,19 +182,65 @@ std::vector<Element<VertexAccessor>>::const_iterator GetStartOrderedElementsIter
 std::array<std::vector<EdgeAccessor>, 2> GetEdgesFromVertex(const VertexAccessor &vertex_accessor,
                                                             msgs::EdgeDirection direction);
 
-bool FilterOnVertex(DbAccessor &dba, const storage::v3::VertexAccessor &v_acc, const std::vector<std::string> &filters,
-                    const std::string_view node_name, const std::optional<EdgeAccessor> &e_acc = std::nullopt);
+bool FilterOnVertex(DbAccessor &dba, const storage::v3::VertexAccessor &v_acc, const std::vector<std::string> &filters);
+
+bool FilterOnEdge(DbAccessor &dba, const storage::v3::VertexAccessor &v_acc, const EdgeAccessor &e_acc,
+                  const std::vector<std::string> &filters);
 
 std::vector<TypedValue> EvaluateVertexExpressions(DbAccessor &dba, const VertexAccessor &v_acc,
                                                   const std::vector<std::string> &expressions,
                                                   std::string_view node_name);
 
-ShardResult<std::map<PropertyId, Value>> CollectSpecificPropertiesFromAccessor(const VertexAccessor &acc,
+std::vector<TypedValue> EvaluateEdgeExpressions(DbAccessor &dba, const VertexAccessor &v_acc, const EdgeAccessor &e_acc,
+                                                const std::vector<std::string> &expressions);
+
+template <typename T>
+concept PropertiesAccessor = utils::SameAsAnyOf<T, VertexAccessor, EdgeAccessor>;
+
+template <PropertiesAccessor TAccessor>
+ShardResult<std::map<PropertyId, Value>> CollectSpecificPropertiesFromAccessor(const TAccessor &acc,
                                                                                const std::vector<PropertyId> &props,
-                                                                               View view);
+                                                                               View view) {
+  std::map<PropertyId, Value> ret;
+
+  for (const auto &prop : props) {
+    auto result = acc.GetProperty(prop, view);
+    if (result.HasError()) {
+      spdlog::debug("Encountered an Error while trying to get a vertex property.");
+      return result.GetError();
+    }
+    auto &value = result.GetValue();
+    ret.emplace(std::make_pair(prop, FromPropertyValueToValue(std::move(value))));
+  }
+
+  return ret;
+}
 
 ShardResult<std::map<PropertyId, Value>> CollectAllPropertiesFromAccessor(const VertexAccessor &acc, View view,
                                                                           const Schemas::Schema &schema);
+namespace impl {
+template <PropertiesAccessor TAccessor>
+ShardResult<std::map<PropertyId, Value>> CollectAllPropertiesImpl(const TAccessor &acc, View view) {
+  std::map<PropertyId, Value> ret;
+  auto props = acc.Properties(view);
+  if (props.HasError()) {
+    spdlog::debug("Encountered an error while trying to get vertex properties.");
+    return props.GetError();
+  }
+
+  auto &properties = props.GetValue();
+  std::transform(properties.begin(), properties.end(), std::inserter(ret, ret.begin()),
+                 [](std::pair<const PropertyId, PropertyValue> &pair) {
+                   return std::make_pair(pair.first, conversions::FromPropertyValueToValue(std::move(pair.second)));
+                 });
+  return ret;
+}
+}  // namespace impl
+
+template <PropertiesAccessor TAccessor>
+ShardResult<std::map<PropertyId, Value>> CollectAllPropertiesFromAccessor(const TAccessor &acc, View view) {
+  return impl::CollectAllPropertiesImpl<TAccessor>(acc, view);
+}
 
 EdgeUniquenessFunction InitializeEdgeUniquenessFunction(bool only_unique_neighbor_rows);
 

src/storage/v3/shard.cpp

@@ -442,7 +442,7 @@ ShardResult<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>>
   for (const auto &item : in_edges) {
     auto [edge_type, from_vertex, edge] = item;
     EdgeAccessor e(edge, edge_type, from_vertex, vertex_id, transaction_, &shard_->indices_, config_);
-    auto ret = DeleteEdge(e.FromVertex(), e.ToVertex(), e.Gid());
+    auto ret = DeleteEdge(e.From(), e.To(), e.Gid());
     if (ret.HasError()) {
       MG_ASSERT(ret.GetError() == common::ErrorCode::SERIALIZATION_ERROR, "Invalid database state!");
       return ret.GetError();
@@ -455,7 +455,7 @@ ShardResult<std::optional<std::pair<VertexAccessor, std::vector<EdgeAccessor>>>>
   for (const auto &item : out_edges) {
     auto [edge_type, to_vertex, edge] = item;
     EdgeAccessor e(edge, edge_type, vertex_id, to_vertex, transaction_, &shard_->indices_, config_);
-    auto ret = DeleteEdge(e.FromVertex(), e.ToVertex(), e.Gid());
+    auto ret = DeleteEdge(e.From(), e.To(), e.Gid());
     if (ret.HasError()) {
       MG_ASSERT(ret.GetError() == common::ErrorCode::SERIALIZATION_ERROR, "Invalid database state!");
       return ret.GetError();

src/storage/v3/shard_rsm.cpp

@@ -10,6 +10,8 @@
 // licenses/APL.txt.
 
 #include <algorithm>
+#include <exception>
+#include <experimental/source_location>
 #include <functional>
 #include <iterator>
 #include <optional>
@@ -19,7 +21,6 @@
 
 #include "common/errors.hpp"
 #include "parser/opencypher/parser.hpp"
-#include "pretty_print_ast_to_original_expression.hpp"
 #include "query/v2/requests.hpp"
 #include "storage/v2/vertex.hpp"
 #include "storage/v2/view.hpp"
@@ -330,7 +331,7 @@ msgs::ReadResponses ShardRsm::HandleRead(msgs::ScanVerticesRequest &&req) {
     std::vector<Value> expression_results;
     if (!req.filter_expressions.empty()) {
       // NOTE - DbAccessor might get removed in the future.
-      const bool eval = FilterOnVertex(dba, vertex, req.filter_expressions, expr::identifier_node_symbol);
+      const bool eval = FilterOnVertex(dba, vertex, req.filter_expressions);
       if (!eval) {
         return;
       }
@@ -435,7 +436,7 @@ msgs::ReadResponses ShardRsm::HandleRead(msgs::ExpandOneRequest &&req) {
     }
     if (!req.filters.empty()) {
       // NOTE - DbAccessor might get removed in the future.
-      const bool eval = FilterOnVertex(dba, src_vertex_acc_opt.value(), req.filters, expr::identifier_node_symbol);
+      const bool eval = FilterOnVertex(dba, src_vertex_acc_opt.value(), req.filters);
       if (!eval) {
         continue;
       }
@@ -515,127 +516,190 @@ msgs::WriteResponses ShardRsm::ApplyWrite(msgs::CommitRequest &&req) {
 };
 
 msgs::ReadResponses ShardRsm::HandleRead(msgs::GetPropertiesRequest &&req) {
-  if (req.vertices_and_edges.empty()) {
-    return msgs::GetPropertiesResponse{.result = msgs::GetPropertiesResponse::FAILURE};
-  }
-  if (req.property_ids.empty()) {
-    return msgs::GetPropertiesResponse{.result = msgs::GetPropertiesResponse::SUCCESS};
+  if (!req.vertex_ids.empty() && !req.vertices_and_edges.empty()) {
+    auto shard_error = SHARD_ERROR(ErrorCode::NONEXISTENT_OBJECT);
+    auto error = CreateErrorResponse(shard_error, req.transaction_id, "");
+    return msgs::GetPropertiesResponse{.error = {}};
   }
 
   auto shard_acc = shard_->Access(req.transaction_id);
   auto dba = DbAccessor{&shard_acc};
   const auto view = storage::v3::View::NEW;
 
-  auto collect_props = [](const VertexAccessor &acc, const std::vector<PropertyId> &props, View view,
-                          const std::optional<EdgeAccessor> &e_acc) mutable -> std::optional<GetPropElement> {
-    std::vector<TypedValue> properties;
-    std::vector<PropertyId> ids;
-    for (const auto &prop : props) {
-      ShardResult<PropertyValue> result{PropertyValue()};
-      if (e_acc) {
-        result = e_acc->GetProperty(prop, view);
-      } else {
-        result = acc.GetProperty(prop, view);
-      }
-      if (result.HasError() && result.GetError() == common::ErrorCode::NONEXISTENT_OBJECT) {
-        continue;
-      }
-      if (result.HasError()) {
-        spdlog::debug("Encountered an Error while trying to get a vertex property.");
-        return std::nullopt;
-      }
-      properties.push_back(PropertyToTypedValue<TypedValue>(result.GetValue()));
-      ids.push_back(prop);
+  auto transform_props = [](std::map<PropertyId, Value> &&value) {
+    std::vector<std::pair<PropertyId, Value>> result;
+    result.reserve(value.size());
+    for (auto &[id, val] : value) {
+      result.emplace_back(std::make_pair(id, std::move(val)));
     }
-    GetPropElement element{std::move(properties), std::move(ids), acc, e_acc};
-    return {std::move(element)};
+    return result;
   };
 
-  auto find_edge = [](const VertexAccessor &v, const EdgeTypeId &e) -> std::optional<EdgeAccessor> {
-    auto in = v.InEdges(view, {e});
+  auto collect_props = [&req](const VertexAccessor &v_acc,
+                              const std::optional<EdgeAccessor> &e_acc) -> ShardResult<std::map<PropertyId, Value>> {
+    if (!req.property_ids) {
+      if (e_acc) {
+        return CollectAllPropertiesFromAccessor(*e_acc, view);
+      }
+      return CollectAllPropertiesFromAccessor(v_acc, view);
+    }
+
+    if (e_acc) {
+      return CollectSpecificPropertiesFromAccessor(*e_acc, *req.property_ids, view);
+    }
+    return CollectSpecificPropertiesFromAccessor(v_acc, *req.property_ids, view);
+  };
+
+  auto find_edge = [](const VertexAccessor &v, msgs::EdgeId e) -> std::optional<EdgeAccessor> {
+    auto in = v.InEdges(view);
     MG_ASSERT(in.HasValue());
     for (auto &edge : in.GetValue()) {
-      if (edge.EdgeType() == e) {
+      if (edge.Gid().AsUint() == e.gid) {
         return edge;
       }
     }
-
-    auto out = v.OutEdges(view, {e});
+    auto out = v.OutEdges(view);
     MG_ASSERT(out.HasValue());
     for (auto &edge : out.GetValue()) {
-      if (edge.EdgeType() == e) {
+      if (edge.Gid().AsUint() == e.gid) {
         return edge;
       }
     }
     return std::nullopt;
   };
 
-  std::vector<GetPropElement> elements;
-
-  for (const auto &[vertex, maybe_edge] : req.vertices_and_edges) {
-    const auto &[label, pk_v] = vertex;
-    auto pk = ConvertPropertyVector(pk_v);
-    auto v_acc = dba.FindVertex(pk, view);
-    if (!v_acc) {
-      return msgs::GetPropertiesResponse{.result = msgs::GetPropertiesResponse::OUT_OF_SHARD_RANGE};
+  const auto has_expr_to_evaluate = !req.expressions.empty();
+  auto emplace_result_row =
+      [dba, transform_props, collect_props, has_expr_to_evaluate, &req](
+          const VertexAccessor &v_acc,
+          const std::optional<EdgeAccessor> e_acc) mutable -> ShardResult<msgs::GetPropertiesResultRow> {
+    auto maybe_id = v_acc.Id(view);
+    if (maybe_id.HasError()) {
+      return {maybe_id.GetError()};
     }
-    std::optional<EdgeAccessor> e_acc;
-    if (maybe_edge) {
-      e_acc = find_edge(*v_acc, *maybe_edge);
-      if (!e_acc) {
-        return msgs::GetPropertiesResponse{.result = msgs::GetPropertiesResponse::OUT_OF_SHARD_RANGE};
+    const auto &id = maybe_id.GetValue();
+    std::optional<msgs::EdgeId> e_id;
+    if (e_acc) {
+      e_id = msgs::EdgeId{e_acc->Gid().AsUint()};
+    }
+    msgs::VertexId v_id{msgs::Label{id.primary_label}, ConvertValueVector(id.primary_key)};
+    auto maybe_props = collect_props(v_acc, e_acc);
+    if (maybe_props.HasError()) {
+      return {maybe_props.GetError()};
+    }
+    auto props = transform_props(std::move(maybe_props.GetValue()));
+    auto result = msgs::GetPropertiesResultRow{.vertex = std::move(v_id), .edge = e_id, .props = std::move(props)};
+    if (has_expr_to_evaluate) {
+      std::vector<Value> e_results;
+      if (e_acc) {
+        e_results =
+            ConvertToValueVectorFromTypedValueVector(EvaluateEdgeExpressions(dba, v_acc, *e_acc, req.expressions));
+      } else {
+        e_results = ConvertToValueVectorFromTypedValueVector(
+            EvaluateVertexExpressions(dba, v_acc, req.expressions, expr::identifier_node_symbol));
       }
+      result.evaluated_expressions = std::move(e_results);
+    }
+    return {std::move(result)};
+  };
+
+  auto get_limit = [&req](const auto &elements) {
+    size_t limit = elements.size();
+    if (req.limit && *req.limit < elements.size()) {
+      limit = *req.limit;
+    }
+    return limit;
+  };
+
+  auto collect_response = [get_limit, &req](auto &elements, auto create_result_row) {
+    msgs::GetPropertiesResponse response;
+    const auto limit = get_limit(elements);
+    for (size_t index = 0; index != limit; ++index) {
+      auto result_row = create_result_row(elements[index]);
+      if (result_row.HasError()) {
+        return msgs::GetPropertiesResponse{.error = CreateErrorResponse(result_row.GetError(), req.transaction_id, "")};
+      }
+      response.result_row.push_back(std::move(result_row.GetValue()));
+    }
+    return response;
+  };
+
+  std::vector<VertexAccessor> vertices;
+  std::vector<EdgeAccessor> edges;
+
+  auto parse_and_filter = [dba, &vertices](auto &container, auto projection, auto filter, auto maybe_get_edge) mutable {
+    for (const auto &elem : container) {
+      const auto &[label, pk_v] = projection(elem);
+      auto pk = ConvertPropertyVector(pk_v);
+      auto v_acc = dba.FindVertex(pk, view);
+      if (!v_acc || filter(*v_acc, maybe_get_edge(elem))) {
+        continue;
+      }
+      vertices.push_back(*v_acc);
+    }
+  };
+  auto identity = [](auto &elem) { return elem; };
+
+  auto filter_vertex = [dba, req](const auto &acc, const auto & /*edge*/) mutable {
+    if (!req.filter) {
+      return false;
+    }
+    return !FilterOnVertex(dba, acc, {*req.filter});
+  };
+
+  auto filter_edge = [dba, &edges, &req, find_edge](const auto &acc, const auto &edge) mutable {
+    auto e_acc = find_edge(acc, edge);
+    if (!e_acc) {
+      return true;
     }
 
-    const auto *symbol = (maybe_edge) ? expr::identifier_edge_symbol : expr::identifier_node_symbol;
-    if (req.filter && !FilterOnVertex(dba, *v_acc, {*req.filter}, symbol, e_acc)) {
-      continue;
+    if (req.filter && !FilterOnEdge(dba, acc, *e_acc, {*req.filter})) {
+      return true;
     }
+    edges.push_back(*e_acc);
+    return false;
+  };
 
-    std::optional<GetPropElement> collected_properties;
-    collected_properties = collect_props(*v_acc, req.property_ids, view, e_acc);
-    if (!collected_properties) {
-      return msgs::GetPropertiesResponse{.result = msgs::GetPropertiesResponse::FAILURE};
+  // Handler logic here
+  if (!req.vertex_ids.empty()) {
+    parse_and_filter(req.vertex_ids, identity, filter_vertex, identity);
+  } else {
+    parse_and_filter(
+        req.vertices_and_edges, [](auto &e) { return e.first; }, filter_edge, [](auto &e) { return e.second; });
+  }
+
+  if (!req.vertex_ids.empty()) {
+    if (!req.order_by.empty()) {
+      auto elements = OrderByVertices(dba, vertices, req.order_by);
+      return collect_response(elements, [emplace_result_row](auto &element) mutable {
+        return emplace_result_row(element.object_acc, std::nullopt);
+      });
     }
-    if (collected_properties->ids.empty()) {
-      continue;
-    }
-    elements.push_back(std::move(*collected_properties));
+    return collect_response(vertices,
+                            [emplace_result_row](auto &acc) mutable { return emplace_result_row(acc, std::nullopt); });
   }
 
   if (!req.order_by.empty()) {
-    elements = OrderByElements(dba, req.order_by, std::move(elements));
+    auto elements = OrderByEdges(dba, edges, req.order_by, vertices);
+    return collect_response(elements, [emplace_result_row](auto &element) mutable {
+      return emplace_result_row(element.object_acc.first, element.object_acc.second);
+    });
   }
 
-  std::vector<msgs::GetPropertiesResultRow> results;
-  results.reserve(elements.size());
+  struct ZipView {
+    ZipView(std::vector<VertexAccessor> &v, std::vector<EdgeAccessor> &e) : v(v), e(e) {}
+    size_t size() const { return v.size(); }
+    auto operator[](size_t index) { return std::make_pair(v[index], e[index]); }
 
-  const auto has_expr_to_evaluate = !req.expressions.empty();
-  size_t limit = elements.size();
-  if (req.limit && *req.limit < elements.size()) {
-    limit = *req.limit;
-  }
-  for (size_t index = 0; index != limit; ++index) {
-    auto &element = elements.at(index);
-    const auto id = element.vertex_acc.Id(view).GetValue();
-    std::optional<EdgeTypeId> e_type =
-        (element.edge_acc) ? std::make_optional(element.edge_acc->EdgeType()) : std::nullopt;
-    msgs::VertexId v_id{msgs::Label{id.primary_label}, ConvertValueVector(id.primary_key)};
-    results.push_back(msgs::GetPropertiesResultRow{
-        .vertex_and_edge = {.vertex = std::move(v_id), .edge = e_type},
-        .properies_and_ids = {
-            .ids = std::move(element.ids),
-            .properties = ConvertToValueVectorFromTypedValueVector(std::move(element.properties_order_by))}});
-    if (has_expr_to_evaluate) {
-      auto expression_results = ConvertToValueVectorFromTypedValueVector(
-          EvaluateVertexExpressions(dba, element.vertex_acc, req.expressions, expr::identifier_node_symbol));
-      results.back().evaluated_expressions = std::move(expression_results);
-    }
-  }
+   private:
+    std::vector<VertexAccessor> &v;
+    std::vector<EdgeAccessor> &e;
+  };
 
-  return msgs::GetPropertiesResponse{std::move(results), msgs::GetPropertiesResponse::SUCCESS};
+  ZipView vertices_and_edges(vertices, edges);
+  return collect_response(vertices_and_edges, [emplace_result_row](const auto &acc) mutable {
+    return emplace_result_row(acc.first, acc.second);
+  });
 }
 
-// TODO(kostasrim) Handle edges
-
 }  // namespace memgraph::storage::v3

tests/e2e/distributed_queries/CMakeLists.txt

@@ -9,3 +9,4 @@ distributed_queries_e2e_python_files(order_by_and_limit.py)
 distributed_queries_e2e_python_files(distinct.py)
 distributed_queries_e2e_python_files(optional_match.py)
 distributed_queries_e2e_python_files(common.py)
+distributed_queries_e2e_python_files(awesome_memgraph_functions.py)

tests/e2e/distributed_queries/awesome_memgraph_functions.py

@@ -0,0 +1,93 @@
+# 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.
+
+import sys
+
+import mgclient
+import pytest
+
+from common import (
+    connection,
+    execute_and_fetch_all,
+    has_n_result_row,
+    wait_for_shard_manager_to_initialize,
+)
+
+
+def test_awesome_memgraph_functions(connection):
+    wait_for_shard_manager_to_initialize()
+    cursor = connection.cursor()
+
+    assert has_n_result_row(cursor, "CREATE (n :label {property:1})", 0)
+    assert has_n_result_row(cursor, "CREATE (n :label {property:2})", 0)
+    assert has_n_result_row(cursor, "CREATE (n :label {property:3})", 0)
+    assert has_n_result_row(cursor, "CREATE (n :label {property:4})", 0)
+    assert has_n_result_row(cursor, "CREATE (n :label {property:10})", 0)
+
+    results = execute_and_fetch_all(cursor, "MATCH (n) WITH COLLECT(n) as nn RETURN SIZE(nn)")
+    assert len(results) == 1
+    assert results[0][0] == 5
+
+    results = execute_and_fetch_all(cursor, "MATCH (n) WITH COLLECT(n.property) as nn RETURN ALL(i IN nn WHERE i > 0)")
+    assert len(results) == 1
+    assert results[0][0] == True
+
+    results = execute_and_fetch_all(cursor, """RETURN CONTAINS("Pineapple", "P")""")
+    assert len(results) == 1
+    assert results[0][0] == True
+
+    results = execute_and_fetch_all(cursor, """RETURN ENDSWITH("Pineapple", "e")""")
+    assert len(results) == 1
+    assert results[0][0] == True
+
+    results = execute_and_fetch_all(cursor, """RETURN LEFT("Pineapple", 1)""")
+    assert len(results) == 1
+    assert results[0][0] == "P"
+
+    results = execute_and_fetch_all(cursor, """RETURN RIGHT("Pineapple", 1)""")
+    assert len(results) == 1
+    assert results[0][0] == "e"
+
+    results = execute_and_fetch_all(cursor, """RETURN REVERSE("Apple")""")
+    assert len(results) == 1
+    assert results[0][0] == "elppA"
+
+    results = execute_and_fetch_all(cursor, """RETURN REPLACE("Apple", "A", "a")""")
+    assert len(results) == 1
+    assert results[0][0] == "apple"
+
+    results = execute_and_fetch_all(cursor, """RETURN TOLOWER("Apple")""")
+    assert len(results) == 1
+    assert results[0][0] == "apple"
+
+    results = execute_and_fetch_all(cursor, """RETURN TOUPPER("Apple")""")
+    assert len(results) == 1
+    assert results[0][0] == "APPLE"
+
+    results = execute_and_fetch_all(cursor, """RETURN TRIM("   Apple")""")
+    assert len(results) == 1
+    assert results[0][0] == "Apple"
+
+    results = execute_and_fetch_all(cursor, """RETURN SPLIT("Apple.Apple", ".")""")
+    assert len(results) == 1
+    assert results[0][0] == ["Apple", "Apple"]
+
+    results = execute_and_fetch_all(cursor, """RETURN LOG10(100)""")
+    assert len(results) == 1
+    assert results[0][0] == 2
+
+    results = execute_and_fetch_all(cursor, """RETURN SQRT(4)""")
+    assert len(results) == 1
+    assert results[0][0] == 2
+
+
+if __name__ == "__main__":
+    sys.exit(pytest.main([__file__, "-rA"]))

tests/e2e/distributed_queries/workloads.yaml

@@ -36,3 +36,8 @@ workloads:
     binary: "tests/e2e/pytest_runner.sh"
     args: ["distributed_queries/optional_match.py"]
     <<: *template_cluster
+
+  - name: "Awesome memgraph functions"
+    binary: "tests/e2e/pytest_runner.sh"
+    args: ["distributed_queries/awesome_memgraph_functions.py"]
+    <<: *template_cluster

tests/simulation/CMakeLists.txt

@@ -32,4 +32,4 @@ add_simulation_test(trial_query_storage/query_storage_test.cpp)
 add_simulation_test(sharded_map.cpp)
 add_simulation_test(shard_rsm.cpp)
 add_simulation_test(cluster_property_test.cpp)
-add_simulation_test(shard_request_manager.cpp)
+add_simulation_test(request_router.cpp)

tests/simulation/common.hpp

@@ -76,14 +76,10 @@ class MockedShardRsm {
   using WriteRequests = msgs::WriteRequests;
   using WriteResponses = msgs::WriteResponses;
 
-  //  ExpandOneResponse Read(ExpandOneRequest rqst);
-  //  GetPropertiesResponse Read(GetPropertiesRequest rqst);
   msgs::ScanVerticesResponse ReadImpl(msgs::ScanVerticesRequest rqst) {
     msgs::ScanVerticesResponse ret;
     auto as_prop_val = storage::conversions::ConvertPropertyVector(rqst.start_id.second);
-    if (!IsKeyInRange(as_prop_val)) {
-      ret.success = false;
-    } else if (as_prop_val == ShardRsmKey{PropertyValue(0), PropertyValue(0)}) {
+    if (as_prop_val == ShardRsmKey{PropertyValue(0), PropertyValue(0)}) {
       msgs::Value val(int64_t(0));
       ret.next_start_id = std::make_optional<msgs::VertexId>();
       ret.next_start_id->second =
@@ -91,37 +87,46 @@ class MockedShardRsm {
       msgs::ScanResultRow result;
       result.props.push_back(std::make_pair(msgs::PropertyId::FromUint(0), val));
       ret.results.push_back(std::move(result));
-      ret.success = true;
     } else if (as_prop_val == ShardRsmKey{PropertyValue(1), PropertyValue(0)}) {
       msgs::ScanResultRow result;
       msgs::Value val(int64_t(1));
       result.props.push_back(std::make_pair(msgs::PropertyId::FromUint(0), val));
       ret.results.push_back(std::move(result));
-      ret.success = true;
     } else if (as_prop_val == ShardRsmKey{PropertyValue(12), PropertyValue(13)}) {
       msgs::ScanResultRow result;
       msgs::Value val(int64_t(444));
       result.props.push_back(std::make_pair(msgs::PropertyId::FromUint(0), val));
       ret.results.push_back(std::move(result));
-      ret.success = true;
-    } else {
-      ret.success = false;
     }
     return ret;
   }
 
   msgs::ExpandOneResponse ReadImpl(msgs::ExpandOneRequest rqst) { return {}; }
-  msgs::ExpandOneResponse ReadImpl(msgs::GetPropertiesRequest rqst) { return {}; }
+  msgs::GetPropertiesResponse ReadImpl(msgs::GetPropertiesRequest rqst) {
+    msgs::GetPropertiesResponse resp;
+    auto &vertices = rqst.vertex_ids;
+    for (auto &vertex : vertices) {
+      auto as_prop_val = storage::conversions::ConvertPropertyVector(vertex.second);
+      if (as_prop_val == ShardRsmKey{PropertyValue(0), PropertyValue(0)}) {
+        resp.result_row.push_back(msgs::GetPropertiesResultRow{.vertex = std::move(vertex)});
+      } else if (as_prop_val == ShardRsmKey{PropertyValue(1), PropertyValue(0)}) {
+        resp.result_row.push_back(msgs::GetPropertiesResultRow{.vertex = std::move(vertex)});
+      } else if (as_prop_val == ShardRsmKey{PropertyValue(13), PropertyValue(13)}) {
+        resp.result_row.push_back(msgs::GetPropertiesResultRow{.vertex = std::move(vertex)});
+      }
+    }
+    return resp;
+  }
 
   ReadResponses Read(ReadRequests read_requests) {
     return {std::visit([this]<typename T>(T &&request) { return ReadResponses{ReadImpl(std::forward<T>(request))}; },
                        std::move(read_requests))};
   }
 
-  msgs::CreateVerticesResponse ApplyImpl(msgs::CreateVerticesRequest rqst) { return {.success = true}; }
+  msgs::CreateVerticesResponse ApplyImpl(msgs::CreateVerticesRequest rqst) { return {}; }
   msgs::DeleteVerticesResponse ApplyImpl(msgs::DeleteVerticesRequest rqst) { return {}; }
   msgs::UpdateVerticesResponse ApplyImpl(msgs::UpdateVerticesRequest rqst) { return {}; }
-  msgs::CreateExpandResponse ApplyImpl(msgs::CreateExpandRequest rqst) { return {.success = true}; }
+  msgs::CreateExpandResponse ApplyImpl(msgs::CreateExpandRequest rqst) { return {}; }
   msgs::DeleteEdgesResponse ApplyImpl(msgs::DeleteEdgesRequest rqst) { return {}; }
   msgs::UpdateEdgesResponse ApplyImpl(msgs::UpdateEdgesRequest rqst) { return {}; }
   msgs::CommitResponse ApplyImpl(msgs::CommitRequest rqst) { return {}; }

tests/simulation/request_router.cpp

@@ -31,8 +31,8 @@
 #include "io/simulator/simulator_transport.hpp"
 #include "query/v2/accessors.hpp"
 #include "query/v2/conversions.hpp"
+#include "query/v2/request_router.hpp"
 #include "query/v2/requests.hpp"
-#include "query/v2/shard_request_manager.hpp"
 #include "storage/v3/property_value.hpp"
 #include "utils/result.hpp"
 
@@ -151,10 +151,8 @@ void RunStorageRaft(Raft<IoImpl, MockedShardRsm, WriteRequests, WriteResponses,
   server.Run();
 }
 
-void TestScanVertices(msgs::ShardRequestManagerInterface &io) {
-  msgs::ExecutionState<ScanVerticesRequest> state{.label = "test_label"};
-
-  auto result = io.Request(state);
+void TestScanVertices(query::v2::RequestRouterInterface &request_router) {
+  auto result = request_router.ScanVertices("test_label");
   MG_ASSERT(result.size() == 2);
   {
     auto prop = result[0].GetProperty(msgs::PropertyId::FromUint(0));
@@ -163,19 +161,18 @@ void TestScanVertices(msgs::ShardRequestManagerInterface &io) {
     MG_ASSERT(prop.int_v == 444);
   }
 
-  result = io.Request(state);
-  {
-    MG_ASSERT(result.size() == 1);
-    auto prop = result[0].GetProperty(msgs::PropertyId::FromUint(0));
-    MG_ASSERT(prop.int_v == 1);
-  }
+  //  result = request_router.ScanVertices("test_label");
+  //  {
+  //    MG_ASSERT(result.size() == 1);
+  //    auto prop = result[0].GetProperty(msgs::PropertyId::FromUint(0));
+  //    MG_ASSERT(prop.int_v == 1);
+  //  }
 }
 
-void TestCreateVertices(msgs::ShardRequestManagerInterface &io) {
+void TestCreateVertices(query::v2::RequestRouterInterface &request_router) {
   using PropVal = msgs::Value;
-  msgs::ExecutionState<CreateVerticesRequest> state;
   std::vector<msgs::NewVertex> new_vertices;
-  auto label_id = io.NameToLabel("test_label");
+  auto label_id = request_router.NameToLabel("test_label");
   msgs::NewVertex a1{.primary_key = {PropVal(int64_t(1)), PropVal(int64_t(0))}};
   a1.label_ids.push_back({label_id});
   msgs::NewVertex a2{.primary_key = {PropVal(int64_t(13)), PropVal(int64_t(13))}};
@@ -183,17 +180,17 @@ void TestCreateVertices(msgs::ShardRequestManagerInterface &io) {
   new_vertices.push_back(std::move(a1));
   new_vertices.push_back(std::move(a2));
 
-  auto result = io.Request(state, std::move(new_vertices));
+  auto result = request_router.CreateVertices(std::move(new_vertices));
   MG_ASSERT(result.size() == 2);
 }
 
-void TestCreateExpand(msgs::ShardRequestManagerInterface &io) {
+void TestCreateExpand(query::v2::RequestRouterInterface &request_router) {
   using PropVal = msgs::Value;
-  msgs::ExecutionState<msgs::CreateExpandRequest> state;
+  msgs::CreateExpandRequest state;
   std::vector<msgs::NewExpand> new_expands;
 
-  const auto edge_type_id = io.NameToEdgeType("edge_type");
-  const auto label = msgs::Label{io.NameToLabel("test_label")};
+  const auto edge_type_id = request_router.NameToEdgeType("edge_type");
+  const auto label = msgs::Label{request_router.NameToLabel("test_label")};
   const msgs::VertexId vertex_id_1{label, {PropVal(int64_t(0)), PropVal(int64_t(0))}};
   const msgs::VertexId vertex_id_2{label, {PropVal(int64_t(13)), PropVal(int64_t(13))}};
   msgs::NewExpand expand_1{
@@ -203,41 +200,45 @@ void TestCreateExpand(msgs::ShardRequestManagerInterface &io) {
   new_expands.push_back(std::move(expand_1));
   new_expands.push_back(std::move(expand_2));
 
-  auto responses = io.Request(state, std::move(new_expands));
+  auto responses = request_router.CreateExpand(std::move(new_expands));
   MG_ASSERT(responses.size() == 2);
-  MG_ASSERT(responses[0].success);
-  MG_ASSERT(responses[1].success);
+  MG_ASSERT(!responses[0].error);
+  MG_ASSERT(!responses[1].error);
 }
 
-void TestExpandOne(msgs::ShardRequestManagerInterface &shard_request_manager) {
-  msgs::ExecutionState<msgs::ExpandOneRequest> state{};
+void TestExpandOne(query::v2::RequestRouterInterface &request_router) {
+  msgs::ExpandOneRequest state{};
   msgs::ExpandOneRequest request;
-  const auto edge_type_id = shard_request_manager.NameToEdgeType("edge_type");
-  const auto label = msgs::Label{shard_request_manager.NameToLabel("test_label")};
+  const auto edge_type_id = request_router.NameToEdgeType("edge_type");
+  const auto label = msgs::Label{request_router.NameToLabel("test_label")};
   request.src_vertices.push_back(msgs::VertexId{label, {msgs::Value(int64_t(0)), msgs::Value(int64_t(0))}});
   request.edge_types.push_back(msgs::EdgeType{edge_type_id});
   request.direction = msgs::EdgeDirection::BOTH;
-  auto result_rows = shard_request_manager.Request(state, std::move(request));
+  auto result_rows = request_router.ExpandOne(std::move(request));
   MG_ASSERT(result_rows.size() == 2);
 }
 
-void TestGetProperties(msgs::ShardRequestManagerInterface &shard_request_manager) {
+void TestGetProperties(query::v2::RequestRouterInterface &request_router) {
   using PropVal = msgs::Value;
 
-  auto label_id = shard_request_manager.NameToLabel("test_label");
+  auto label_id = request_router.NameToLabel("test_label");
+  msgs::VertexId v0{{label_id}, {PropVal(int64_t(0)), PropVal(int64_t(0))}};
   msgs::VertexId v1{{label_id}, {PropVal(int64_t(1)), PropVal(int64_t(0))}};
   msgs::VertexId v2{{label_id}, {PropVal(int64_t(13)), PropVal(int64_t(13))}};
 
-  msgs::ExecutionState<msgs::GetPropertiesRequest> state;
   msgs::GetPropertiesRequest request;
 
-  request.vertices_and_edges.push_back({v1});
-  request.vertices_and_edges.push_back({v2});
+  request.vertex_ids.push_back({v0});
+  request.vertex_ids.push_back({v1});
+  request.vertex_ids.push_back({v2});
 
-  auto result = shard_request_manager.Request(state, std::move(request));
-  MG_ASSERT(result.size() == 2);
+  auto result = request_router.GetProperties(std::move(request));
+  MG_ASSERT(result.size() == 3);
 }
 
+template <typename RequestRouter>
+void TestAggregate(RequestRouter &request_router) {}
+
 void DoTest() {
   SimulatorConfig config{
       .drop_percent = 0,
@@ -351,13 +352,13 @@ void DoTest() {
   // also get the current shard map
   CoordinatorClient<SimulatorTransport> coordinator_client(cli_io, c_addrs[0], c_addrs);
 
-  msgs::ShardRequestManager<SimulatorTransport> io(std::move(coordinator_client), std::move(cli_io));
+  query::v2::RequestRouter<SimulatorTransport> request_router(std::move(coordinator_client), std::move(cli_io));
 
-  io.StartTransaction();
-  TestScanVertices(io);
-  TestCreateVertices(io);
-  TestCreateExpand(io);
-  TestGetProperties(io);
+  request_router.StartTransaction();
+  TestScanVertices(request_router);
+  TestCreateVertices(request_router);
+  TestCreateExpand(request_router);
+  TestGetProperties(request_router);
 
   simulator.ShutDown();
 

tests/simulation/shard_rsm.cpp

@@ -480,13 +480,11 @@ std::tuple<size_t, std::optional<msgs::VertexId>> AttemptToScanAllWithExpression
   }
 }
 
-msgs::GetPropertiesResponse AttemptToGetProperties(ShardClient &client, std::vector<PropertyId> properties,
-                                                   std::vector<msgs::VertexId> vertices,
-                                                   std::vector<msgs::EdgeTypeId> edges,
-                                                   std::optional<size_t> limit = std::nullopt,
-                                                   std::optional<uint64_t> filter_prop = std::nullopt,
-                                                   bool edge = false,
-                                                   std::optional<std::string> order_by = std::nullopt) {
+msgs::GetPropertiesResponse AttemptToGetProperties(
+    ShardClient &client, std::optional<std::vector<PropertyId>> properties, std::vector<msgs::VertexId> vertices,
+    std::vector<msgs::EdgeId> edges, std::optional<size_t> limit = std::nullopt,
+    std::optional<uint64_t> filter_prop = std::nullopt, bool edge = false,
+    std::optional<std::string> order_by = std::nullopt) {
   msgs::GetPropertiesRequest req{};
   req.transaction_id.logical_id = GetTransactionId();
   req.property_ids = std::move(properties);
@@ -508,14 +506,25 @@ msgs::GetPropertiesResponse AttemptToGetProperties(ShardClient &client, std::vec
     req.limit = limit;
   }
   req.expressions = {std::string("5 = 5")};
-  std::vector<msgs::VertexAndEdgeId> req_v;
+  std::vector<msgs::VertexId> req_v;
+  std::vector<msgs::EdgeId> req_e;
   for (auto &v : vertices) {
-    req_v.push_back(msgs::VertexAndEdgeId{.vertex = std::move(v)});
+    req_v.push_back(std::move(v));
   }
-  for (auto index = 0; index != edges.size(); ++index) {
-    req_v[index].edge = edges[index];
+  for (auto &e : edges) {
+    req_e.push_back(std::move(e));
+  }
+
+  if (!edges.empty()) {
+    MG_ASSERT(edges.size() == vertices.size());
+    size_t id = 0;
+    req.vertices_and_edges.reserve(req_v.size());
+    for (auto &v : req_v) {
+      req.vertices_and_edges.push_back({std::move(v), std::move(req_e[id++])});
+    }
+  } else {
+    req.vertex_ids = std::move(req_v);
   }
-  req.vertices_and_edges = std::move(req_v);
 
   while (true) {
     auto read_res = client.SendReadRequest(req);
@@ -1281,97 +1290,102 @@ void TestGetProperties(ShardClient &client) {
   const auto prop_id_2 = PropertyId::FromUint(2);
   const auto prop_id_4 = PropertyId::FromUint(4);
   const auto prop_id_5 = PropertyId::FromUint(5);
-  // Vertices
+  // No properties
   {
-    // No properties
-    const auto result = AttemptToGetProperties(client, {}, {v_id, v_id_2}, {}, std::nullopt, unique_prop_val_2);
-    MG_ASSERT(result.result == msgs::GetPropertiesResponse::SUCCESS);
-    MG_ASSERT(result.result_row.empty());
+    const auto result = AttemptToGetProperties(client, {{}}, {v_id, v_id_2}, {});
+    MG_ASSERT(!result.error);
+    MG_ASSERT(result.result_row.size() == 2);
+    for (const auto &elem : result.result_row) {
+      MG_ASSERT(elem.props.size() == 0);
+    }
+  }
+  // All properties
+  {
+    const auto result = AttemptToGetProperties(client, std::nullopt, {v_id, v_id_2}, {});
+    MG_ASSERT(!result.error);
+    MG_ASSERT(result.result_row.size() == 2);
+    for (const auto &elem : result.result_row) {
+      MG_ASSERT(elem.props.size() == 3);
+    }
   }
   {
-    // All properties
-    const auto result = AttemptToGetProperties(client, {prop_id_2, prop_id_4, prop_id_5}, {v_id, v_id_2, v_id_3}, {});
-    MG_ASSERT(result.result == msgs::GetPropertiesResponse::SUCCESS);
+    // Specific properties
+    const auto result =
+        AttemptToGetProperties(client, std::vector{prop_id_2, prop_id_4, prop_id_5}, {v_id, v_id_2, v_id_3}, {});
+    MG_ASSERT(!result.error);
     MG_ASSERT(!result.result_row.empty());
     MG_ASSERT(result.result_row.size() == 3);
     for (const auto &elem : result.result_row) {
-      MG_ASSERT(elem.properies_and_ids.ids.size() == 3);
-      MG_ASSERT(elem.properies_and_ids.properties.size() == 3);
+      MG_ASSERT(elem.props.size() == 3);
     }
   }
   {
     // Two properties from two vertices with a filter on unique_prop_5
-    const auto result = AttemptToGetProperties(client, {prop_id_2, prop_id_4}, {v_id, v_id_2, v_id_5}, {}, std::nullopt,
-                                               unique_prop_val_5);
-    MG_ASSERT(result.result == msgs::GetPropertiesResponse::SUCCESS);
-    MG_ASSERT(!result.result_row.empty());
+    const auto result = AttemptToGetProperties(client, std::vector{prop_id_2, prop_id_4}, {v_id, v_id_2, v_id_5}, {},
+                                               std::nullopt, unique_prop_val_5);
+    MG_ASSERT(!result.error);
     MG_ASSERT(result.result_row.size() == 1);
   }
   {
     // One property from three vertices.
-    const auto result = AttemptToGetProperties(client, {prop_id_2}, {v_id, v_id_2, v_id_3}, {});
-    MG_ASSERT(result.result == msgs::GetPropertiesResponse::SUCCESS);
-    MG_ASSERT(!result.result_row.empty());
+    const auto result = AttemptToGetProperties(client, std::vector{prop_id_2}, {v_id, v_id_2, v_id_3}, {});
+    MG_ASSERT(!result.error);
     MG_ASSERT(result.result_row.size() == 3);
-    MG_ASSERT(result.result_row[0].properies_and_ids.ids.size() == 1);
-    MG_ASSERT(result.result_row[1].properies_and_ids.ids.size() == 1);
-    MG_ASSERT(result.result_row[2].properies_and_ids.ids.size() == 1);
+    MG_ASSERT(result.result_row[0].props.size() == 1);
+    MG_ASSERT(result.result_row[1].props.size() == 1);
+    MG_ASSERT(result.result_row[2].props.size() == 1);
   }
   {
     // Same as before but with limit of 1 row
-    const auto result =
-        AttemptToGetProperties(client, {prop_id_2}, {v_id, v_id_2, v_id_3}, {}, std::make_optional<size_t>(1));
-    MG_ASSERT(result.result == msgs::GetPropertiesResponse::SUCCESS);
-    MG_ASSERT(!result.result_row.empty());
+    const auto result = AttemptToGetProperties(client, std::vector{prop_id_2}, {v_id, v_id_2, v_id_3}, {},
+                                               std::make_optional<size_t>(1));
+    MG_ASSERT(!result.error);
     MG_ASSERT(result.result_row.size() == 1);
   }
   {
     // Same as before but with a limit greater than the elements returned
-    const auto result =
-        AttemptToGetProperties(client, {prop_id_2}, {v_id, v_id_2, v_id_3}, {}, std::make_optional<size_t>(5));
-    MG_ASSERT(result.result == msgs::GetPropertiesResponse::SUCCESS);
-    MG_ASSERT(!result.result_row.empty());
+    const auto result = AttemptToGetProperties(client, std::vector{prop_id_2}, std::vector{v_id, v_id_2, v_id_3}, {},
+                                               std::make_optional<size_t>(5));
+    MG_ASSERT(!result.error);
     MG_ASSERT(result.result_row.size() == 3);
   }
   {
     // Order by on `prop1` (descending)
-    const auto result = AttemptToGetProperties(client, {prop_id_2}, {v_id, v_id_2, v_id_3}, {}, std::nullopt,
+    const auto result = AttemptToGetProperties(client, std::vector{prop_id_2}, {v_id, v_id_2, v_id_3}, {}, std::nullopt,
                                                std::nullopt, false, "prop1");
-    MG_ASSERT(result.result == msgs::GetPropertiesResponse::SUCCESS);
-    MG_ASSERT(!result.result_row.empty());
+    MG_ASSERT(!result.error);
     MG_ASSERT(result.result_row.size() == 3);
-    MG_ASSERT(result.result_row[0].vertex_and_edge.vertex == v_id_3);
-    MG_ASSERT(result.result_row[1].vertex_and_edge.vertex == v_id_2);
-    MG_ASSERT(result.result_row[2].vertex_and_edge.vertex == v_id);
+    MG_ASSERT(result.result_row[0].vertex == v_id_3);
+    MG_ASSERT(result.result_row[1].vertex == v_id_2);
+    MG_ASSERT(result.result_row[2].vertex == v_id);
   }
   {
     // Order by and filter on >= unique_prop_val_3 && assert result row data members
-    const auto result = AttemptToGetProperties(client, {prop_id_2}, {v_id, v_id_2, v_id_3, v_id_4, v_id_5}, {},
-                                               std::nullopt, unique_prop_val_3, false, "prop1");
-    MG_ASSERT(result.result == msgs::GetPropertiesResponse::SUCCESS);
-    MG_ASSERT(!result.result_row.empty());
+    const auto result = AttemptToGetProperties(client, std::vector{prop_id_2}, {v_id, v_id_2, v_id_3, v_id_4, v_id_5},
+                                               {}, std::nullopt, unique_prop_val_3, false, "prop1");
+    MG_ASSERT(!result.error);
     MG_ASSERT(result.result_row.size() == 3);
-    MG_ASSERT(result.result_row[0].vertex_and_edge.vertex == v_id_5);
-    MG_ASSERT(result.result_row[0].properies_and_ids.properties.size() == 1);
-    MG_ASSERT(result.result_row[0].properies_and_ids.properties.front() == prim_key_5.front());
-    MG_ASSERT(result.result_row[0].properies_and_ids.ids.size() == 1);
-    MG_ASSERT(result.result_row[0].properies_and_ids.ids.front() == prop_id_2);
+    MG_ASSERT(result.result_row[0].vertex == v_id_5);
+    MG_ASSERT(result.result_row[0].props.size() == 1);
+    MG_ASSERT(result.result_row[0].props.front().second == prim_key_5.front());
+    MG_ASSERT(result.result_row[0].props.size() == 1);
+    MG_ASSERT(result.result_row[0].props.front().first == prop_id_2);
     MG_ASSERT(result.result_row[0].evaluated_expressions.size() == 1);
     MG_ASSERT(result.result_row[0].evaluated_expressions.front() == msgs::Value(true));
 
-    MG_ASSERT(result.result_row[1].vertex_and_edge.vertex == v_id_4);
-    MG_ASSERT(result.result_row[1].properies_and_ids.properties.size() == 1);
-    MG_ASSERT(result.result_row[1].properies_and_ids.properties.front() == prim_key_4.front());
-    MG_ASSERT(result.result_row[1].properies_and_ids.ids.size() == 1);
-    MG_ASSERT(result.result_row[1].properies_and_ids.ids.front() == prop_id_2);
+    MG_ASSERT(result.result_row[1].vertex == v_id_4);
+    MG_ASSERT(result.result_row[1].props.size() == 1);
+    MG_ASSERT(result.result_row[1].props.front().second == prim_key_4.front());
+    MG_ASSERT(result.result_row[1].props.size() == 1);
+    MG_ASSERT(result.result_row[1].props.front().first == prop_id_2);
     MG_ASSERT(result.result_row[1].evaluated_expressions.size() == 1);
     MG_ASSERT(result.result_row[1].evaluated_expressions.front() == msgs::Value(true));
 
-    MG_ASSERT(result.result_row[2].vertex_and_edge.vertex == v_id_3);
-    MG_ASSERT(result.result_row[2].properies_and_ids.properties.size() == 1);
-    MG_ASSERT(result.result_row[2].properies_and_ids.properties.front() == prim_key_3.front());
-    MG_ASSERT(result.result_row[2].properies_and_ids.ids.size() == 1);
-    MG_ASSERT(result.result_row[2].properies_and_ids.ids.front() == prop_id_2);
+    MG_ASSERT(result.result_row[2].vertex == v_id_3);
+    MG_ASSERT(result.result_row[2].props.size() == 1);
+    MG_ASSERT(result.result_row[2].props.front().second == prim_key_3.front());
+    MG_ASSERT(result.result_row[2].props.size() == 1);
+    MG_ASSERT(result.result_row[2].props.front().first == prop_id_2);
     MG_ASSERT(result.result_row[2].evaluated_expressions.size() == 1);
     MG_ASSERT(result.result_row[2].evaluated_expressions.front() == msgs::Value(true));
   }
@@ -1388,54 +1402,61 @@ void TestGetProperties(ShardClient &client) {
   MG_ASSERT(AttemptToAddEdgeWithProperties(client, unique_prop_val_3, unique_prop_val_4, edge_gid_2,
                                            unique_edge_prop_id, edge_prop_val_2, {edge_type_id}));
   const auto edge_prop_id = PropertyId::FromUint(unique_edge_prop_id);
-  // no properties
+  std::vector<msgs::EdgeId> edge_ids = {{edge_gid}, {edge_gid_2}};
+  // No properties
   {
-    const auto result = AttemptToGetProperties(client, {}, {v_id_2, v_id_3}, {edge_type_id, edge_type_id});
-    MG_ASSERT(result.result == msgs::GetPropertiesResponse::SUCCESS);
-    MG_ASSERT(result.result_row.empty());
+    const auto result = AttemptToGetProperties(client, {{}}, {v_id_2, v_id_3}, edge_ids);
+    MG_ASSERT(!result.error);
+    MG_ASSERT(result.result_row.size() == 2);
+    for (const auto &elem : result.result_row) {
+      MG_ASSERT(elem.props.size() == 0);
+    }
   }
-  // properties for two vertices
+  // All properties
   {
-    const auto result = AttemptToGetProperties(client, {edge_prop_id}, {v_id_2, v_id_3}, {edge_type_id, edge_type_id});
-    MG_ASSERT(result.result == msgs::GetPropertiesResponse::SUCCESS);
-    MG_ASSERT(!result.result_row.empty());
+    const auto result = AttemptToGetProperties(client, std::nullopt, {v_id_2, v_id_3}, edge_ids);
+    MG_ASSERT(!result.error);
+    MG_ASSERT(result.result_row.size() == 2);
+    for (const auto &elem : result.result_row) {
+      MG_ASSERT(elem.props.size() == 1);
+    }
+  }
+  // Properties for two vertices
+  {
+    const auto result = AttemptToGetProperties(client, std::vector{edge_prop_id}, {v_id_2, v_id_3}, edge_ids);
+    MG_ASSERT(!result.error);
     MG_ASSERT(result.result_row.size() == 2);
   }
-  // filter
+  // Filter
   {
-    const auto result = AttemptToGetProperties(client, {edge_prop_id}, {v_id_2, v_id_3}, {edge_type_id, edge_type_id},
-                                               {}, {edge_prop_val}, true);
-    MG_ASSERT(result.result == msgs::GetPropertiesResponse::SUCCESS);
-    MG_ASSERT(!result.result_row.empty());
+    const auto result = AttemptToGetProperties(client, std::vector{edge_prop_id}, {v_id_2, v_id_3}, edge_ids, {},
+                                               {edge_prop_val}, true);
+    MG_ASSERT(!result.error);
     MG_ASSERT(result.result_row.size() == 1);
-    MG_ASSERT(result.result_row.front().vertex_and_edge.edge);
-    MG_ASSERT(result.result_row.front().vertex_and_edge.edge.value() == edge_type_id);
-    MG_ASSERT(result.result_row.front().properies_and_ids.properties.size() == 1);
-    MG_ASSERT(result.result_row.front().properies_and_ids.properties.front() ==
-              msgs::Value(static_cast<int64_t>(edge_prop_val)));
+    MG_ASSERT(result.result_row.front().edge);
+    MG_ASSERT(result.result_row.front().edge.value().gid == edge_gid);
+    MG_ASSERT(result.result_row.front().props.size() == 1);
+    MG_ASSERT(result.result_row.front().props.front().second == msgs::Value(static_cast<int64_t>(edge_prop_val)));
   }
   // Order by
   {
-    const auto result = AttemptToGetProperties(client, {edge_prop_id}, {v_id_2, v_id_3}, {edge_type_id, edge_type_id},
-                                               {}, {}, true, "e_prop");
-    MG_ASSERT(result.result == msgs::GetPropertiesResponse::SUCCESS);
-    MG_ASSERT(!result.result_row.empty());
+    const auto result =
+        AttemptToGetProperties(client, std::vector{edge_prop_id}, {v_id_2, v_id_3}, edge_ids, {}, {}, true, "e_prop");
+    MG_ASSERT(!result.error);
     MG_ASSERT(result.result_row.size() == 2);
-    MG_ASSERT(result.result_row[0].vertex_and_edge.vertex == v_id_3);
-    MG_ASSERT(result.result_row[0].vertex_and_edge.edge);
-    MG_ASSERT(result.result_row[0].vertex_and_edge.edge.value() == edge_type_id);
-    MG_ASSERT(result.result_row[0].properies_and_ids.properties.size() == 1);
-    MG_ASSERT(result.result_row[0].properies_and_ids.properties.front() ==
-              msgs::Value(static_cast<int64_t>(edge_prop_val_2)));
+    MG_ASSERT(result.result_row[0].vertex == v_id_3);
+    MG_ASSERT(result.result_row[0].edge);
+    MG_ASSERT(result.result_row[0].edge.value().gid == edge_gid_2);
+    MG_ASSERT(result.result_row[0].props.size() == 1);
+    MG_ASSERT(result.result_row[0].props.front().second == msgs::Value(static_cast<int64_t>(edge_prop_val_2)));
     MG_ASSERT(result.result_row[0].evaluated_expressions.size() == 1);
     MG_ASSERT(result.result_row[0].evaluated_expressions.front() == msgs::Value(true));
 
-    MG_ASSERT(result.result_row[1].vertex_and_edge.vertex == v_id_2);
-    MG_ASSERT(result.result_row[1].vertex_and_edge.edge);
-    MG_ASSERT(result.result_row[1].vertex_and_edge.edge.value() == edge_type_id);
-    MG_ASSERT(result.result_row[1].properies_and_ids.properties.size() == 1);
-    MG_ASSERT(result.result_row[1].properies_and_ids.properties.front() ==
-              msgs::Value(static_cast<int64_t>(edge_prop_val)));
+    MG_ASSERT(result.result_row[1].vertex == v_id_2);
+    MG_ASSERT(result.result_row[1].edge);
+    MG_ASSERT(result.result_row[1].edge.value().gid == edge_gid);
+    MG_ASSERT(result.result_row[1].props.size() == 1);
+    MG_ASSERT(result.result_row[1].props.front().second == msgs::Value(static_cast<int64_t>(edge_prop_val)));
     MG_ASSERT(result.result_row[1].evaluated_expressions.size() == 1);
     MG_ASSERT(result.result_row[1].evaluated_expressions.front() == msgs::Value(true));
   }

tests/simulation/test_cluster.hpp

@@ -30,8 +30,8 @@
 #include "io/simulator/simulator_transport.hpp"
 #include "machine_manager/machine_config.hpp"
 #include "machine_manager/machine_manager.hpp"
+#include "query/v2/request_router.hpp"
 #include "query/v2/requests.hpp"
-#include "query/v2/shard_request_manager.hpp"
 #include "testing_constants.hpp"
 #include "utils/print_helpers.hpp"
 #include "utils/variant_helpers.hpp"
@@ -151,8 +151,8 @@ ShardMap TestShardMap(int n_splits, int replication_factor) {
   return sm;
 }
 
-void ExecuteOp(msgs::ShardRequestManager<SimulatorTransport> &shard_request_manager,
-               std::set<CompoundKey> &correctness_model, CreateVertex create_vertex) {
+void ExecuteOp(query::v2::RequestRouter<SimulatorTransport> &request_router, std::set<CompoundKey> &correctness_model,
+               CreateVertex create_vertex) {
   const auto key1 = memgraph::storage::v3::PropertyValue(create_vertex.first);
   const auto key2 = memgraph::storage::v3::PropertyValue(create_vertex.second);
 
@@ -164,9 +164,7 @@ void ExecuteOp(msgs::ShardRequestManager<SimulatorTransport> &shard_request_mana
     return;
   }
 
-  msgs::ExecutionState<msgs::CreateVerticesRequest> state;
-
-  auto label_id = shard_request_manager.NameToLabel("test_label");
+  auto label_id = request_router.NameToLabel("test_label");
 
   msgs::NewVertex nv{.primary_key = primary_key};
   nv.label_ids.push_back({label_id});
@@ -174,7 +172,7 @@ void ExecuteOp(msgs::ShardRequestManager<SimulatorTransport> &shard_request_mana
   std::vector<msgs::NewVertex> new_vertices;
   new_vertices.push_back(std::move(nv));
 
-  auto result = shard_request_manager.Request(state, std::move(new_vertices));
+  auto result = request_router.CreateVertices(std::move(new_vertices));
 
   RC_ASSERT(result.size() == 1);
   RC_ASSERT(!result[0].error.has_value());
@@ -182,11 +180,9 @@ void ExecuteOp(msgs::ShardRequestManager<SimulatorTransport> &shard_request_mana
   correctness_model.emplace(std::make_pair(create_vertex.first, create_vertex.second));
 }
 
-void ExecuteOp(msgs::ShardRequestManager<SimulatorTransport> &shard_request_manager,
-               std::set<CompoundKey> &correctness_model, ScanAll scan_all) {
-  msgs::ExecutionState<msgs::ScanVerticesRequest> request{.label = "test_label"};
-
-  auto results = shard_request_manager.Request(request);
+void ExecuteOp(query::v2::RequestRouter<SimulatorTransport> &request_router, std::set<CompoundKey> &correctness_model,
+               ScanAll scan_all) {
+  auto results = request_router.ScanVertices("test_label");
 
   RC_ASSERT(results.size() == correctness_model.size());
 
@@ -247,14 +243,14 @@ std::pair<SimulatorStats, LatencyHistogramSummaries> RunClusterSimulation(const
   CoordinatorClient<SimulatorTransport> coordinator_client(cli_io, coordinator_address, {coordinator_address});
   WaitForShardsToInitialize(coordinator_client);
 
-  msgs::ShardRequestManager<SimulatorTransport> shard_request_manager(std::move(coordinator_client), std::move(cli_io));
+  query::v2::RequestRouter<SimulatorTransport> request_router(std::move(coordinator_client), std::move(cli_io));
 
-  shard_request_manager.StartTransaction();
+  request_router.StartTransaction();
 
   auto correctness_model = std::set<CompoundKey>{};
 
   for (const Op &op : ops) {
-    std::visit([&](auto &o) { ExecuteOp(shard_request_manager, correctness_model, o); }, op.inner);
+    std::visit([&](auto &o) { ExecuteOp(request_router, correctness_model, o); }, op.inner);
   }
 
   // We have now completed our workload without failing any assertions, so we can

tests/unit/CMakeLists.txt

@@ -406,3 +406,7 @@ target_link_libraries(${test_prefix}coordinator_shard_map mg-coordinator)
 # Tests for many shards, many creates, scan
 add_unit_test(high_density_shard_create_scan.cpp)
 target_link_libraries(${test_prefix}high_density_shard_create_scan mg-io mg-coordinator mg-storage-v3 mg-query-v2)
+
+# Tests for awesome_memgraph_functions
+add_unit_test(query_v2_expression_evaluator.cpp)
+target_link_libraries(${test_prefix}query_v2_expression_evaluator mg-query-v2)

tests/unit/high_density_shard_create_scan.cpp

@@ -29,8 +29,8 @@
 #include "io/simulator/simulator_transport.hpp"
 #include "machine_manager/machine_config.hpp"
 #include "machine_manager/machine_manager.hpp"
+#include "query/v2/request_router.hpp"
 #include "query/v2/requests.hpp"
-#include "query/v2/shard_request_manager.hpp"
 #include "utils/variant_helpers.hpp"
 
 namespace memgraph::tests::simulation {
@@ -161,8 +161,8 @@ ShardMap TestShardMap(int shards, int replication_factor, int gap_between_shards
   return sm;
 }
 
-void ExecuteOp(msgs::ShardRequestManager<LocalTransport> &shard_request_manager,
-               std::set<CompoundKey> &correctness_model, CreateVertex create_vertex) {
+void ExecuteOp(query::v2::RequestRouter<LocalTransport> &request_router, std::set<CompoundKey> &correctness_model,
+               CreateVertex create_vertex) {
   const auto key1 = memgraph::storage::v3::PropertyValue(create_vertex.first);
   const auto key2 = memgraph::storage::v3::PropertyValue(create_vertex.second);
 
@@ -174,9 +174,7 @@ void ExecuteOp(msgs::ShardRequestManager<LocalTransport> &shard_request_manager,
     return;
   }
 
-  msgs::ExecutionState<msgs::CreateVerticesRequest> state;
-
-  auto label_id = shard_request_manager.NameToLabel("test_label");
+  auto label_id = request_router.NameToLabel("test_label");
 
   msgs::NewVertex nv{.primary_key = primary_key};
   nv.label_ids.push_back({label_id});
@@ -184,7 +182,7 @@ void ExecuteOp(msgs::ShardRequestManager<LocalTransport> &shard_request_manager,
   std::vector<msgs::NewVertex> new_vertices;
   new_vertices.push_back(std::move(nv));
 
-  auto result = shard_request_manager.Request(state, std::move(new_vertices));
+  auto result = request_router.CreateVertices(std::move(new_vertices));
 
   MG_ASSERT(result.size() == 1);
   MG_ASSERT(!result[0].error.has_value());
@@ -192,11 +190,9 @@ void ExecuteOp(msgs::ShardRequestManager<LocalTransport> &shard_request_manager,
   correctness_model.emplace(std::make_pair(create_vertex.first, create_vertex.second));
 }
 
-void ExecuteOp(msgs::ShardRequestManager<LocalTransport> &shard_request_manager,
-               std::set<CompoundKey> &correctness_model, ScanAll scan_all) {
-  msgs::ExecutionState<msgs::ScanVerticesRequest> request{.label = "test_label"};
-
-  auto results = shard_request_manager.Request(request);
+void ExecuteOp(query::v2::RequestRouter<LocalTransport> &request_router, std::set<CompoundKey> &correctness_model,
+               ScanAll scan_all) {
+  auto results = request_router.ScanVertices("test_label");
 
   MG_ASSERT(results.size() == correctness_model.size());
 
@@ -245,22 +241,22 @@ void RunWorkload(int shards, int replication_factor, int create_ops, int scan_op
   WaitForShardsToInitialize(coordinator_client);
   auto time_after_shard_stabilization = cli_io_2.Now();
 
-  msgs::ShardRequestManager<LocalTransport> shard_request_manager(std::move(coordinator_client), std::move(cli_io));
+  query::v2::RequestRouter<LocalTransport> request_router(std::move(coordinator_client), std::move(cli_io));
 
-  shard_request_manager.StartTransaction();
+  request_router.StartTransaction();
 
   auto correctness_model = std::set<CompoundKey>{};
 
   auto time_before_creates = cli_io_2.Now();
 
   for (int i = 0; i < create_ops; i++) {
-    ExecuteOp(shard_request_manager, correctness_model, CreateVertex{.first = i, .second = i});
+    ExecuteOp(request_router, correctness_model, CreateVertex{.first = i, .second = i});
   }
 
   auto time_after_creates = cli_io_2.Now();
 
   for (int i = 0; i < scan_ops; i++) {
-    ExecuteOp(shard_request_manager, correctness_model, ScanAll{});
+    ExecuteOp(request_router, correctness_model, ScanAll{});
   }
 
   auto time_after_scan = cli_io_2.Now();

tests/unit/machine_manager.cpp

@@ -27,7 +27,7 @@
 #include <machine_manager/machine_manager.hpp>
 #include <query/v2/requests.hpp>
 #include "io/rsm/rsm_client.hpp"
-#include "query/v2/shard_request_manager.hpp"
+#include "query/v2/request_router.hpp"
 #include "storage/v3/id_types.hpp"
 #include "storage/v3/schemas.hpp"
 
@@ -109,19 +109,16 @@ ShardMap TestShardMap() {
   return sm;
 }
 
-template <typename ShardRequestManager>
-void TestScanAll(ShardRequestManager &shard_request_manager) {
-  msgs::ExecutionState<msgs::ScanVerticesRequest> state{.label = kLabelName};
-
-  auto result = shard_request_manager.Request(state);
+template <typename RequestRouter>
+void TestScanAll(RequestRouter &request_router) {
+  auto result = request_router.ScanVertices(kLabelName);
   EXPECT_EQ(result.size(), 2);
 }
 
-void TestCreateVertices(msgs::ShardRequestManagerInterface &shard_request_manager) {
+void TestCreateVertices(query::v2::RequestRouterInterface &request_router) {
   using PropVal = msgs::Value;
-  msgs::ExecutionState<msgs::CreateVerticesRequest> state;
   std::vector<msgs::NewVertex> new_vertices;
-  auto label_id = shard_request_manager.NameToLabel(kLabelName);
+  auto label_id = request_router.NameToLabel(kLabelName);
   msgs::NewVertex a1{.primary_key = {PropVal(int64_t(0)), PropVal(int64_t(0))}};
   a1.label_ids.push_back({label_id});
   msgs::NewVertex a2{.primary_key = {PropVal(int64_t(13)), PropVal(int64_t(13))}};
@@ -129,18 +126,17 @@ void TestCreateVertices(msgs::ShardRequestManagerInterface &shard_request_manage
   new_vertices.push_back(std::move(a1));
   new_vertices.push_back(std::move(a2));
 
-  auto result = shard_request_manager.Request(state, std::move(new_vertices));
+  auto result = request_router.CreateVertices(std::move(new_vertices));
   EXPECT_EQ(result.size(), 1);
   EXPECT_FALSE(result[0].error.has_value()) << result[0].error->message;
 }
 
-void TestCreateExpand(msgs::ShardRequestManagerInterface &shard_request_manager) {
+void TestCreateExpand(query::v2::RequestRouterInterface &request_router) {
   using PropVal = msgs::Value;
-  msgs::ExecutionState<msgs::CreateExpandRequest> state;
   std::vector<msgs::NewExpand> new_expands;
 
-  const auto edge_type_id = shard_request_manager.NameToEdgeType("edge_type");
-  const auto label = msgs::Label{shard_request_manager.NameToLabel("test_label")};
+  const auto edge_type_id = request_router.NameToEdgeType("edge_type");
+  const auto label = msgs::Label{request_router.NameToLabel("test_label")};
   const msgs::VertexId vertex_id_1{label, {PropVal(int64_t(0)), PropVal(int64_t(0))}};
   const msgs::VertexId vertex_id_2{label, {PropVal(int64_t(13)), PropVal(int64_t(13))}};
   msgs::NewExpand expand_1{
@@ -150,27 +146,26 @@ void TestCreateExpand(msgs::ShardRequestManagerInterface &shard_request_manager)
   new_expands.push_back(std::move(expand_1));
   new_expands.push_back(std::move(expand_2));
 
-  auto responses = shard_request_manager.Request(state, std::move(new_expands));
+  auto responses = request_router.CreateExpand(std::move(new_expands));
   MG_ASSERT(responses.size() == 1);
   MG_ASSERT(!responses[0].error.has_value());
 }
 
-void TestExpandOne(msgs::ShardRequestManagerInterface &shard_request_manager) {
-  msgs::ExecutionState<msgs::ExpandOneRequest> state{};
+void TestExpandOne(query::v2::RequestRouterInterface &request_router) {
   msgs::ExpandOneRequest request;
-  const auto edge_type_id = shard_request_manager.NameToEdgeType("edge_type");
-  const auto label = msgs::Label{shard_request_manager.NameToLabel("test_label")};
+  const auto edge_type_id = request_router.NameToEdgeType("edge_type");
+  const auto label = msgs::Label{request_router.NameToLabel("test_label")};
   request.src_vertices.push_back(msgs::VertexId{label, {msgs::Value(int64_t(0)), msgs::Value(int64_t(0))}});
   request.edge_types.push_back(msgs::EdgeType{edge_type_id});
   request.direction = msgs::EdgeDirection::BOTH;
-  auto result_rows = shard_request_manager.Request(state, std::move(request));
+  auto result_rows = request_router.ExpandOne(std::move(request));
   MG_ASSERT(result_rows.size() == 1);
   MG_ASSERT(result_rows[0].in_edges_with_all_properties.size() == 1);
   MG_ASSERT(result_rows[0].out_edges_with_all_properties.size() == 1);
 }
 
-template <typename ShardRequestManager>
-void TestAggregate(ShardRequestManager &shard_request_manager) {}
+template <typename RequestRouter>
+void TestAggregate(RequestRouter &request_router) {}
 
 MachineManager<LocalTransport> MkMm(LocalSystem &local_system, std::vector<Address> coordinator_addresses, Address addr,
                                     ShardMap shard_map) {
@@ -226,13 +221,13 @@ TEST(MachineManager, BasicFunctionality) {
 
   CoordinatorClient<LocalTransport> coordinator_client(cli_io, coordinator_address, {coordinator_address});
 
-  msgs::ShardRequestManager<LocalTransport> shard_request_manager(std::move(coordinator_client), std::move(cli_io));
+  query::v2::RequestRouter<LocalTransport> request_router(std::move(coordinator_client), std::move(cli_io));
 
-  shard_request_manager.StartTransaction();
-  TestCreateVertices(shard_request_manager);
-  TestScanAll(shard_request_manager);
-  TestCreateExpand(shard_request_manager);
-  TestExpandOne(shard_request_manager);
+  request_router.StartTransaction();
+  TestCreateVertices(request_router);
+  TestScanAll(request_router);
+  TestCreateExpand(request_router);
+  TestExpandOne(request_router);
   local_system.ShutDown();
 };