Gix visitor

.github/workflows/diff.yaml

@@ -271,30 +271,3 @@ jobs:
           source ve3/bin/activate
           cd e2e
           LD_LIBRARY_PATH=$LD_LIBRARY_PATH:../../libs/mgclient/lib python runner.py --workloads-root-directory ./distributed_queries
-
-      - name: Run query performance tests
-        run: |
-          cd tests/manual
-          ./query_performance_runner.py
-
-      - name: Get branch name (merge)
-        if: github.event_name != 'pull_request'
-        shell: bash
-        run: echo "BRANCH_NAME=$(echo ${GITHUB_REF#refs/heads/} | tr / -)" >> $GITHUB_ENV
-
-      - name: Get branch name (pull request)
-        if: github.event_name == 'pull_request'
-        shell: bash
-        run: echo "BRANCH_NAME=$(echo ${GITHUB_HEAD_REF} | tr / -)" >> $GITHUB_ENV
-
-      - name: Upload macro benchmark results
-        run: |
-          cd tools/bench-graph-client
-          virtualenv -p python3 ve3
-          source ve3/bin/activate
-          pip install -r requirements.txt
-          ./main.py --benchmark-name "query_performance" \
-                    --benchmark-results-path "../../build/tests/manual/query_performance_benchmark/summary.json" \
-                    --github-run-id "${{ github.run_id }}" \
-                    --github-run-number "${{ github.run_number }}" \
-                    --head-branch-name "${{ env.BRANCH_NAME }}"

src/common/types.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -16,4 +16,6 @@
 namespace memgraph::common {
 enum class SchemaType : uint8_t { BOOL, INT, STRING, DATE, LOCALTIME, LOCALDATETIME, DURATION };
 
+enum class SchemaConfigParams : uint8_t { REPLICATION_FACTOR, SPLIT_THRESHOLD };
+
 }  // namespace memgraph::common

src/coordinator/coordinator.cpp

@@ -18,7 +18,12 @@ CoordinatorWriteResponses Coordinator::ApplyWrite(HeartbeatRequest &&heartbeat_r
 
   // add this storage engine to any under-replicated shards that it is not already a part of
 
-  return shard_map_.AssignShards(heartbeat_request.from_storage_manager, heartbeat_request.initialized_rsms);
+  auto initializing_rsms_for_shard_manager =
+      shard_map_.AssignShards(heartbeat_request.from_storage_manager, heartbeat_request.initialized_rsms);
+
+  return HeartbeatResponse{
+      .shards_to_initialize = initializing_rsms_for_shard_manager,
+  };
 }
 
 CoordinatorWriteResponses Coordinator::ApplyWrite(HlcRequest &&hlc_request) {
@@ -62,8 +67,12 @@ CoordinatorWriteResponses Coordinator::ApplyWrite(AllocateEdgeIdBatchRequest &&a
 CoordinatorWriteResponses Coordinator::ApplyWrite(SplitShardRequest &&split_shard_request) {
   SplitShardResponse res{};
 
-  res.success = shard_map_.SplitShard(split_shard_request.previous_shard_map_version, split_shard_request.label_id,
-                                      split_shard_request.split_key);
+  if (split_shard_request.previous_shard_map_version != shard_map_.shard_map_version) {
+    res.success = false;
+  } else {
+    res.success = shard_map_.SplitShard(split_shard_request.previous_shard_map_version, split_shard_request.label_id,
+                                        split_shard_request.split_key);
+  }
 
   return res;
 }

src/coordinator/coordinator.hpp

@@ -121,6 +121,15 @@ struct InitializeLabelResponse {
   std::optional<ShardMap> fresher_shard_map;
 };
 
+struct HeartbeatRequest {
+  Address from_storage_manager;
+  std::set<boost::uuids::uuid> initialized_rsms;
+};
+
+struct HeartbeatResponse {
+  std::vector<ShardToInitialize> shards_to_initialize;
+};
+
 using CoordinatorWriteRequests =
     std::variant<HlcRequest, AllocateEdgeIdBatchRequest, SplitShardRequest, RegisterStorageEngineRequest,
                  DeregisterStorageEngineRequest, InitializeLabelRequest, AllocatePropertyIdsRequest, HeartbeatRequest>;

src/coordinator/hybrid_logical_clock.hpp

@@ -27,7 +27,7 @@ struct Hlc final {
   uint64_t logical_id{0};
   Time coordinator_wall_clock = Time::min();
 
-  auto operator<=>(const Hlc &other) const noexcept { return logical_id <=> other.logical_id; }
+  auto operator<=>(const Hlc &other) const { return logical_id <=> other.logical_id; }
 
   bool operator==(const Hlc &other) const noexcept = default;
   bool operator<(const Hlc &other) const noexcept = default;

src/coordinator/shard_map.cpp

@@ -9,7 +9,6 @@
 // by the Apache License, Version 2.0, included in the file
 // licenses/APL.txt.
 
-#include <map>
 #include <optional>
 #include <unordered_map>
 #include <vector>
@@ -268,8 +267,9 @@ boost::uuids::uuid NewShardUuid(uint64_t shard_id) {
                             static_cast<unsigned char>(shard_id)};
 }
 
-HeartbeatResponse ShardMap::AssignShards(Address storage_manager, std::set<boost::uuids::uuid> initialized) {
-  HeartbeatResponse ret{};
+std::vector<ShardToInitialize> ShardMap::AssignShards(Address storage_manager,
+                                                      std::set<boost::uuids::uuid> initialized) {
+  std::vector<ShardToInitialize> ret{};
 
   bool mutated = false;
 
@@ -281,74 +281,48 @@ HeartbeatResponse ShardMap::AssignShards(Address storage_manager, std::set<boost
         high_key = next_it->first;
       }
       // TODO(tyler) avoid these triple-nested loops by having the heartbeat include better info
-      bool shard_assigned_to_machine = false;
+      bool machine_contains_shard = false;
 
-      for (auto &peer_metadata : shard.peers) {
-        const bool same_machine = peer_metadata.address.last_known_ip == storage_manager.last_known_ip &&
-                                  peer_metadata.address.last_known_port == storage_manager.last_known_port;
-
-        if (initialized.contains(peer_metadata.address.unique_id)) {
-          shard_assigned_to_machine = true;
-
-          if (!same_machine) {
-            // set the last known ip and port to the storage manager that has heartbeated it just now
+      for (auto &aas : shard.peers) {
+        if (initialized.contains(aas.address.unique_id)) {
+          machine_contains_shard = true;
+          if (aas.status != Status::CONSENSUS_PARTICIPANT) {
             mutated = true;
-            peer_metadata.address.last_known_ip = storage_manager.last_known_ip;
-            peer_metadata.address.last_known_port = storage_manager.last_known_port;
+            spdlog::info("marking shard as full consensus participant: {}", aas.address.unique_id);
+            aas.status = Status::CONSENSUS_PARTICIPANT;
           }
-
-          if (peer_metadata.status != Status::CONSENSUS_PARTICIPANT) {
-            mutated = true;
-            spdlog::info("marking shard as full consensus participant: {}", peer_metadata.address.unique_id);
-            peer_metadata.status = Status::CONSENSUS_PARTICIPANT;
-          }
-        } else if (same_machine && peer_metadata.status == Status::INITIALIZING) {
-          // we are expecting this shard to be initialized (rather than split) on this machine,
-          // so send it an initialization request
-
-          shard_assigned_to_machine = true;
-          spdlog::info("reminding shard manager that they should begin participating in shard");
-
-          ret.shards_to_initialize.push_back(ShardToInitialize{
-              .uuid = peer_metadata.address.unique_id,
-              .label_id = label_id,
-              .min_key = low_key,
-              .max_key = high_key,
-              .schema = schemas[label_id],
-              .config = Config{},
-              .id_to_names = IdToNames(),
-          });
-        } else if (same_machine && peer_metadata.status == Status::PENDING_SPLIT) {
-          // we are expecting this shard to be split, so send it a split request
-
-          ret.shards_to_split.push_back(ShardToSplit{
-              .shard_to_split_uuid = peer_metadata.split_from,
-              .new_right_side_uuid = peer_metadata.address.unique_id,
-              .split_requested_at = shard.version,
-              .label_id = label_id,
-              .split_key = low_key,
-              .schema = schemas[label_id],
-              .config = Config{},
-              .id_to_names = IdToNames(),
-          });
         } else {
-          MG_ASSERT(
-              !same_machine,
-              "failed to properly handle a new Status type in the heartbeat management and shard assignment code");
+          const bool same_machine = aas.address.last_known_ip == storage_manager.last_known_ip &&
+                                    aas.address.last_known_port == storage_manager.last_known_port;
+          if (same_machine) {
+            machine_contains_shard = true;
+            spdlog::info("reminding shard manager that they should begin participating in shard");
+
+            ret.push_back(ShardToInitialize{
+                .uuid = aas.address.unique_id,
+                .label_id = label_id,
+                .min_key = low_key,
+                .max_key = high_key,
+                .schema = schemas[label_id],
+                .config = Config{},
+                .id_to_names = IdToNames(),
+            });
+          }
         }
       }
 
-      if (!shard_assigned_to_machine && shard.peers.size() < label_space.replication_factor) {
-        Address address = storage_manager;
-
-        // NB: increment version for each new uuid for deterministic creation
+      if (!machine_contains_shard && shard.peers.size() < label_space.replication_factor) {
+        // increment version for each new uuid for deterministic creation
         IncrementShardMapVersion();
 
+        Address address = storage_manager;
+
+        // TODO(tyler) use deterministic UUID so that coordinators don't diverge here
         address.unique_id = NewShardUuid(shard_map_version.logical_id);
 
         spdlog::info("assigning shard manager to shard");
 
-        ret.shards_to_initialize.push_back(ShardToInitialize{
+        ret.push_back(ShardToInitialize{
             .uuid = address.unique_id,
             .label_id = label_id,
             .min_key = low_key,
@@ -358,12 +332,12 @@ HeartbeatResponse ShardMap::AssignShards(Address storage_manager, std::set<boost
             .id_to_names = IdToNames(),
         });
 
-        PeerMetadata peer_metadata = {
+        AddressAndStatus aas = {
             .address = address,
             .status = Status::INITIALIZING,
         };
 
-        shard.peers.emplace_back(peer_metadata);
+        shard.peers.emplace_back(aas);
       }
     }
   }
@@ -371,12 +345,11 @@ HeartbeatResponse ShardMap::AssignShards(Address storage_manager, std::set<boost
   if (mutated) {
     IncrementShardMapVersion();
   }
-
   return ret;
 }
 
 bool ShardMap::SplitShard(Hlc previous_shard_map_version, LabelId label_id, const PrimaryKey &key) {
-  if (previous_shard_map_version != shard_map_version || !label_spaces.contains(label_id)) {
+  if (previous_shard_map_version != shard_map_version) {
     return false;
   }
 
@@ -385,26 +358,11 @@ bool ShardMap::SplitShard(Hlc previous_shard_map_version, LabelId label_id, cons
 
   MG_ASSERT(!shards_in_map.empty());
   MG_ASSERT(!shards_in_map.contains(key));
+  MG_ASSERT(label_spaces.contains(label_id));
 
   // Finding the ShardMetadata that the new PrimaryKey should map to.
-  ShardMetadata duplicated_shard = GetShardForKey(label_id, key);
-
-  std::map<boost::uuids::uuid, boost::uuids::uuid> split_mapping = {};
-
-  for (auto &peer_metadata : duplicated_shard.peers) {
-    peer_metadata.status = Status::PENDING_SPLIT;
-    peer_metadata.split_from = peer_metadata.address.unique_id;
-
-    // NB: increment version for each new uuid for deterministic creation
-    IncrementShardMapVersion();
-
-    auto new_uuid = NewShardUuid(shard_map_version.logical_id);
-
-    // store new uuid for the right side of each shard
-    split_mapping.emplace(peer_metadata.address.unique_id, new_uuid);
-
-    peer_metadata.address.unique_id = new_uuid;
-  }
+  auto prev = std::prev(shards_in_map.upper_bound(key));
+  ShardMetadata duplicated_shard = prev->second;
 
   // Apply the split
   shards_in_map[key] = duplicated_shard;
@@ -603,8 +561,8 @@ bool ShardMap::ClusterInitialized() const {
         return false;
       }
 
-      for (const auto &peer_metadata : shard.peers) {
-        if (peer_metadata.status != Status::CONSENSUS_PARTICIPANT) {
+      for (const auto &aas : shard.peers) {
+        if (aas.status != Status::CONSENSUS_PARTICIPANT) {
           spdlog::info("shard member not yet a CONSENSUS_PARTICIPANT");
           return false;
         }

src/coordinator/shard_map.hpp

@@ -47,45 +47,38 @@ using memgraph::storage::v3::SchemaProperty;
 enum class Status : uint8_t {
   CONSENSUS_PARTICIPANT,
   INITIALIZING,
-  PENDING_SPLIT,
   // TODO(tyler) this will possibly have more states,
   // depending on the reconfiguration protocol that we
   // implement.
 };
 
-struct PeerMetadata {
+struct AddressAndStatus {
   memgraph::io::Address address;
   Status status;
-  boost::uuids::uuid split_from;
 
-  friend bool operator<(const PeerMetadata &lhs, const PeerMetadata &rhs) { return lhs.address < rhs.address; }
+  friend bool operator<(const AddressAndStatus &lhs, const AddressAndStatus &rhs) { return lhs.address < rhs.address; }
 
-  friend std::ostream &operator<<(std::ostream &in, const PeerMetadata &peer_metadata) {
-    in << "PeerMetadata { address: ";
-    in << peer_metadata.address;
-
-    if (peer_metadata.status == Status::CONSENSUS_PARTICIPANT) {
-      in << ", status: CONSENSUS_PARTICIPANT";
-    } else if (peer_metadata.status == Status::INITIALIZING) {
-      in << ", status: INITIALIZING";
-    } else if (peer_metadata.status == Status::PENDING_SPLIT) {
-      in << ", status: PENDING_SPLIT";
+  friend std::ostream &operator<<(std::ostream &in, const AddressAndStatus &address_and_status) {
+    in << "AddressAndStatus { address: ";
+    in << address_and_status.address;
+    if (address_and_status.status == Status::CONSENSUS_PARTICIPANT) {
+      in << ", status: CONSENSUS_PARTICIPANT }";
     } else {
-      MG_ASSERT(false, "failed to update the operator<< implementation for Status");
+      in << ", status: INITIALIZING }";
     }
 
-    in << ", split_from: " << peer_metadata.split_from << " }";
-
     return in;
   }
 
-  friend bool operator==(const PeerMetadata &lhs, const PeerMetadata &rhs) { return lhs.address == rhs.address; }
+  friend bool operator==(const AddressAndStatus &lhs, const AddressAndStatus &rhs) {
+    return lhs.address == rhs.address;
+  }
 };
 
 using PrimaryKey = std::vector<PropertyValue>;
 
 struct ShardMetadata {
-  std::vector<PeerMetadata> peers;
+  std::vector<AddressAndStatus> peers;
   uint64_t version;
 
   friend std::ostream &operator<<(std::ostream &in, const ShardMetadata &shard) {
@@ -128,27 +121,6 @@ struct ShardToInitialize {
   std::unordered_map<uint64_t, std::string> id_to_names;
 };
 
-struct ShardToSplit {
-  boost::uuids::uuid shard_to_split_uuid;
-  boost::uuids::uuid new_right_side_uuid;
-  Hlc split_requested_at;
-  LabelId label_id;
-  PrimaryKey split_key;
-  std::vector<SchemaProperty> schema;
-  Config config;
-  std::unordered_map<uint64_t, std::string> id_to_names;
-};
-
-struct HeartbeatRequest {
-  Address from_storage_manager;
-  std::set<boost::uuids::uuid> initialized_rsms;
-};
-
-struct HeartbeatResponse {
-  std::vector<ShardToInitialize> shards_to_initialize;
-  std::vector<ShardToSplit> shards_to_split;
-};
-
 PrimaryKey SchemaToMinKey(const std::vector<SchemaProperty> &schema);
 
 struct LabelSpace {
@@ -196,7 +168,7 @@ struct ShardMap {
   std::unordered_map<uint64_t, std::string> IdToNames();
 
   // Returns the shard UUIDs that have been assigned but not yet acknowledged for this storage manager
-  HeartbeatResponse AssignShards(Address storage_manager, std::set<boost::uuids::uuid> initialized);
+  std::vector<ShardToInitialize> AssignShards(Address storage_manager, std::set<boost::uuids::uuid> initialized);
 
   bool SplitShard(Hlc previous_shard_map_version, LabelId label_id, const PrimaryKey &key);
 

src/expr/ast/cypher_main_visitor.hpp

@@ -33,6 +33,7 @@
 
 #include <boost/preprocessor/cat.hpp>
 
+#include "common/types.hpp"
 #include "expr/ast.hpp"
 #include "expr/ast/ast_visitor.hpp"
 #include "expr/exceptions.hpp"
@@ -51,7 +52,7 @@ constexpr char kId[] = "ID";
 
 namespace MG_INJECTED_NAMESPACE_NAME {
 namespace detail {
-using antlropencypher::v2::MemgraphCypher;
+using antlropencypher::MemgraphCypher;
 
 template <typename TVisitor>
 std::optional<std::pair<Expression *, size_t>> VisitMemoryLimit(MemgraphCypher::MemoryLimitContext *memory_limit_ctx,
@@ -211,13 +212,13 @@ inline std::string_view ToString(const PulsarConfigKey key) {
 }
 }  // namespace detail
 
-using antlropencypher::v2::MemgraphCypher;
+using antlropencypher::MemgraphCypher;
 
 struct ParsingContext {
   bool is_query_cached = false;
 };
 
-class CypherMainVisitor : public antlropencypher::v2::MemgraphCypherBaseVisitor {
+class CypherMainVisitor : public antlropencypher::MemgraphCypherBaseVisitor {
  public:
   explicit CypherMainVisitor(ParsingContext context, AstStorage *storage) : context_(context), storage_(storage) {}
 
@@ -2941,6 +2942,40 @@ class CypherMainVisitor : public antlropencypher::v2::MemgraphCypherBaseVisitor
     return schema_property_map;
   }
 
+  inline memgraph::common::SchemaConfigParams SchemaConfigKeyToEnum(std::string_view val) {
+    if (val == "replication_factor") {
+      return memgraph::common::SchemaConfigParams::REPLICATION_FACTOR;
+    } else if (val == "split_threshold") {
+      return memgraph::common::SchemaConfigParams::SPLIT_THRESHOLD;
+    }
+    throw memgraph::expr::SemanticException("Schema configuration parameter not recognized!");
+  }
+
+  /**
+   * @return Schema*
+   */
+  antlrcpp::Any visitSchemaConfigKeyValuePair(MemgraphCypher::SchemaConfigKeyValuePairContext *ctx) override {
+    MG_ASSERT(ctx->literal().size() == 2);
+    const auto key_value =
+        SchemaConfigKeyToEnum(utils::ToLowerCase(std::any_cast<std::string>(ctx->literal(0)->accept(this))));
+    // TODO(jbajic) Introduce variable values here
+    const auto value = std::any_cast<int64_t>(ctx->literal(1)->accept(this));
+    return std::pair<common::SchemaConfigParams, int64_t>{key_value, value};
+  }
+
+  /**
+   * @return Schema*
+   */
+  antlrcpp::Any visitSchemaConfiguration(MemgraphCypher::SchemaConfigurationContext *ctx) override {
+    std::unordered_map<common::SchemaConfigParams, int64_t> map;
+    for (auto *key_value_pair : ctx->schemaConfigKeyValuePair()) {
+      // If the queries are cached, then only the stripped query is parsed, so the actual keys cannot be determined
+      // here. That means duplicates cannot be checked.
+      map.insert(std::any_cast<std::pair<common::SchemaConfigParams, int64_t>>(key_value_pair->accept(this)));
+    }
+    return map;
+  }
+
   /**
    * @return Schema*
    */
@@ -2981,7 +3016,11 @@ class CypherMainVisitor : public antlropencypher::v2::MemgraphCypherBaseVisitor
     schema_query->label_ = AddLabel(std::any_cast<std::string>(ctx->labelName()->accept(this)));
     schema_query->schema_type_map_ =
         std::any_cast<std::vector<std::pair<PropertyIx, common::SchemaType>>>(ctx->schemaPropertyMap()->accept(this));
-    query_ = schema_query;
+    if (ctx->schemaConfiguration()) {
+      schema_query->schema_config_map_ = std::any_cast<std::unordered_map<common::SchemaConfigParams, int64_t>>(
+          ctx->schemaConfiguration()->accept(this));
+      query_ = schema_query;
+    }
     return schema_query;
   }
 

src/expr/interpret/eval.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -47,12 +47,12 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
   TypedValue Visit(NamedExpression &named_expression) override {
     const auto &symbol = symbol_table_->at(named_expression);
     auto value = named_expression.expression_->Accept(*this);
-    frame_->At(symbol) = value;
+    frame_->at(symbol) = value;
     return value;
   }
 
   TypedValue Visit(Identifier &ident) override {
-    return TypedValue(frame_->At(symbol_table_->at(ident)), ctx_->memory);
+    return TypedValue(frame_->at(symbol_table_->at(ident)), ctx_->memory);
   }
 
   // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
@@ -470,7 +470,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
   }
 
   TypedValue Visit(Aggregation &aggregation) override {
-    return TypedValue(frame_->At(symbol_table_->at(aggregation)), ctx_->memory);
+    return TypedValue(frame_->at(symbol_table_->at(aggregation)), ctx_->memory);
   }
 
   TypedValue Visit(Coalesce &coalesce) override {
@@ -528,8 +528,8 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     const auto &accumulator_symbol = symbol_table_->at(*reduce.accumulator_);
     auto accumulator = reduce.initializer_->Accept(*this);
     for (const auto &element : list) {
-      frame_->At(accumulator_symbol) = accumulator;
-      frame_->At(element_symbol) = element;
+      frame_->at(accumulator_symbol) = accumulator;
+      frame_->at(element_symbol) = element;
       accumulator = reduce.expression_->Accept(*this);
     }
     return accumulator;
@@ -551,7 +551,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
       if (element.IsNull()) {
         result.emplace_back();
       } else {
-        frame_->At(element_symbol) = element;
+        frame_->at(element_symbol) = element;
         result.emplace_back(extract.expression_->Accept(*this));
       }
     }
@@ -571,7 +571,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     bool has_null_elements = false;
     bool has_value = false;
     for (const auto &element : list) {
-      frame_->At(symbol) = element;
+      frame_->at(symbol) = element;
       auto result = all.where_->expression_->Accept(*this);
       if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
         throw ExpressionRuntimeException("Predicate of ALL must evaluate to boolean, got {}.", result.type());
@@ -608,7 +608,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     bool has_value = false;
     bool predicate_satisfied = false;
     for (const auto &element : list) {
-      frame_->At(symbol) = element;
+      frame_->at(symbol) = element;
       auto result = single.where_->expression_->Accept(*this);
       if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
         throw ExpressionRuntimeException("Predicate of SINGLE must evaluate to boolean, got {}.", result.type());
@@ -645,7 +645,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     const auto &symbol = symbol_table_->at(*any.identifier_);
     bool has_value = false;
     for (const auto &element : list) {
-      frame_->At(symbol) = element;
+      frame_->at(symbol) = element;
       auto result = any.where_->expression_->Accept(*this);
       if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
         throw ExpressionRuntimeException("Predicate of ANY must evaluate to boolean, got {}.", result.type());
@@ -677,7 +677,7 @@ class ExpressionEvaluator : public ExpressionVisitor<TypedValue> {
     const auto &symbol = symbol_table_->at(*none.identifier_);
     bool has_value = false;
     for (const auto &element : list) {
-      frame_->At(symbol) = element;
+      frame_->at(symbol) = element;
       auto result = none.where_->expression_->Accept(*this);
       if (!result.IsNull() && result.type() != TypedValue::Type::Bool) {
         throw ExpressionRuntimeException("Predicate of NONE must evaluate to boolean, got {}.", result.type());

src/expr/interpret/frame.hpp

@@ -30,18 +30,14 @@ class Frame {
   TypedValue &operator[](const Symbol &symbol) { return elems_[symbol.position()]; }
   const TypedValue &operator[](const Symbol &symbol) const { return elems_[symbol.position()]; }
 
-  TypedValue &At(const Symbol &symbol) { return elems_.at(symbol.position()); }
-  const TypedValue &At(const Symbol &symbol) const { return elems_.at(symbol.position()); }
+  TypedValue &at(const Symbol &symbol) { return elems_.at(symbol.position()); }
+  const TypedValue &at(const Symbol &symbol) const { return elems_.at(symbol.position()); }
 
-  uint64_t Id() const { return id_; }
-  void SetId(const uint64_t id) { id_ = id; }
-
-  const utils::pmr::vector<TypedValue> &Elems() const { return elems_; }
+  auto &elems() { return elems_; }
 
   utils::MemoryResource *GetMemoryResource() const { return elems_.get_allocator().GetMemoryResource(); }
 
  private:
-  uint64_t id_{0U};
   utils::pmr::vector<TypedValue> elems_;
 };
 

src/io/future.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -120,7 +120,7 @@ class Shared {
       MG_ASSERT(!consumed_, "Promise filled after it was already consumed!");
       MG_ASSERT(!filled_, "Promise filled twice!");
 
-      item_ = std::move(item);
+      item_ = item;
       filled_ = true;
     }  // lock released before condition variable notification
 
@@ -235,7 +235,7 @@ class Promise {
   // Fill the expected item into the Future.
   void Fill(T item) {
     MG_ASSERT(!filled_or_moved_, "Promise::Fill called on a promise that is already filled or moved!");
-    shared_->Fill(std::move(item));
+    shared_->Fill(item);
     filled_or_moved_ = true;
   }
 

src/io/local_transport/local_system.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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

src/io/local_transport/local_transport.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -30,10 +30,10 @@ class LocalTransport {
   explicit LocalTransport(std::shared_ptr<LocalTransportHandle> local_transport_handle)
       : local_transport_handle_(std::move(local_transport_handle)) {}
 
-  template <Message ResponseT, Message RequestT>
-  ResponseFuture<ResponseT> Request(Address to_address, Address from_address, RValueRef<RequestT> request,
+  template <Message RequestT, Message ResponseT>
+  ResponseFuture<ResponseT> Request(Address to_address, Address from_address, RequestT request,
                                     std::function<void()> fill_notifier, Duration timeout) {
-    return local_transport_handle_->template SubmitRequest<ResponseT, RequestT>(
+    return local_transport_handle_->template SubmitRequest<RequestT, ResponseT>(
         to_address, from_address, std::move(request), timeout, fill_notifier);
   }
 
@@ -43,8 +43,8 @@ class LocalTransport {
   }
 
   template <Message M>
-  void Send(Address to_address, Address from_address, RequestId request_id, RValueRef<M> message) {
-    return local_transport_handle_->template Send<M>(to_address, from_address, request_id, std::move(message));
+  void Send(Address to_address, Address from_address, RequestId request_id, M &&message) {
+    return local_transport_handle_->template Send<M>(to_address, from_address, request_id, std::forward<M>(message));
   }
 
   Time Now() const { return local_transport_handle_->Now(); }

src/io/local_transport/local_transport_handle.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -104,10 +104,10 @@ class LocalTransportHandle {
   }
 
   template <Message M>
-  void Send(Address to_address, Address from_address, RequestId request_id, RValueRef<M> message) {
+  void Send(Address to_address, Address from_address, RequestId request_id, M &&message) {
     auto type_info = TypeInfoFor(message);
 
-    std::any message_any(std::move(message));
+    std::any message_any(std::forward<M>(message));
     OpaqueMessage opaque_message{.to_address = to_address,
                                  .from_address = from_address,
                                  .request_id = request_id,
@@ -138,14 +138,14 @@ class LocalTransportHandle {
     cv_.notify_all();
   }
 
-  template <Message ResponseT, Message RequestT>
-  ResponseFuture<ResponseT> SubmitRequest(Address to_address, Address from_address, RValueRef<RequestT> request,
+  template <Message RequestT, Message ResponseT>
+  ResponseFuture<ResponseT> SubmitRequest(Address to_address, Address from_address, RequestT &&request,
                                           Duration timeout, std::function<void()> fill_notifier) {
     auto [future, promise] = memgraph::io::FuturePromisePairWithNotifications<ResponseResult<ResponseT>>(
         // set null notifier for when the Future::Wait is called
         nullptr,
         // set notifier for when Promise::Fill is called
-        std::move(fill_notifier));
+        std::forward<std::function<void()>>(fill_notifier));
 
     const bool port_matches = to_address.last_known_port == from_address.last_known_port;
     const bool ip_matches = to_address.last_known_ip == from_address.last_known_ip;
@@ -168,7 +168,7 @@ class LocalTransportHandle {
       promises_.emplace(std::move(promise_key), std::move(dop));
     }  // lock dropped
 
-    Send<RequestT>(to_address, from_address, request_id, std::move(request));
+    Send(to_address, from_address, request_id, std::forward<RequestT>(request));
 
     return std::move(future);
   }

src/io/message_conversion.hpp

@@ -13,7 +13,6 @@
 
 #include <boost/core/demangle.hpp>
 
-#include "io/time.hpp"
 #include "io/transport.hpp"
 #include "utils/type_info_ref.hpp"
 
@@ -39,7 +38,6 @@ struct OpaqueMessage {
   uint64_t request_id;
   std::any message;
   utils::TypeInfoRef type_info;
-  Time deliverable_at;
 
   /// Recursively tries to match a specific type from the outer
   /// variant's parameter pack against the type of the std::any,

src/io/rsm/raft.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -19,7 +19,6 @@
 #include <map>
 #include <set>
 #include <thread>
-#include <type_traits>
 #include <vector>
 
 #include <boost/core/demangle.hpp>
@@ -247,7 +246,7 @@ to a CAS operation.
 template <typename WriteOperation, typename ReadOperation, typename ReplicatedState, typename WriteResponseValue,
           typename ReadResponseValue>
 concept Rsm = requires(ReplicatedState state, WriteOperation w, ReadOperation r) {
-  { state.Read(std::move(r)) } -> std::same_as<ReadResponseValue>;
+  { state.Read(r) } -> std::same_as<ReadResponseValue>;
   { state.Apply(w) } -> std::same_as<WriteResponseValue>;
 };
 
@@ -403,7 +402,7 @@ class Raft {
         const PendingClientRequest client_request = std::move(leader.pending_client_requests.at(apply_index));
         leader.pending_client_requests.erase(apply_index);
 
-        WriteResponse<WriteResponseValue> resp{
+        const WriteResponse<WriteResponseValue> resp{
             .success = true,
             .write_return = std::move(write_return),
             .raft_index = apply_index,
@@ -555,7 +554,7 @@ class Raft {
       for (const auto &peer : peers_) {
         // request_id not necessary to set because it's not a Future-backed Request.
         static constexpr auto request_id = 0;
-        io_.template Send(peer, request_id, VoteRequest{request});
+        io_.template Send<VoteRequest>(peer, request_id, request);
         outstanding_votes.insert(peer);
       }
 
@@ -625,12 +624,13 @@ class Raft {
       MG_ASSERT(std::max(req.term, state_.term) == req.term);
     }
 
-    io_.Send(from_address, request_id,
-             VoteResponse{
-                 .term = std::max(req.term, state_.term),
-                 .committed_log_size = state_.committed_log_size,
-                 .vote_granted = new_leader,
-             });
+    const VoteResponse res{
+        .term = std::max(req.term, state_.term),
+        .committed_log_size = state_.committed_log_size,
+        .vote_granted = new_leader,
+    };
+
+    io_.Send(from_address, request_id, res);
 
     if (new_leader) {
       // become a follower
@@ -718,10 +718,6 @@ class Raft {
         .log_size = state_.log.size(),
     };
 
-    static_assert(std::is_trivially_copyable_v<AppendResponse>,
-                  "This function copies this message, therefore it is important to be trivially copyable. Otherwise it "
-                  "should be moved");
-
     if constexpr (std::is_same<ALL, Leader>()) {
       MG_ASSERT(req.term != state_.term, "Multiple leaders are acting under the term ", req.term);
     }
@@ -740,7 +736,7 @@ class Raft {
       // become follower of this leader, reply with our log status
       state_.term = req.term;
 
-      io_.Send(from_address, request_id, AppendResponse{res});
+      io_.Send(from_address, request_id, res);
 
       Log("becoming Follower of Leader ", from_address.last_known_port, " at term ", req.term);
       return Follower{
@@ -751,7 +747,7 @@ class Raft {
 
     if (req.term < state_.term) {
       // nack this request from an old leader
-      io_.Send(from_address, request_id, AppendResponse{res});
+      io_.Send(from_address, request_id, res);
 
       return std::nullopt;
     }
@@ -812,7 +808,7 @@ class Raft {
 
     Log("returning log_size of ", res.log_size);
 
-    io_.Send(from_address, request_id, AppendResponse{res});
+    io_.Send(from_address, request_id, res);
 
     return std::nullopt;
   }
@@ -863,17 +859,17 @@ class Raft {
     auto type_info = TypeInfoFor(req);
     std::string demangled_name = boost::core::demangle(type_info.get().name());
     Log("handling ReadOperation<" + demangled_name + ">");
-    ReadOperation &read_operation = req.operation;
+    ReadOperation read_operation = req.operation;
 
-    ReadResponseValue read_return = replicated_state_.Read(std::move(read_operation));
+    ReadResponseValue read_return = replicated_state_.Read(read_operation);
 
-    ReadResponse<ReadResponseValue> resp{
+    const ReadResponse<ReadResponseValue> resp{
         .success = true,
         .read_return = std::move(read_return),
         .retry_leader = std::nullopt,
     };
 
-    io_.Send(from_address, request_id, std::move(resp));
+    io_.Send(from_address, request_id, resp);
 
     return std::nullopt;
   }
@@ -882,11 +878,11 @@ class Raft {
   std::optional<Role> Handle(Candidate & /* variable */, ReadRequest<ReadOperation> && /* variable */,
                              RequestId request_id, Address from_address) {
     Log("received ReadOperation - not redirecting because no Leader is known");
-    ReadResponse<ReadResponseValue> res{
+    const ReadResponse<ReadResponseValue> res{
         .success = false,
     };
 
-    io_.Send(from_address, request_id, std::move(res));
+    io_.Send(from_address, request_id, res);
 
     Cron();
 
@@ -898,12 +894,12 @@ class Raft {
                              Address from_address) {
     Log("redirecting client to known Leader with port ", follower.leader_address.last_known_port);
 
-    ReadResponse<ReadResponseValue> res{
+    const ReadResponse<ReadResponseValue> res{
         .success = false,
         .retry_leader = follower.leader_address,
     };
 
-    io_.Send(from_address, request_id, std::move(res));
+    io_.Send(from_address, request_id, res);
 
     return std::nullopt;
   }
@@ -917,12 +913,12 @@ class Raft {
                              Address from_address) {
     Log("redirecting client to known Leader with port ", follower.leader_address.last_known_port);
 
-    WriteResponse<WriteResponseValue> res{
+    const WriteResponse<WriteResponseValue> res{
         .success = false,
         .retry_leader = follower.leader_address,
     };
 
-    io_.Send(from_address, request_id, std::move(res));
+    io_.Send(from_address, request_id, res);
 
     return std::nullopt;
   }
@@ -931,11 +927,11 @@ class Raft {
                              RequestId request_id, Address from_address) {
     Log("received WriteRequest - not redirecting because no Leader is known");
 
-    WriteResponse<WriteResponseValue> res{
+    const WriteResponse<WriteResponseValue> res{
         .success = false,
     };
 
-    io_.Send(from_address, request_id, std::move(res));
+    io_.Send(from_address, request_id, res);
 
     Cron();
 

src/io/rsm/rsm_client.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -95,7 +95,7 @@ class RsmClient {
   BasicResult<TimedOut, WriteResponseT> SendWriteRequest(WriteRequestT req) {
     Notifier notifier;
     const ReadinessToken readiness_token{0};
-    SendAsyncWriteRequest(std::move(req), notifier, readiness_token);
+    SendAsyncWriteRequest(req, notifier, readiness_token);
     auto poll_result = AwaitAsyncWriteRequest(readiness_token);
     while (!poll_result) {
       poll_result = AwaitAsyncWriteRequest(readiness_token);
@@ -106,7 +106,7 @@ class RsmClient {
   BasicResult<TimedOut, ReadResponseT> SendReadRequest(ReadRequestT req) {
     Notifier notifier;
     const ReadinessToken readiness_token{0};
-    SendAsyncReadRequest(std::move(req), notifier, readiness_token);
+    SendAsyncReadRequest(req, notifier, readiness_token);
     auto poll_result = AwaitAsyncReadRequest(readiness_token);
     while (!poll_result) {
       poll_result = AwaitAsyncReadRequest(readiness_token);
@@ -115,15 +115,15 @@ class RsmClient {
   }
 
   /// AsyncRead methods
-  void SendAsyncReadRequest(ReadRequestT &&req, Notifier notifier, ReadinessToken readiness_token) {
+  void SendAsyncReadRequest(const ReadRequestT &req, Notifier notifier, ReadinessToken readiness_token) {
     ReadRequest<ReadRequestT> read_req = {.operation = req};
 
     AsyncRequest<ReadRequestT, ReadResponse<ReadResponseT>> async_request{
         .start_time = io_.Now(),
         .request = std::move(req),
         .notifier = notifier,
-        .future = io_.template RequestWithNotification<ReadResponse<ReadResponseT>, ReadRequest<ReadRequestT>>(
-            leader_, std::move(read_req), notifier, readiness_token),
+        .future = io_.template RequestWithNotification<ReadRequest<ReadRequestT>, ReadResponse<ReadResponseT>>(
+            leader_, read_req, notifier, readiness_token),
     };
 
     async_reads_.emplace(readiness_token.GetId(), std::move(async_request));
@@ -134,8 +134,8 @@ class RsmClient {
 
     ReadRequest<ReadRequestT> read_req = {.operation = async_request.request};
 
-    async_request.future = io_.template RequestWithNotification<ReadResponse<ReadResponseT>, ReadRequest<ReadRequestT>>(
-        leader_, std::move(read_req), async_request.notifier, readiness_token);
+    async_request.future = io_.template RequestWithNotification<ReadRequest<ReadRequestT>, ReadResponse<ReadResponseT>>(
+        leader_, read_req, async_request.notifier, readiness_token);
   }
 
   std::optional<BasicResult<TimedOut, ReadResponseT>> PollAsyncReadRequest(const ReadinessToken &readiness_token) {
@@ -184,15 +184,15 @@ class RsmClient {
   }
 
   /// AsyncWrite methods
-  void SendAsyncWriteRequest(WriteRequestT &&req, Notifier notifier, ReadinessToken readiness_token) {
+  void SendAsyncWriteRequest(const WriteRequestT &req, Notifier notifier, ReadinessToken readiness_token) {
     WriteRequest<WriteRequestT> write_req = {.operation = req};
 
     AsyncRequest<WriteRequestT, WriteResponse<WriteResponseT>> async_request{
         .start_time = io_.Now(),
         .request = std::move(req),
         .notifier = notifier,
-        .future = io_.template RequestWithNotification<WriteResponse<WriteResponseT>, WriteRequest<WriteRequestT>>(
-            leader_, std::move(write_req), notifier, readiness_token),
+        .future = io_.template RequestWithNotification<WriteRequest<WriteRequestT>, WriteResponse<WriteResponseT>>(
+            leader_, write_req, notifier, readiness_token),
     };
 
     async_writes_.emplace(readiness_token.GetId(), std::move(async_request));
@@ -204,8 +204,8 @@ class RsmClient {
     WriteRequest<WriteRequestT> write_req = {.operation = async_request.request};
 
     async_request.future =
-        io_.template RequestWithNotification<WriteResponse<WriteResponseT>, WriteRequest<WriteRequestT>>(
-            leader_, std::move(write_req), async_request.notifier, readiness_token);
+        io_.template RequestWithNotification<WriteRequest<WriteRequestT>, WriteResponse<WriteResponseT>>(
+            leader_, write_req, async_request.notifier, readiness_token);
   }
 
   std::optional<BasicResult<TimedOut, WriteResponseT>> PollAsyncWriteRequest(const ReadinessToken &readiness_token) {

src/io/simulator/simulator.hpp

@@ -41,7 +41,7 @@ class Simulator {
   Io<SimulatorTransport> Register(Address address) {
     std::uniform_int_distribution<uint64_t> seed_distrib;
     uint64_t seed = seed_distrib(rng_);
-    return Io{SimulatorTransport(simulator_handle_, address, seed), address};
+    return Io{SimulatorTransport{simulator_handle_, address, seed}, address};
   }
 
   void IncrementServerCountAndWaitForQuiescentState(Address address) {
@@ -50,12 +50,8 @@ class Simulator {
 
   SimulatorStats Stats() { return simulator_handle_->Stats(); }
 
-  std::shared_ptr<SimulatorHandle> GetSimulatorHandle() const { return simulator_handle_; }
-
   std::function<bool()> GetSimulatorTickClosure() {
-    std::function<bool()> tick_closure = [handle_copy = simulator_handle_] {
-      return handle_copy->MaybeTickSimulator();
-    };
+    std::function<bool()> tick_closure = [handle_copy = simulator_handle_] { return handle_copy->MaybeTickSimulator(); };
     return tick_closure;
   }
 };

src/io/simulator/simulator_config.hpp

@@ -26,6 +26,5 @@ struct SimulatorConfig {
   uint64_t rng_seed = 0;
   Time start_time = Time::min();
   Time abort_time = Time::max();
-  Duration message_delay = std::chrono::microseconds(100);
 };
 };  // namespace memgraph::io::simulator

src/io/simulator/simulator_handle.cpp

@@ -175,8 +175,8 @@ bool SimulatorHandle::MaybeTickSimulator() {
     spdlog::trace("simulator adding message to can_receive_ from {} to {}", opaque_message.from_address.last_known_port,
                   opaque_message.to_address.last_known_port);
     const auto &[om_vec, inserted] =
-        can_receive_.try_emplace(to_address.ToPartialAddress(), std::deque<OpaqueMessage>());
-    om_vec->second.emplace_front(std::move(opaque_message));
+        can_receive_.try_emplace(to_address.ToPartialAddress(), std::vector<OpaqueMessage>());
+    om_vec->second.emplace_back(std::move(opaque_message));
   }
 
   return true;

src/io/simulator/simulator_handle.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -46,7 +46,7 @@ class SimulatorHandle {
   std::map<PromiseKey, DeadlineAndOpaquePromise> promises_;
 
   // messages that are sent to servers that may later receive them
-  std::map<PartialAddress, std::deque<OpaqueMessage>> can_receive_;
+  std::map<PartialAddress, std::vector<OpaqueMessage>> can_receive_;
 
   Time cluster_wide_time_microseconds_;
   bool should_shut_down_ = false;
@@ -105,19 +105,19 @@ class SimulatorHandle {
 
   bool ShouldShutDown() const;
 
-  template <Message ResponseT, Message RequestT>
-  ResponseFuture<ResponseT> SubmitRequest(Address to_address, Address from_address, RValueRef<RequestT> request,
-                                          Duration timeout, std::function<bool()> &&maybe_tick_simulator,
-                                          std::function<void()> &&fill_notifier) {
+  template <Message Request, Message Response>
+  ResponseFuture<Response> SubmitRequest(Address to_address, Address from_address, Request &&request, Duration timeout,
+                                         std::function<bool()> &&maybe_tick_simulator,
+                                         std::function<void()> &&fill_notifier) {
     auto type_info = TypeInfoFor(request);
     std::string demangled_name = boost::core::demangle(type_info.get().name());
     spdlog::trace("simulator sending request {} to {}", demangled_name, to_address);
 
-    auto [future, promise] = memgraph::io::FuturePromisePairWithNotifications<ResponseResult<ResponseT>>(
+    auto [future, promise] = memgraph::io::FuturePromisePairWithNotifications<ResponseResult<Response>>(
         // set notifier for when the Future::Wait is called
-        std::move(maybe_tick_simulator),
+        std::forward<std::function<bool()>>(maybe_tick_simulator),
         // set notifier for when Promise::Fill is called
-        std::move(fill_notifier));
+        std::forward<std::function<void()>>(fill_notifier));
 
     {
       std::unique_lock<std::mutex> lock(mu_);
@@ -126,13 +126,12 @@ class SimulatorHandle {
 
       const Time deadline = cluster_wide_time_microseconds_ + timeout;
 
-      std::any message(std::move(request));
+      std::any message(request);
       OpaqueMessage om{.to_address = to_address,
                        .from_address = from_address,
                        .request_id = request_id,
                        .message = std::move(message),
-                       .type_info = type_info,
-                       .deliverable_at = cluster_wide_time_microseconds_ + config_.message_delay};
+                       .type_info = type_info};
       in_flight_.emplace_back(std::make_pair(to_address, std::move(om)));
 
       PromiseKey promise_key{.requester_address = from_address, .request_id = request_id};
@@ -166,12 +165,8 @@ class SimulatorHandle {
 
     while (!should_shut_down_ && (cluster_wide_time_microseconds_ < deadline)) {
       if (can_receive_.contains(partial_address)) {
-        std::deque<OpaqueMessage> &can_rx = can_receive_.at(partial_address);
-
-        bool contains_items = !can_rx.empty();
-        bool can_receive = contains_items && can_rx.back().deliverable_at <= cluster_wide_time_microseconds_;
-
-        if (can_receive) {
+        std::vector<OpaqueMessage> &can_rx = can_receive_.at(partial_address);
+        if (!can_rx.empty()) {
           OpaqueMessage message = std::move(can_rx.back());
           can_rx.pop_back();
 
@@ -182,12 +177,6 @@ class SimulatorHandle {
 
           return std::move(m_opt).value();
         }
-        if (contains_items) {
-          auto count = can_rx.back().deliverable_at.time_since_epoch().count();
-          auto now_count = cluster_wide_time_microseconds_.time_since_epoch().count();
-          spdlog::trace("can't receive message yet due to artificial latency. deliverable_at: {}, now: {}", count,
-                        now_count);
-        }
       }
 
       if (!should_shut_down_) {
@@ -205,7 +194,7 @@ class SimulatorHandle {
   }
 
   template <Message M>
-  void Send(Address to_address, Address from_address, RequestId request_id, RValueRef<M> message) {
+  void Send(Address to_address, Address from_address, RequestId request_id, M message) {
     spdlog::trace("sending message from {} to {}", from_address.last_known_port, to_address.last_known_port);
     auto type_info = TypeInfoFor(message);
     {
@@ -215,8 +204,7 @@ class SimulatorHandle {
                        .from_address = from_address,
                        .request_id = request_id,
                        .message = std::move(message_any),
-                       .type_info = type_info,
-                       .deliverable_at = cluster_wide_time_microseconds_ + config_.message_delay};
+                       .type_info = type_info};
       in_flight_.emplace_back(std::make_pair(std::move(to_address), std::move(om)));
 
       stats_.total_messages++;

src/io/simulator/simulator_transport.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -26,21 +26,19 @@ using memgraph::io::Time;
 
 class SimulatorTransport {
   std::shared_ptr<SimulatorHandle> simulator_handle_;
-  Address address_;
+  const Address address_;
   std::mt19937 rng_;
 
  public:
   SimulatorTransport(std::shared_ptr<SimulatorHandle> simulator_handle, Address address, uint64_t seed)
       : simulator_handle_(simulator_handle), address_(address), rng_(std::mt19937{seed}) {}
 
-  template <Message ResponseT, Message RequestT>
-  ResponseFuture<ResponseT> Request(Address to_address, Address from_address, RValueRef<RequestT> request,
+  template <Message RequestT, Message ResponseT>
+  ResponseFuture<ResponseT> Request(Address to_address, Address from_address, RequestT request,
                                     std::function<void()> notification, Duration timeout) {
-    std::function<bool()> tick_simulator = [handle_copy = simulator_handle_] {
-      return handle_copy->MaybeTickSimulator();
-    };
+    std::function<bool()> tick_simulator = [handle_copy = simulator_handle_] { return handle_copy->MaybeTickSimulator(); };
 
-    return simulator_handle_->template SubmitRequest<ResponseT, RequestT>(
+    return simulator_handle_->template SubmitRequest<RequestT, ResponseT>(
         to_address, from_address, std::move(request), timeout, std::move(tick_simulator), std::move(notification));
   }
 
@@ -50,8 +48,8 @@ class SimulatorTransport {
   }
 
   template <Message M>
-  void Send(Address to_address, Address from_address, uint64_t request_id, RValueRef<M> message) {
-    return simulator_handle_->template Send<M>(to_address, from_address, request_id, std::move(message));
+  void Send(Address to_address, Address from_address, uint64_t request_id, M message) {
+    return simulator_handle_->template Send<M>(to_address, from_address, request_id, message);
   }
 
   Time Now() const { return simulator_handle_->Now(); }

src/io/transport.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -22,7 +22,6 @@
 #include "io/message_histogram_collector.hpp"
 #include "io/notifier.hpp"
 #include "io/time.hpp"
-#include "utils/concepts.hpp"
 #include "utils/result.hpp"
 
 namespace memgraph::io {
@@ -33,15 +32,7 @@ using memgraph::utils::BasicResult;
 // reasonable constraints around message types over time,
 // as we adapt things to use Thrift-generated message types.
 template <typename T>
-concept Message = std::movable<T> && std::copyable<T>;
-
-template <utils::Object T>
-struct RValueRefEnforcer {
-  using Type = T &&;
-};
-
-template <typename T>
-using RValueRef = typename RValueRefEnforcer<T>::Type;
+concept Message = std::same_as<T, std::decay_t<T>>;
 
 using RequestId = uint64_t;
 
@@ -91,44 +82,44 @@ class Io {
   Duration GetDefaultTimeout() { return default_timeout_; }
 
   /// Issue a request with an explicit timeout in microseconds provided. This tends to be used by clients.
-  template <Message ResponseT, Message RequestT>
-  ResponseFuture<ResponseT> RequestWithTimeout(Address address, RValueRef<RequestT> request, Duration timeout) {
+  template <Message RequestT, Message ResponseT>
+  ResponseFuture<ResponseT> RequestWithTimeout(Address address, RequestT request, Duration timeout) {
     const Address from_address = address_;
     std::function<void()> fill_notifier = nullptr;
-    return implementation_.template Request<ResponseT, RequestT>(address, from_address, std::move(request),
-                                                                 fill_notifier, timeout);
+    return implementation_.template Request<RequestT, ResponseT>(address, from_address, request, fill_notifier,
+                                                                 timeout);
   }
 
   /// Issue a request that times out after the default timeout. This tends
   /// to be used by clients.
-  template <Message ResponseT, Message RequestT>
-  ResponseFuture<ResponseT> Request(Address to_address, RValueRef<RequestT> request) {
+  template <Message RequestT, Message ResponseT>
+  ResponseFuture<ResponseT> Request(Address to_address, RequestT request) {
     const Duration timeout = default_timeout_;
     const Address from_address = address_;
     std::function<void()> fill_notifier = nullptr;
-    return implementation_.template Request<ResponseT, RequestT>(to_address, from_address, std::move(request),
+    return implementation_.template Request<RequestT, ResponseT>(to_address, from_address, std::move(request),
                                                                  fill_notifier, timeout);
   }
 
   /// Issue a request that will notify a Notifier when it is filled or times out.
-  template <Message ResponseT, Message RequestT>
-  ResponseFuture<ResponseT> RequestWithNotification(Address to_address, RValueRef<RequestT> request, Notifier notifier,
+  template <Message RequestT, Message ResponseT>
+  ResponseFuture<ResponseT> RequestWithNotification(Address to_address, RequestT request, Notifier notifier,
                                                     ReadinessToken readiness_token) {
     const Duration timeout = default_timeout_;
     const Address from_address = address_;
     std::function<void()> fill_notifier = [notifier, readiness_token]() { notifier.Notify(readiness_token); };
-    return implementation_.template Request<ResponseT, RequestT>(to_address, from_address, std::move(request),
+    return implementation_.template Request<RequestT, ResponseT>(to_address, from_address, std::move(request),
                                                                  fill_notifier, timeout);
   }
 
   /// Issue a request that will notify a Notifier when it is filled or times out.
-  template <Message ResponseT, Message RequestT>
-  ResponseFuture<ResponseT> RequestWithNotificationAndTimeout(Address to_address, RequestT &&request, Notifier notifier,
+  template <Message RequestT, Message ResponseT>
+  ResponseFuture<ResponseT> RequestWithNotificationAndTimeout(Address to_address, RequestT request, Notifier notifier,
                                                               ReadinessToken readiness_token, Duration timeout) {
     const Address from_address = address_;
     std::function<void()> fill_notifier = [notifier, readiness_token]() { notifier.Notify(readiness_token); };
-    return implementation_.template Request<ResponseT>(to_address, from_address, std::forward<RequestT>(request),
-                                                       fill_notifier, timeout);
+    return implementation_.template Request<RequestT, ResponseT>(to_address, from_address, std::move(request),
+                                                                 fill_notifier, timeout);
   }
 
   /// Wait for an explicit number of microseconds for a request of one of the
@@ -150,9 +141,9 @@ class Io {
   /// responses are not necessarily expected, and for servers to respond to requests.
   /// If you need reliable delivery, this must be built on-top. TCP is not enough for most use cases.
   template <Message M>
-  void Send(Address to_address, RequestId request_id, M &&message) {
+  void Send(Address to_address, RequestId request_id, M message) {
     Address from_address = address_;
-    return implementation_.template Send<M>(to_address, from_address, request_id, std::forward<M>(message));
+    return implementation_.template Send<M>(to_address, from_address, request_id, std::move(message));
   }
 
   /// The current system time. This time source should be preferred over any other,

src/memgraph.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -640,8 +640,6 @@ int main(int argc, char **argv) {
   memgraph::machine_manager::MachineManager<memgraph::io::local_transport::LocalTransport> mm{io, config, coordinator};
   std::jthread mm_thread([&mm] { mm.Run(); });
 
-  auto rr_factory = std::make_unique<memgraph::query::v2::LocalRequestRouterFactory>(io);
-
   memgraph::query::v2::InterpreterContext interpreter_context{
       (memgraph::storage::v3::Shard *)(nullptr),
       {.query = {.allow_load_csv = FLAGS_allow_load_csv},
@@ -652,7 +650,7 @@ int main(int argc, char **argv) {
        .stream_transaction_conflict_retries = FLAGS_stream_transaction_conflict_retries,
        .stream_transaction_retry_interval = std::chrono::milliseconds(FLAGS_stream_transaction_retry_interval)},
       FLAGS_data_directory,
-      std::move(rr_factory),
+      std::move(io),
       mm.CoordinatorAddress()};
 
   SessionData session_data{&interpreter_context};

src/parser/CMakeLists.txt

@@ -23,7 +23,7 @@ add_custom_command(
     COMMAND ${CMAKE_COMMAND} -E make_directory ${opencypher_generated}
     COMMAND
         java -jar ${CMAKE_SOURCE_DIR}/libs/antlr-4.10.1-complete.jar
-            -Dlanguage=Cpp -visitor -package antlropencypher::v2
+            -Dlanguage=Cpp -visitor -package antlropencypher
             -o ${opencypher_generated}
             ${opencypher_lexer_grammar} ${opencypher_parser_grammar}
     WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"

src/parser/opencypher/grammar/MemgraphCypher.g4

@@ -394,6 +394,10 @@ propertyKeyTypePair : propertyKeyName propertyType ;
 
 schemaPropertyMap : '(' propertyKeyTypePair ( ',' propertyKeyTypePair )* ')' ;
 
-createSchema : CREATE SCHEMA ON ':' labelName schemaPropertyMap ;
+schemaConfigKeyValuePair : literal '=' literal ;
+
+schemaConfiguration : ( schemaConfigKeyValuePair ( ',' schemaConfigKeyValuePair )* )? ;
+
+createSchema : CREATE SCHEMA ON ':' labelName schemaPropertyMap ( CONFIG schemaConfiguration ) ? ;
 
 dropSchema : DROP SCHEMA ON ':' labelName ;

src/parser/opencypher/parser.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -14,10 +14,10 @@
 #include <string>
 
 #include "antlr4-runtime.h"
+#include "utils/exceptions.hpp"
 #include "parser/opencypher/generated/MemgraphCypher.h"
 #include "parser/opencypher/generated/MemgraphCypherLexer.h"
 #include "utils/concepts.hpp"
-#include "utils/exceptions.hpp"
 
 namespace memgraph::frontend::opencypher {
 
@@ -32,9 +32,11 @@ class SyntaxException : public utils::BasicException {
  * This thing must me a class since parser.cypher() returns pointer and there is
  * no way for us to get ownership over the object.
  */
-enum class ParserOpTag : uint8_t { CYPHER, EXPRESSION };
+enum class ParserOpTag : uint8_t {
+  CYPHER, EXPRESSION
+};
 
-template <ParserOpTag Tag = ParserOpTag::CYPHER>
+template<ParserOpTag Tag = ParserOpTag::CYPHER>
 class Parser {
  public:
   /**
@@ -44,9 +46,10 @@ class Parser {
   Parser(const std::string query) : query_(std::move(query)) {
     parser_.removeErrorListeners();
     parser_.addErrorListener(&error_listener_);
-    if constexpr (Tag == ParserOpTag::CYPHER) {
+    if constexpr(Tag == ParserOpTag::CYPHER) {
       tree_ = parser_.cypher();
-    } else {
+    }
+    else {
       tree_ = parser_.expression();
     }
     if (parser_.getNumberOfSyntaxErrors()) {
@@ -72,11 +75,11 @@ class Parser {
   FirstMessageErrorListener error_listener_;
   std::string query_;
   antlr4::ANTLRInputStream input_{query_};
-  antlropencypher::v2::MemgraphCypherLexer lexer_{&input_};
+  antlropencypher::MemgraphCypherLexer lexer_{&input_};
   antlr4::CommonTokenStream tokens_{&lexer_};
 
   // generate ast
-  antlropencypher::v2::MemgraphCypher parser_{&tokens_};
+  antlropencypher::MemgraphCypher parser_{&tokens_};
   antlr4::tree::ParseTree *tree_ = nullptr;
 };
 }  // namespace memgraph::frontend::opencypher

src/query/CMakeLists.txt

@@ -48,20 +48,18 @@ add_dependencies(mg-query generate_lcp_query)
 target_include_directories(mg-query PUBLIC ${CMAKE_SOURCE_DIR}/include)
 target_link_libraries(mg-query dl cppitertools Boost::headers)
 target_link_libraries(mg-query mg-integrations-pulsar mg-integrations-kafka mg-storage-v2 mg-license mg-utils mg-kvstore mg-memory)
-
 if(NOT "${MG_PYTHON_PATH}" STREQUAL "")
     set(Python3_ROOT_DIR "${MG_PYTHON_PATH}")
 endif()
-
 if("${MG_PYTHON_VERSION}" STREQUAL "")
     find_package(Python3 3.5 REQUIRED COMPONENTS Development)
 else()
     find_package(Python3 "${MG_PYTHON_VERSION}" EXACT REQUIRED COMPONENTS Development)
 endif()
-
 target_link_libraries(mg-query Python3::Python)
 
 # Generate Antlr openCypher parser
+
 set(opencypher_frontend ${CMAKE_CURRENT_SOURCE_DIR}/frontend/opencypher)
 set(opencypher_generated ${opencypher_frontend}/generated)
 set(opencypher_lexer_grammar ${opencypher_frontend}/grammar/MemgraphCypherLexer.g4)
@@ -84,15 +82,15 @@ add_custom_command(
     OUTPUT ${antlr_opencypher_generated_src} ${antlr_opencypher_generated_include}
     COMMAND ${CMAKE_COMMAND} -E make_directory ${opencypher_generated}
     COMMAND
-    java -jar ${CMAKE_SOURCE_DIR}/libs/antlr-4.10.1-complete.jar
-    -Dlanguage=Cpp -visitor -package antlropencypher
-    -o ${opencypher_generated}
-    ${opencypher_lexer_grammar} ${opencypher_parser_grammar}
+        java -jar ${CMAKE_SOURCE_DIR}/libs/antlr-4.10.1-complete.jar
+            -Dlanguage=Cpp -visitor -package antlropencypher
+            -o ${opencypher_generated}
+            ${opencypher_lexer_grammar} ${opencypher_parser_grammar}
     WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
     DEPENDS
-    ${opencypher_lexer_grammar} ${opencypher_parser_grammar}
-    ${opencypher_frontend}/grammar/CypherLexer.g4
-    ${opencypher_frontend}/grammar/Cypher.g4)
+        ${opencypher_lexer_grammar} ${opencypher_parser_grammar}
+        ${opencypher_frontend}/grammar/CypherLexer.g4
+        ${opencypher_frontend}/grammar/Cypher.g4)
 
 add_custom_target(generate_opencypher_parser
     DEPENDS ${antlr_opencypher_generated_src} ${antlr_opencypher_generated_include})

src/query/v2/cypher_query_interpreter.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -14,9 +14,9 @@
 #include "query/v2/request_router.hpp"
 
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_HIDDEN_bool(query_v2_cost_planner, true, "Use the cost-estimating query planner.");
+DEFINE_HIDDEN_bool(query_cost_planner, true, "Use the cost-estimating query planner.");
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_VALIDATED_int32(query_v2_plan_cache_ttl, 60, "Time to live for cached query plans, in seconds.",
+DEFINE_VALIDATED_int32(query_plan_cache_ttl, 60, "Time to live for cached query plans, in seconds.",
                        FLAG_IN_RANGE(0, std::numeric_limits<int32_t>::max()));
 
 namespace memgraph::query::v2 {
@@ -123,7 +123,7 @@ std::unique_ptr<LogicalPlan> MakeLogicalPlan(AstStorage ast_storage, CypherQuery
   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_v2_cost_planner);
+  auto [root, cost] = plan::MakeLogicalPlan(&planning_context, parameters, FLAGS_query_cost_planner);
   return std::make_unique<SingleNodeLogicalPlan>(std::move(root), cost, std::move(ast_storage),
                                                  std::move(symbol_table));
 }

src/query/v2/cypher_query_interpreter.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -22,9 +22,9 @@
 #include "utils/timer.hpp"
 
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_bool(query_v2_cost_planner);
+DECLARE_bool(query_cost_planner);
 // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_int32(query_v2_plan_cache_ttl);
+DECLARE_int32(query_plan_cache_ttl);
 
 namespace memgraph::query::v2 {
 
@@ -58,7 +58,7 @@ class CachedPlan {
 
   bool IsExpired() const {
     // NOLINTNEXTLINE (modernize-use-nullptr)
-    return cache_timer_.Elapsed() > std::chrono::seconds(FLAGS_query_v2_plan_cache_ttl);
+    return cache_timer_.Elapsed() > std::chrono::seconds(FLAGS_query_plan_cache_ttl);
   };
 
  private:

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

@@ -147,6 +147,14 @@ cpp<#
     }
     cpp<#)
 
+(defun clone-map (source dest)
+    #>cpp
+    ${dest}.reserve(${source}.size());
+    for (const auto &[config_key, config_val]: ${source}) {
+      ${dest}.emplace(config_key, config_val);
+    }
+    cpp<#)
+
 ;; The following index structs serve as a decoupling point of AST from
 ;; concrete database types. All the names are collected in AstStorage, and can
 ;; be indexed through these instances. This means that we can create a vector
@@ -2698,10 +2706,15 @@ cpp<#
                    #>cpp
                    ${dest} = storage->GetLabelIx(${source}.name);
                    cpp<#))
+
     (schema_type_map "std::vector<std::pair<PropertyIx, common::SchemaType>>"
       :slk-save #'slk-save-property-map
       :slk-load #'slk-load-property-map
       :clone #'clone-schema-property-vector
+      :scope :public)
+
+   (schema_config_map "std::unordered_map<common::SchemaConfigParams, int64_t>"
+      :clone #'clone-map
       :scope :public))
 
   (:public

src/query/v2/interpreter.cpp

@@ -22,6 +22,7 @@
 #include <memory>
 #include <optional>
 
+#include "common/types.hpp"
 #include "coordinator/coordinator_client.hpp"
 #include "expr/ast/ast_visitor.hpp"
 #include "io/local_transport/local_system.hpp"
@@ -64,11 +65,7 @@
 #include "utils/tsc.hpp"
 #include "utils/variant_helpers.hpp"
 
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_bool(use_multi_frame, false, "Whether to use MultiFrame or not");
-
 namespace EventCounter {
-
 extern Event ReadQuery;
 extern Event WriteQuery;
 extern Event ReadWriteQuery;
@@ -78,7 +75,6 @@ extern const Event LabelPropertyIndexCreated;
 
 extern const Event StreamsCreated;
 extern const Event TriggersCreated;
-
 }  // namespace EventCounter
 
 namespace memgraph::query::v2 {
@@ -547,7 +543,7 @@ Callback HandleSchemaQuery(SchemaQuery *schema_query, InterpreterContext *interp
         std::vector<std::vector<TypedValue>> results;
         results.reserve(schemas_info.schemas.size());
 
-        for (const auto &[label_id, schema_types] : schemas_info.schemas) {
+        for ([[maybe_unused]] const auto &[label_id, schema_types, config] : schemas_info.schemas) {
           std::vector<TypedValue> schema_info_row;
           schema_info_row.reserve(3);
 
@@ -575,7 +571,7 @@ Callback HandleSchemaQuery(SchemaQuery *schema_query, InterpreterContext *interp
         const auto *schema = db->GetSchema(label);
         std::vector<std::vector<TypedValue>> results;
         if (schema) {
-          for (const auto &schema_property : schema->second) {
+          for (const auto &schema_property : schema->properties) {
             std::vector<TypedValue> schema_info_row;
             schema_info_row.reserve(2);
             schema_info_row.emplace_back(db->PropertyToName(schema_property.property_id));
@@ -594,7 +590,8 @@ Callback HandleSchemaQuery(SchemaQuery *schema_query, InterpreterContext *interp
         throw SyntaxException("One or more types have to be defined in schema definition.");
       }
       callback.fn = [interpreter_context, primary_label = schema_query->label_,
-                     schema_type_map = std::move(schema_type_map)]() {
+                     schema_type_map = std::move(schema_type_map),
+                     config_map = std::move(schema_query->schema_config_map_)]() {
         auto *db = interpreter_context->db;
         const auto label = interpreter_context->NameToLabelId(primary_label.name);
         std::vector<storage::v3::SchemaProperty> schemas_types;
@@ -603,8 +600,30 @@ Callback HandleSchemaQuery(SchemaQuery *schema_query, InterpreterContext *interp
           auto property_id = interpreter_context->NameToPropertyId(schema_type.first.name);
           schemas_types.push_back({property_id, schema_type.second});
         }
-        if (!db->CreateSchema(label, schemas_types)) {
-          throw QueryException(fmt::format("Schema on label :{} already exists!", primary_label.name));
+        auto schema_config = std::invoke([&config_map]() -> std::optional<storage::v3::Schema::SchemaConfiguration> {
+          if (!config_map.empty()) {
+            return std::nullopt;
+          }
+          storage::v3::Schema::SchemaConfiguration config;
+          if (const auto replication_factor_it = config_map.find(common::SchemaConfigParams::REPLICATION_FACTOR);
+              replication_factor_it != config_map.end()) {
+            config.replication_factor = replication_factor_it->second;
+          }
+          if (const auto split_threshold_it = config_map.find(common::SchemaConfigParams::SPLIT_THRESHOLD);
+              split_threshold_it != config_map.end()) {
+            config.split_threshold = split_threshold_it->second;
+          }
+          return config;
+        });
+        // TODO FIx this late
+        if (schema_config) {
+          if (!db->CreateSchema(label, schemas_types, *schema_config)) {
+            throw QueryException(fmt::format("Schema on label :{} already exists!", primary_label.name));
+          }
+        } else {
+          if (!db->CreateSchema(label, schemas_types)) {
+            throw QueryException(fmt::format("Schema on label :{} already exists!", primary_label.name));
+          }
         }
         return std::vector<std::vector<TypedValue>>{};
       };
@@ -693,7 +712,7 @@ PullPlan::PullPlan(const std::shared_ptr<CachedPlan> plan, const Parameters &par
     : plan_(plan),
       cursor_(plan->plan().MakeCursor(execution_memory)),
       frame_(plan->symbol_table().max_position(), execution_memory),
-      multi_frame_(plan->symbol_table().max_position(), FLAGS_default_multi_frame_size, execution_memory),
+      multi_frame_(plan->symbol_table().max_position(), kNumberOfFramesInMultiframe, execution_memory),
       memory_limit_(memory_limit) {
   ctx_.db_accessor = dba;
   ctx_.symbol_table = plan->symbol_table();
@@ -709,6 +728,7 @@ PullPlan::PullPlan(const std::shared_ptr<CachedPlan> plan, const Parameters &par
   ctx_.request_router = request_router;
   ctx_.edge_ids_alloc = &interpreter_context->edge_ids_alloc;
 }
+
 std::optional<plan::ProfilingStatsWithTotalTime> PullPlan::PullMultiple(AnyStream *stream, std::optional<int> n,
                                                                         const std::vector<Symbol> &output_symbols,
                                                                         std::map<std::string, TypedValue> *summary) {
@@ -736,7 +756,10 @@ std::optional<plan::ProfilingStatsWithTotalTime> PullPlan::PullMultiple(AnyStrea
   }
 
   // Returns true if a result was pulled.
-  const auto pull_result = [&]() -> bool { return cursor_->PullMultiple(multi_frame_, ctx_); };
+  const auto pull_result = [&]() -> bool {
+    cursor_->PullMultiple(multi_frame_, ctx_);
+    return !multi_frame_.HasInvalidFrame();
+  };
 
   const auto stream_values = [&output_symbols, &stream](const Frame &frame) {
     // TODO: The streamed values should also probably use the above memory.
@@ -756,14 +779,13 @@ std::optional<plan::ProfilingStatsWithTotalTime> PullPlan::PullMultiple(AnyStrea
   int i = 0;
   if (has_unsent_results_ && !output_symbols.empty()) {
     // stream unsent results from previous pull
-    for (auto &frame : multi_frame_.GetValidFramesConsumer()) {
+
+    auto iterator_for_valid_frame_only = multi_frame_.GetValidFramesReader();
+    for (const auto &frame : iterator_for_valid_frame_only) {
       stream_values(frame);
-      frame.MakeInvalid();
       ++i;
-      if (i == n) {
-        break;
-      }
     }
+    multi_frame_.MakeAllFramesInvalid();
   }
 
   for (; !n || i < n;) {
@@ -772,17 +794,13 @@ std::optional<plan::ProfilingStatsWithTotalTime> PullPlan::PullMultiple(AnyStrea
     }
 
     if (!output_symbols.empty()) {
-      for (auto &frame : multi_frame_.GetValidFramesConsumer()) {
+      auto iterator_for_valid_frame_only = multi_frame_.GetValidFramesReader();
+      for (const auto &frame : iterator_for_valid_frame_only) {
         stream_values(frame);
-        frame.MakeInvalid();
         ++i;
-        if (i == n) {
-          break;
-        }
       }
-    } else {
-      multi_frame_.MakeAllFramesInvalid();
     }
+    multi_frame_.MakeAllFramesInvalid();
   }
 
   // If we finished because we streamed the requested n results,
@@ -817,7 +835,8 @@ std::optional<plan::ProfilingStatsWithTotalTime> PullPlan::PullMultiple(AnyStrea
 std::optional<plan::ProfilingStatsWithTotalTime> PullPlan::Pull(AnyStream *stream, std::optional<int> n,
                                                                 const std::vector<Symbol> &output_symbols,
                                                                 std::map<std::string, TypedValue> *summary) {
-  if (FLAGS_use_multi_frame) {
+  auto should_pull_multiple = false;  // TODO on the long term, we will only use PullMultiple
+  if (should_pull_multiple) {
     return PullMultiple(stream, n, output_symbols, summary);
   }
   // Set up temporary memory for a single Pull. Initial memory comes from the
@@ -911,24 +930,34 @@ using RWType = plan::ReadWriteTypeChecker::RWType;
 
 InterpreterContext::InterpreterContext(storage::v3::Shard *db, const InterpreterConfig config,
                                        const std::filesystem::path & /*data_directory*/,
-                                       std::unique_ptr<RequestRouterFactory> request_router_factory,
+                                       io::Io<io::local_transport::LocalTransport> io,
                                        coordinator::Address coordinator_addr)
-    : db(db),
-      config(config),
-      coordinator_address{coordinator_addr},
-      request_router_factory_{std::move(request_router_factory)} {}
+    : db(db), config(config), io{std::move(io)}, coordinator_address{coordinator_addr} {}
 
 Interpreter::Interpreter(InterpreterContext *interpreter_context) : interpreter_context_(interpreter_context) {
   MG_ASSERT(interpreter_context_, "Interpreter context must not be NULL");
 
-  request_router_ =
-      interpreter_context_->request_router_factory_->CreateRequestRouter(interpreter_context_->coordinator_address);
+  // TODO(tyler) make this deterministic so that it can be tested.
+  auto random_uuid = boost::uuids::uuid{boost::uuids::random_generator()()};
+  auto query_io = interpreter_context_->io.ForkLocal(random_uuid);
 
+  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));
   // Get edge ids
-  const auto edge_ids_alloc_min_max_pair =
-      request_router_->AllocateInitialEdgeIds(interpreter_context_->coordinator_address);
-  if (edge_ids_alloc_min_max_pair) {
-    interpreter_context_->edge_ids_alloc = {edge_ids_alloc_min_max_pair->first, edge_ids_alloc_min_max_pair->second};
+  coordinator::CoordinatorWriteRequests requests{coordinator::AllocateEdgeIdBatchRequest{.batch_size = 1000000}};
+  io::rsm::WriteRequest<coordinator::CoordinatorWriteRequests> ww;
+  ww.operation = requests;
+  auto resp = interpreter_context_->io
+                  .Request<io::rsm::WriteRequest<coordinator::CoordinatorWriteRequests>,
+                           io::rsm::WriteResponse<coordinator::CoordinatorWriteResponses>>(
+                      interpreter_context_->coordinator_address, ww)
+                  .Wait();
+  if (resp.HasValue()) {
+    const auto alloc_edge_id_reps =
+        std::get<coordinator::AllocateEdgeIdBatchResponse>(resp.GetValue().message.write_return);
+    interpreter_context_->edge_ids_alloc = {alloc_edge_id_reps.low, alloc_edge_id_reps.high};
   }
 }
 

src/query/v2/interpreter.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -16,6 +16,7 @@
 
 #include "coordinator/coordinator.hpp"
 #include "coordinator/coordinator_client.hpp"
+#include "io/local_transport/local_transport.hpp"
 #include "io/transport.hpp"
 #include "query/v2/auth_checker.hpp"
 #include "query/v2/bindings/cypher_main_visitor.hpp"
@@ -171,8 +172,7 @@ struct PreparedQuery {
 struct InterpreterContext {
   explicit InterpreterContext(storage::v3::Shard *db, InterpreterConfig config,
                               const std::filesystem::path &data_directory,
-                              std::unique_ptr<RequestRouterFactory> request_router_factory,
-                              coordinator::Address coordinator_addr);
+                              io::Io<io::local_transport::LocalTransport> io, coordinator::Address coordinator_addr);
 
   storage::v3::Shard *db;
 
@@ -188,24 +188,26 @@ struct InterpreterContext {
   const InterpreterConfig config;
   IdAllocator edge_ids_alloc;
 
+  // TODO (antaljanosbenjamin) Figure out an abstraction for io::Io to make it possible to construct an interpreter
+  // context with a simulator transport without templatizing it.
+  io::Io<io::local_transport::LocalTransport> io;
   coordinator::Address coordinator_address;
-  std::unique_ptr<RequestRouterFactory> request_router_factory_;
 
   storage::v3::LabelId NameToLabelId(std::string_view label_name) {
-    return storage::v3::LabelId::FromUint(query_id_mapper_.NameToId(label_name));
+    return storage::v3::LabelId::FromUint(query_id_mapper.NameToId(label_name));
   }
 
   storage::v3::PropertyId NameToPropertyId(std::string_view property_name) {
-    return storage::v3::PropertyId::FromUint(query_id_mapper_.NameToId(property_name));
+    return storage::v3::PropertyId::FromUint(query_id_mapper.NameToId(property_name));
   }
 
   storage::v3::EdgeTypeId NameToEdgeTypeId(std::string_view edge_type_name) {
-    return storage::v3::EdgeTypeId::FromUint(query_id_mapper_.NameToId(edge_type_name));
+    return storage::v3::EdgeTypeId::FromUint(query_id_mapper.NameToId(edge_type_name));
   }
 
  private:
   // TODO Replace with local map of labels, properties and edge type ids
-  storage::v3::NameIdMapper query_id_mapper_;
+  storage::v3::NameIdMapper query_id_mapper;
 };
 
 /// Function that is used to tell all active interpreters that they should stop
@@ -295,15 +297,12 @@ class Interpreter final {
   void Abort();
 
   const RequestRouterInterface *GetRequestRouter() const { return request_router_.get(); }
-  void InstallSimulatorTicker(std::function<bool()> &&tick_simulator) {
-    request_router_->InstallSimulatorTicker(tick_simulator);
-  }
 
  private:
   struct QueryExecution {
+    std::optional<PreparedQuery> prepared_query;
     utils::MonotonicBufferResource execution_memory{kExecutionMemoryBlockSize};
     utils::ResourceWithOutOfMemoryException execution_memory_with_exception{&execution_memory};
-    std::optional<PreparedQuery> prepared_query;
 
     std::map<std::string, TypedValue> summary;
     std::vector<Notification> notifications;

src/query/v2/multiframe.cpp

@@ -17,9 +17,6 @@
 #include "query/v2/bindings/frame.hpp"
 #include "utils/pmr/vector.hpp"
 
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_uint64(default_multi_frame_size, 100, "Default size of MultiFrame");
-
 namespace memgraph::query::v2 {
 
 static_assert(std::forward_iterator<ValidFramesReader::Iterator>);
@@ -57,17 +54,15 @@ bool MultiFrame::HasInvalidFrame() const noexcept {
 
 // NOLINTNEXTLINE (bugprone-exception-escape)
 void MultiFrame::DefragmentValidFrames() noexcept {
-  static constexpr auto kIsValid = [](const FrameWithValidity &frame) { return frame.IsValid(); };
-  static constexpr auto kIsInvalid = [](const FrameWithValidity &frame) { return !frame.IsValid(); };
-  auto first_invalid_frame = std::find_if(frames_.begin(), frames_.end(), kIsInvalid);
-  auto following_first_valid = std::find_if(first_invalid_frame, frames_.end(), kIsValid);
-  while (first_invalid_frame != frames_.end() && following_first_valid != frames_.end()) {
-    std::swap(*first_invalid_frame, *following_first_valid);
-    first_invalid_frame++;
-    first_invalid_frame = std::find_if(first_invalid_frame, frames_.end(), kIsInvalid);
-    following_first_valid++;
-    following_first_valid = std::find_if(following_first_valid, frames_.end(), kIsValid);
-  }
+  /*
+  from: https://en.cppreference.com/w/cpp/algorithm/remove
+  "Removing is done by shifting (by means of copy assignment (until C++11)move assignment (since C++11)) the elements
+  in the range in such a way that the elements that are not to be removed appear in the beginning of the range.
+  Relative order of the elements that remain is preserved and the physical size of the container is unchanged."
+  */
+
+  // NOLINTNEXTLINE (bugprone-unused-return-value)
+  std::remove_if(frames_.begin(), frames_.end(), [](auto &frame) { return !frame.IsValid(); });
 }
 
 ValidFramesReader MultiFrame::GetValidFramesReader() { return ValidFramesReader{*this}; }

src/query/v2/multiframe.hpp

@@ -13,14 +13,10 @@
 
 #include <iterator>
 
-#include <gflags/gflags.h>
-
 #include "query/v2/bindings/frame.hpp"
 
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint64(default_multi_frame_size);
-
 namespace memgraph::query::v2 {
+constexpr uint64_t kNumberOfFramesInMultiframe = 1000;  // TODO have it configurable
 
 class ValidFramesConsumer;
 class ValidFramesModifier;
@@ -37,7 +33,6 @@ class MultiFrame {
   MultiFrame(size_t size_of_frame, size_t number_of_frames, utils::MemoryResource *execution_memory);
   ~MultiFrame() = default;
 
-  // Assigning and moving the MultiFrame is not allowed if any accessor from the above ones are alive.
   MultiFrame(const MultiFrame &other);
   MultiFrame(MultiFrame &&other) noexcept;
   MultiFrame &operator=(const MultiFrame &other) = delete;
@@ -102,9 +97,9 @@ class ValidFramesReader {
 
   ~ValidFramesReader() = default;
   ValidFramesReader(const ValidFramesReader &other) = delete;
-  ValidFramesReader(ValidFramesReader &&other) noexcept = default;
+  ValidFramesReader(ValidFramesReader &&other) noexcept = delete;
   ValidFramesReader &operator=(const ValidFramesReader &other) = delete;
-  ValidFramesReader &operator=(ValidFramesReader &&other) noexcept = default;
+  ValidFramesReader &operator=(ValidFramesReader &&other) noexcept = delete;
 
   struct Iterator {
     using iterator_category = std::forward_iterator_tag;
@@ -152,9 +147,9 @@ class ValidFramesModifier {
 
   ~ValidFramesModifier() = default;
   ValidFramesModifier(const ValidFramesModifier &other) = delete;
-  ValidFramesModifier(ValidFramesModifier &&other) noexcept = default;
+  ValidFramesModifier(ValidFramesModifier &&other) noexcept = delete;
   ValidFramesModifier &operator=(const ValidFramesModifier &other) = delete;
-  ValidFramesModifier &operator=(ValidFramesModifier &&other) noexcept = default;
+  ValidFramesModifier &operator=(ValidFramesModifier &&other) noexcept = delete;
 
   struct Iterator {
     using iterator_category = std::forward_iterator_tag;
@@ -207,9 +202,9 @@ class ValidFramesConsumer {
 
   ~ValidFramesConsumer() noexcept;
   ValidFramesConsumer(const ValidFramesConsumer &other) = delete;
-  ValidFramesConsumer(ValidFramesConsumer &&other) noexcept = default;
+  ValidFramesConsumer(ValidFramesConsumer &&other) noexcept = delete;
   ValidFramesConsumer &operator=(const ValidFramesConsumer &other) = delete;
-  ValidFramesConsumer &operator=(ValidFramesConsumer &&other) noexcept = default;
+  ValidFramesConsumer &operator=(ValidFramesConsumer &&other) noexcept = delete;
 
   struct Iterator {
     using iterator_category = std::forward_iterator_tag;
@@ -261,9 +256,9 @@ class InvalidFramesPopulator {
   ~InvalidFramesPopulator() = default;
 
   InvalidFramesPopulator(const InvalidFramesPopulator &other) = delete;
-  InvalidFramesPopulator(InvalidFramesPopulator &&other) noexcept = default;
+  InvalidFramesPopulator(InvalidFramesPopulator &&other) noexcept = delete;
   InvalidFramesPopulator &operator=(const InvalidFramesPopulator &other) = delete;
-  InvalidFramesPopulator &operator=(InvalidFramesPopulator &&other) noexcept = default;
+  InvalidFramesPopulator &operator=(InvalidFramesPopulator &&other) noexcept = delete;
 
   struct Iterator {
     using iterator_category = std::forward_iterator_tag;

src/query/v2/plan/cost_estimator.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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

src/query/v2/plan/operator.lcp

@@ -72,23 +72,7 @@ class Cursor {
   /// @throws QueryRuntimeException if something went wrong with execution
   virtual bool Pull(Frame &, ExecutionContext &) = 0;
 
-  /// Run an iteration of a @c LogicalOperator with MultiFrame.
-  ///
-  /// Since operators may be chained, the iteration may pull results from
-  /// multiple operators.
-  ///
-  /// @param MultiFrame May be read from or written to while performing the
-  ///     iteration.
-  /// @param ExecutionContext Used to get the position of symbols in frame and
-  ///     other information.
-  /// @return True if the operator was able to populate at least one Frame on the MultiFrame,
-  ///     thus if an operator returns true, that means there is at least one valid Frame in the
-  ///     MultiFrame.
-  ///
-  /// @throws QueryRuntimeException if something went wrong with execution
-  virtual bool PullMultiple(MultiFrame &, ExecutionContext &) {MG_ASSERT(false, "PullMultipleIsNotImplemented"); return false; }
-
-  virtual void PushDown(const MultiFrame&) { MG_ASSERT(false, "PushDownIsNotImplemented"); }
+  virtual void PullMultiple(MultiFrame &, ExecutionContext &) { LOG_FATAL("PullMultipleIsNotImplemented"); }
 
   /// Resets the Cursor to its initial state.
   virtual void Reset() = 0;
@@ -351,14 +335,12 @@ and false on every following Pull.")
    class OnceCursor : public Cursor {
     public:
      OnceCursor() {}
-     bool PullMultiple(MultiFrame &, ExecutionContext &) override;
-     void PushDown(const MultiFrame&) override;
+     void PullMultiple(MultiFrame &, ExecutionContext &) override;
      bool Pull(Frame &, ExecutionContext &) override;
      void Shutdown() override;
      void Reset() override;
 
     private:
-     std::optional<MultiFrame> pushed_down_multi_frame_;
      bool did_pull_{false};
    };
    cpp<#)
@@ -1180,7 +1162,6 @@ a boolean value.")
     public:
      FilterCursor(const Filter &, utils::MemoryResource *);
      bool Pull(Frame &, ExecutionContext &) override;
-     bool PullMultiple(MultiFrame &, ExecutionContext &) override;
      void Shutdown() override;
      void Reset() override;
 
@@ -1232,7 +1213,7 @@ RETURN clause) the Produce's pull succeeds exactly once.")
     public:
      ProduceCursor(const Produce &, utils::MemoryResource *);
      bool Pull(Frame &, ExecutionContext &) override;
-     bool PullMultiple(MultiFrame &, ExecutionContext &) override;
+     void PullMultiple(MultiFrame &, ExecutionContext &) override;
      void Shutdown() override;
      void Reset() override;
 
@@ -1280,7 +1261,6 @@ Has a flag for using DETACH DELETE when deleting vertices.")
     public:
      DeleteCursor(const Delete &, utils::MemoryResource *);
      bool Pull(Frame &, ExecutionContext &) override;
-     bool PullMultiple(MultiFrame &, ExecutionContext &) override;
      void Shutdown() override;
      void Reset() override;
 
@@ -1574,7 +1554,6 @@ edge lists).")
      EdgeUniquenessFilterCursor(const EdgeUniquenessFilter &,
                                 utils::MemoryResource *);
      bool Pull(Frame &, ExecutionContext &) override;
-     bool PullMultiple(MultiFrame &, ExecutionContext &) override;
      void Shutdown() override;
      void Reset() override;
 
@@ -1971,6 +1950,27 @@ and returns true, once.")
      input_ = input;
    }
    cpp<#)
+  (:private
+   #>cpp
+   class OptionalCursor : public Cursor {
+    public:
+     OptionalCursor(const Optional &, utils::MemoryResource *);
+     bool Pull(Frame &, ExecutionContext &) override;
+     void Shutdown() override;
+     void Reset() override;
+
+    private:
+     const Optional &self_;
+     const UniqueCursorPtr input_cursor_;
+     const UniqueCursorPtr optional_cursor_;
+     // indicates if the next Pull from this cursor should
+     // perform a Pull from the input_cursor_
+     // this is true when:
+     //  - first pulling from this Cursor
+     //  - previous Pull from this cursor exhausted the optional_cursor_
+     bool pull_input_{true};
+   };
+   cpp<#)
   (:serialize (:slk))
   (:clone))
 

src/query/v2/plan/rewrite/index_lookup.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -13,8 +13,7 @@
 
 #include "utils/flag_validation.hpp"
 
-// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_VALIDATED_HIDDEN_int64(query_v2_vertex_count_to_expand_existing, 10,
+DEFINE_VALIDATED_HIDDEN_int64(query_vertex_count_to_expand_existing, 10,
                               "Maximum count of indexed vertices which provoke "
                               "indexed lookup and then expand to existing, instead of "
                               "a regular expand. Default is 10, to turn off use -1.",

src/query/v2/plan/rewrite/index_lookup.hpp

@@ -30,8 +30,7 @@
 #include "query/v2/plan/preprocess.hpp"
 #include "storage/v3/id_types.hpp"
 
-// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_int64(query_v2_vertex_count_to_expand_existing);
+DECLARE_int64(query_vertex_count_to_expand_existing);
 
 namespace memgraph::query::v2::plan {
 
@@ -101,7 +100,7 @@ class IndexLookupRewriter final : public HierarchicalLogicalOperatorVisitor {
       return true;
     }
     ScanAll dst_scan(expand.input(), expand.common_.node_symbol, expand.view_);
-    auto indexed_scan = GenScanByIndex(dst_scan, FLAGS_query_v2_vertex_count_to_expand_existing);
+    auto indexed_scan = GenScanByIndex(dst_scan, FLAGS_query_vertex_count_to_expand_existing);
     if (indexed_scan) {
       expand.set_input(std::move(indexed_scan));
       expand.common_.existing_node = true;
@@ -130,7 +129,7 @@ class IndexLookupRewriter final : public HierarchicalLogicalOperatorVisitor {
       // unconditionally creating an indexed scan.
       indexed_scan = GenScanByIndex(dst_scan);
     } else {
-      indexed_scan = GenScanByIndex(dst_scan, FLAGS_query_v2_vertex_count_to_expand_existing);
+      indexed_scan = GenScanByIndex(dst_scan, FLAGS_query_vertex_count_to_expand_existing);
     }
     if (indexed_scan) {
       expand.set_input(std::move(indexed_scan));
@@ -598,9 +597,6 @@ class IndexLookupRewriter final : public HierarchicalLogicalOperatorVisitor {
                      [](const auto &schema_elem) { return schema_elem.property_id; });
 
       for (const auto &property_filter : property_filters) {
-        if (property_filter.property_filter->type_ != PropertyFilter::Type::EQUAL) {
-          continue;
-        }
         const auto &property_id = db_->NameToProperty(property_filter.property_filter->property_.name);
         if (std::find(schema_properties.begin(), schema_properties.end(), property_id) != schema_properties.end()) {
           pk_temp.emplace_back(std::make_pair(property_filter.expression, property_filter));

src/query/v2/plan/variable_start_planner.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -17,8 +17,7 @@
 #include "utils/flag_validation.hpp"
 #include "utils/logging.hpp"
 
-// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_VALIDATED_HIDDEN_uint64(query_v2_max_plans, 1000U, "Maximum number of generated plans for a query.",
+DEFINE_VALIDATED_HIDDEN_uint64(query_max_plans, 1000U, "Maximum number of generated plans for a query.",
                                FLAG_IN_RANGE(1, std::numeric_limits<std::uint64_t>::max()));
 
 namespace memgraph::query::v2::plan::impl {

src/query/v2/plan/variable_start_planner.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -18,8 +18,7 @@
 
 #include "query/v2/plan/rule_based_planner.hpp"
 
-// NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
-DECLARE_uint64(query_v2_max_plans);
+DECLARE_uint64(query_max_plans);
 
 namespace memgraph::query::v2::plan {
 
@@ -311,7 +310,7 @@ class VariableStartPlanner {
     for (const auto &query_part : query_parts) {
       alternative_query_parts.emplace_back(impl::VaryQueryPartMatching(query_part, symbol_table));
     }
-    return iter::slice(MakeCartesianProduct(std::move(alternative_query_parts)), 0UL, FLAGS_query_v2_max_plans);
+    return iter::slice(MakeCartesianProduct(std::move(alternative_query_parts)), 0UL, FLAGS_query_max_plans);
   }
 
  public:

src/query/v2/request_router.hpp

@@ -24,18 +24,14 @@
 #include <stdexcept>
 #include <thread>
 #include <unordered_map>
-#include <variant>
 #include <vector>
 
-#include <boost/uuid/uuid.hpp>
-
 #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/local_transport/local_transport.hpp"
 #include "io/notifier.hpp"
 #include "io/rsm/raft.hpp"
 #include "io/rsm/rsm_client.hpp"
@@ -117,10 +113,7 @@ class RequestRouterInterface {
   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 IsPrimaryProperty(storage::v3::LabelId primary_label, storage::v3::PropertyId property) const = 0;
-
-  virtual std::optional<std::pair<uint64_t, uint64_t>> AllocateInitialEdgeIds(io::Address coordinator_address) = 0;
-  virtual void InstallSimulatorTicker(std::function<bool()> tick_simulator) = 0;
+  virtual bool IsPrimaryKey(storage::v3::LabelId primary_label, storage::v3::PropertyId property) const = 0;
   virtual const std::vector<coordinator::SchemaProperty> &GetSchemaForLabel(storage::v3::LabelId label) const = 0;
 };
 
@@ -146,7 +139,7 @@ class RequestRouter : public RequestRouterInterface {
 
   ~RequestRouter() override {}
 
-  void InstallSimulatorTicker(std::function<bool()> tick_simulator) override {
+  void InstallSimulatorTicker(std::function<bool()> tick_simulator) {
     notifier_.InstallSimulatorTicker(tick_simulator);
   }
 
@@ -231,7 +224,7 @@ class RequestRouter : public RequestRouterInterface {
     return edge_types_.IdToName(id.AsUint());
   }
 
-  bool IsPrimaryProperty(storage::v3::LabelId primary_label, storage::v3::PropertyId property) const override {
+  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());
 
@@ -323,8 +316,8 @@ class RequestRouter : public RequestRouterInterface {
       io::ReadinessToken readiness_token{i};
       auto &storage_client = GetStorageClientForShard(request.shard);
       msgs::WriteRequests req = request.request;
-      storage_client.SendAsyncWriteRequest(std::move(req), notifier_, readiness_token);
-      running_requests.emplace(readiness_token.GetId(), std::move(request));
+      storage_client.SendAsyncWriteRequest(req, notifier_, readiness_token);
+      running_requests.emplace(readiness_token.GetId(), request);
     }
 
     // drive requests to completion
@@ -339,8 +332,7 @@ class RequestRouter : public RequestRouterInterface {
     // must be fetched again with an ExpandOne(Edges.dst)
 
     // create requests
-    std::vector<ShardRequestState<msgs::ExpandOneRequest>> requests_to_be_sent =
-        RequestsForExpandOne(std::move(request));
+    std::vector<ShardRequestState<msgs::ExpandOneRequest>> requests_to_be_sent = RequestsForExpandOne(request);
 
     // begin all requests in parallel
     RunningRequests<msgs::ExpandOneRequest> running_requests = {};
@@ -350,8 +342,8 @@ class RequestRouter : public RequestRouterInterface {
       io::ReadinessToken readiness_token{i};
       auto &storage_client = GetStorageClientForShard(request.shard);
       msgs::ReadRequests req = request.request;
-      storage_client.SendAsyncReadRequest(std::move(req), notifier_, readiness_token);
-      running_requests.emplace(readiness_token.GetId(), std::move(request));
+      storage_client.SendAsyncReadRequest(req, notifier_, readiness_token);
+      running_requests.emplace(readiness_token.GetId(), request);
     }
 
     // drive requests to completion
@@ -387,8 +379,8 @@ class RequestRouter : public RequestRouterInterface {
       io::ReadinessToken readiness_token{i};
       auto &storage_client = GetStorageClientForShard(request.shard);
       msgs::ReadRequests req = request.request;
-      storage_client.SendAsyncReadRequest(std::move(req), notifier_, readiness_token);
-      running_requests.emplace(readiness_token.GetId(), std::move(request));
+      storage_client.SendAsyncReadRequest(req, notifier_, readiness_token);
+      running_requests.emplace(readiness_token.GetId(), request);
     }
 
     // drive requests to completion
@@ -504,7 +496,6 @@ class RequestRouter : public RequestRouterInterface {
 
         msgs::ScanVerticesRequest request;
         request.transaction_id = transaction_id_;
-        request.props_to_return.emplace();
         request.start_id.second = storage::conversions::ConvertValueVector(key);
 
         ShardRequestState<msgs::ScanVerticesRequest> shard_request_state{
@@ -519,7 +510,7 @@ class RequestRouter : public RequestRouterInterface {
     return requests;
   }
 
-  std::vector<ShardRequestState<msgs::ExpandOneRequest>> RequestsForExpandOne(msgs::ExpandOneRequest &&request) {
+  std::vector<ShardRequestState<msgs::ExpandOneRequest>> RequestsForExpandOne(const msgs::ExpandOneRequest &request) {
     std::map<ShardMetadata, msgs::ExpandOneRequest> per_shard_request_table;
     msgs::ExpandOneRequest top_level_rqst_template = request;
     top_level_rqst_template.transaction_id = transaction_id_;
@@ -531,7 +522,7 @@ class RequestRouter : public RequestRouterInterface {
       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(std::move(vertex));
+      per_shard_request_table[shard].src_vertices.push_back(vertex);
     }
 
     std::vector<ShardRequestState<msgs::ExpandOneRequest>> requests = {};
@@ -724,23 +715,6 @@ class RequestRouter : public RequestRouterInterface {
     edge_types_.StoreMapping(std::move(id_to_name));
   }
 
-  std::optional<std::pair<uint64_t, uint64_t>> AllocateInitialEdgeIds(io::Address coordinator_address) override {
-    coordinator::CoordinatorWriteRequests requests{coordinator::AllocateEdgeIdBatchRequest{.batch_size = 1000000}};
-
-    io::rsm::WriteRequest<coordinator::CoordinatorWriteRequests> ww;
-    ww.operation = std::move(requests);
-    auto resp = io_.template Request<io::rsm::WriteResponse<coordinator::CoordinatorWriteResponses>,
-                                     io::rsm::WriteRequest<coordinator::CoordinatorWriteRequests>>(coordinator_address,
-                                                                                                   std::move(ww))
-                    .Wait();
-    if (resp.HasValue()) {
-      const auto alloc_edge_id_reps =
-          std::get<coordinator::AllocateEdgeIdBatchResponse>(resp.GetValue().message.write_return);
-      return std::make_pair(alloc_edge_id_reps.low, alloc_edge_id_reps.high);
-    }
-    return {};
-  }
-
   ShardMap shards_map_;
   storage::v3::NameIdMapper properties_;
   storage::v3::NameIdMapper edge_types_;
@@ -752,66 +726,4 @@ class RequestRouter : public RequestRouterInterface {
   io::Notifier notifier_ = {};
   // TODO(kostasrim) Add batch prefetching
 };
-
-class RequestRouterFactory {
- public:
-  RequestRouterFactory() = default;
-  RequestRouterFactory(const RequestRouterFactory &) = delete;
-  RequestRouterFactory &operator=(const RequestRouterFactory &) = delete;
-  RequestRouterFactory(RequestRouterFactory &&) = delete;
-  RequestRouterFactory &operator=(RequestRouterFactory &&) = delete;
-
-  virtual ~RequestRouterFactory() = default;
-
-  virtual std::unique_ptr<RequestRouterInterface> CreateRequestRouter(
-      const coordinator::Address &coordinator_address) const = 0;
-};
-
-class LocalRequestRouterFactory : public RequestRouterFactory {
-  using LocalTransportIo = io::Io<io::local_transport::LocalTransport>;
-  LocalTransportIo &io_;
-
- public:
-  explicit LocalRequestRouterFactory(LocalTransportIo &io) : io_(io) {}
-
-  std::unique_ptr<RequestRouterInterface> CreateRequestRouter(
-      const coordinator::Address &coordinator_address) const override {
-    using TransportType = io::local_transport::LocalTransport;
-
-    auto query_io = io_.ForkLocal(boost::uuids::uuid{boost::uuids::random_generator()()});
-    auto local_transport_io = io_.ForkLocal(boost::uuids::uuid{boost::uuids::random_generator()()});
-
-    return std::make_unique<RequestRouter<TransportType>>(
-        coordinator::CoordinatorClient<TransportType>(query_io, coordinator_address, {coordinator_address}),
-        std::move(local_transport_io));
-  }
-};
-
-class SimulatedRequestRouterFactory : public RequestRouterFactory {
-  io::simulator::Simulator *simulator_;
-
- public:
-  explicit SimulatedRequestRouterFactory(io::simulator::Simulator &simulator) : simulator_(&simulator) {}
-
-  std::unique_ptr<RequestRouterInterface> CreateRequestRouter(
-      const coordinator::Address &coordinator_address) const override {
-    using TransportType = io::simulator::SimulatorTransport;
-    auto actual_transport_handle = simulator_->GetSimulatorHandle();
-
-    boost::uuids::uuid random_uuid;
-    io::Address unique_local_addr_query;
-
-    // The simulated RR should not introduce stochastic behavior.
-    random_uuid = boost::uuids::uuid{3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-    unique_local_addr_query = {.unique_id = boost::uuids::uuid{4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
-
-    auto io = simulator_->Register(unique_local_addr_query);
-    auto query_io = io.ForkLocal(random_uuid);
-
-    return std::make_unique<RequestRouter<TransportType>>(
-        coordinator::CoordinatorClient<TransportType>(query_io, coordinator_address, {coordinator_address}),
-        std::move(io));
-  }
-};
-
 }  // namespace memgraph::query::v2

src/query/v2/requests.hpp

@@ -26,7 +26,6 @@
 #include "storage/v3/id_types.hpp"
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/result.hpp"
-#include "utils/fnv.hpp"
 
 namespace memgraph::msgs {
 
@@ -591,48 +590,3 @@ using WriteResponses = std::variant<CreateVerticesResponse, DeleteVerticesRespon
                                     CreateExpandResponse, DeleteEdgesResponse, UpdateEdgesResponse, CommitResponse>;
 
 }  // namespace memgraph::msgs
-
-namespace std {
-
-template <>
-struct hash<memgraph::msgs::Value>;
-
-template <>
-struct hash<memgraph::msgs::VertexId> {
-  size_t operator()(const memgraph::msgs::VertexId &id) const {
-    using LabelId = memgraph::storage::v3::LabelId;
-    using Value = memgraph::msgs::Value;
-    return memgraph::utils::HashCombine<LabelId, std::vector<Value>, std::hash<LabelId>,
-                                        memgraph::utils::FnvCollection<std::vector<Value>, Value>>{}(id.first.id,
-                                                                                                     id.second);
-  }
-};
-
-template <>
-struct hash<memgraph::msgs::Value> {
-  size_t operator()(const memgraph::msgs::Value &value) const {
-    using Type = memgraph::msgs::Value::Type;
-    switch (value.type) {
-      case Type::Null:
-        return std::hash<size_t>{}(0U);
-      case Type::Bool:
-        return std::hash<bool>{}(value.bool_v);
-      case Type::Int64:
-        return std::hash<int64_t>{}(value.int_v);
-      case Type::Double:
-        return std::hash<double>{}(value.double_v);
-      case Type::String:
-        return std::hash<std::string>{}(value.string_v);
-      case Type::List:
-        LOG_FATAL("Add hash for lists");
-      case Type::Map:
-        LOG_FATAL("Add hash for maps");
-      case Type::Vertex:
-        LOG_FATAL("Add hash for vertices");
-      case Type::Edge:
-        LOG_FATAL("Add hash for edges");
-    }
-  }
-};
-
-}  // namespace std

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

@@ -146,6 +146,14 @@ cpp<#
     }
     cpp<#)
 
+(defun clone-map (source dest)
+    #>cpp
+    ${dest}.reserve(${source}.size());
+    for (const auto &[config_key, config_val]: ${source}) {
+      ${dest}.emplace(config_key, config_val);
+    }
+    cpp<#)
+
 ;; The following index structs serve as a decoupling point of AST from
 ;; concrete database types. All the names are collected in AstStorage, and can
 ;; be indexed through these instances. This means that we can create a vector
@@ -2705,10 +2713,15 @@ cpp<#
                    #>cpp
                    ${dest} = storage->GetLabelIx(${source}.name);
                    cpp<#))
+
     (schema_type_map "std::vector<std::pair<PropertyIx, common::SchemaType>>"
       :slk-save #'slk-save-property-map
       :slk-load #'slk-load-property-map
       :clone #'clone-schema-property-vector
+      :scope :public)
+
+   (schema_config_map "std::unordered_map<common::SchemaConfigParams, int64_t>"
+      :clone #'clone-map
       :scope :public))
 
   (:public

src/storage/v3/delta.hpp

@@ -29,7 +29,7 @@ struct Edge;
 struct Delta;
 struct CommitInfo;
 
-inline uint64_t GetNextDeltaId() {
+inline uint64_t GetNextDeltaId() noexcept {
   static utils::Synchronized<uint64_t, utils::SpinLock> delta_id{0};
   return delta_id.WithLock([](auto &id) { return id++; });
 }

src/storage/v3/expr.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -35,7 +35,7 @@ msgs::Value ConstructValueVertex(const VertexAccessor &acc, View view) {
   memgraph::msgs::Label value_label{.id = prim_label};
 
   auto prim_key = conversions::ConvertValueVector(acc.PrimaryKey(view).GetValue());
-  memgraph::msgs::VertexId vertex_id = std::make_pair(value_label, std::move(prim_key));
+  memgraph::msgs::VertexId vertex_id = std::make_pair(value_label, prim_key);
 
   // Get the labels
   auto vertex_labels = acc.Labels(view).GetValue();
@@ -45,7 +45,7 @@ msgs::Value ConstructValueVertex(const VertexAccessor &acc, View view) {
   std::transform(vertex_labels.begin(), vertex_labels.end(), std::back_inserter(value_labels),
                  [](const auto &label) { return msgs::Label{.id = label}; });
 
-  return msgs::Value({.id = std::move(vertex_id), .labels = std::move(value_labels)});
+  return msgs::Value({.id = vertex_id, .labels = value_labels});
 }
 
 msgs::Value ConstructValueEdge(const EdgeAccessor &acc, View view) {

src/storage/v3/indices.hpp

@@ -123,12 +123,18 @@ class LabelIndex {
   void Clear() { index_.clear(); }
 
   std::map<IndexType, IndexContainer> SplitIndexEntries(const PrimaryKey &split_key) {
+    if (index_.empty()) {
+      return {};
+    }
+
+    // Cloned index entries will contain new index entry iterators, but old
+    // vertices address which need to be adjusted after extracting vertices
     std::map<IndexType, IndexContainer> cloned_indices;
     for (auto &[index_type_val, index] : index_) {
       auto entry_it = index.begin();
       auto &cloned_indices_container = cloned_indices[index_type_val];
       while (entry_it != index.end()) {
-        // We need to save the next iterator since the current one will be
+        // We need to save the next pointer since the current one will be
         // invalidated after extract
         auto next_entry_it = std::next(entry_it);
         if (entry_it->vertex->first > split_key) {
@@ -260,12 +266,18 @@ class LabelPropertyIndex {
   void Clear() { index_.clear(); }
 
   std::map<IndexType, IndexContainer> SplitIndexEntries(const PrimaryKey &split_key) {
+    if (index_.empty()) {
+      return {};
+    }
+
+    // Cloned index entries will contain new index entry iterators, but old
+    // vertices address which need to be adjusted after extracting vertices
     std::map<IndexType, IndexContainer> cloned_indices;
     for (auto &[index_type_val, index] : index_) {
       auto entry_it = index.begin();
       auto &cloned_index_container = cloned_indices[index_type_val];
       while (entry_it != index.end()) {
-        // We need to save the next iterator since the current one will be
+        // We need to save the next pointer since the current one will be
         // invalidated after extract
         auto next_entry_it = std::next(entry_it);
         if (entry_it->vertex->first > split_key) {

src/storage/v3/request_helper.cpp

@@ -44,20 +44,21 @@ struct VertexIdCmpr {
 };
 
 std::optional<std::map<PropertyId, Value>> PrimaryKeysFromAccessor(const VertexAccessor &acc, View view,
-                                                                   const Schemas::Schema &schema) {
+                                                                   const Schema &schema) {
   std::map<PropertyId, Value> ret;
+  auto props = acc.Properties(view);
   auto maybe_pk = acc.PrimaryKey(view);
   if (maybe_pk.HasError()) {
     spdlog::debug("Encountered an error while trying to get vertex primary key.");
     return std::nullopt;
   }
   auto &pk = maybe_pk.GetValue();
-  MG_ASSERT(schema.second.size() == pk.size(), "PrimaryKey size does not match schema!");
-  for (size_t i{0}; i < schema.second.size(); ++i) {
-    ret.emplace(schema.second[i].property_id, FromPropertyValueToValue(std::move(pk[i])));
+  MG_ASSERT(schema.properties.size() == pk.size(), "PrimaryKey size does not match schema!");
+  for (size_t i{0}; i < schema.properties.size(); ++i) {
+    ret.emplace(schema.properties[i].property_id, FromPropertyValueToValue(std::move(pk[i])));
   }
 
-  return {std::move(ret)};
+  return ret;
 }
 
 ShardResult<std::vector<msgs::Label>> FillUpSourceVertexSecondaryLabels(const std::optional<VertexAccessor> &v_acc,
@@ -81,8 +82,7 @@ ShardResult<std::vector<msgs::Label>> FillUpSourceVertexSecondaryLabels(const st
 
 ShardResult<std::map<PropertyId, Value>> FillUpSourceVertexProperties(const std::optional<VertexAccessor> &v_acc,
                                                                       const msgs::ExpandOneRequest &req,
-                                                                      storage::v3::View view,
-                                                                      const Schemas::Schema &schema) {
+                                                                      storage::v3::View view, const Schema &schema) {
   std::map<PropertyId, Value> src_vertex_properties;
 
   if (!req.src_vertex_properties) {
@@ -98,7 +98,7 @@ ShardResult<std::map<PropertyId, Value>> FillUpSourceVertexProperties(const std:
     }
     auto pks = PrimaryKeysFromAccessor(*v_acc, view, schema);
     if (pks) {
-      src_vertex_properties.merge(std::move(*pks));
+      src_vertex_properties.merge(*pks);
     }
 
   } else if (req.src_vertex_properties.value().empty()) {
@@ -235,7 +235,7 @@ std::vector<TypedValue> EvaluateEdgeExpressions(DbAccessor &dba, const VertexAcc
 }
 
 ShardResult<std::map<PropertyId, Value>> CollectAllPropertiesFromAccessor(const VertexAccessor &acc, View view,
-                                                                          const Schemas::Schema &schema) {
+                                                                          const Schema &schema) {
   auto ret = impl::CollectAllPropertiesImpl<VertexAccessor>(acc, view);
   if (ret.HasError()) {
     return ret.GetError();
@@ -320,15 +320,12 @@ 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.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(
-            EdgeWithAllProperties{ToMsgsVertexId(edge.From()), msgs::EdgeType{edge.EdgeType()}, edge.Gid().AsUint(),
-                                  std::move(value_properties)});
+        result_row.in_edges_with_all_properties.push_back(std::move(edges));
       } else {
-        result_row.out_edges_with_all_properties.push_back(
-            EdgeWithAllProperties{ToMsgsVertexId(edge.To()), msgs::EdgeType{edge.EdgeType()}, edge.Gid().AsUint(),
-                                  std::move(value_properties)});
+        result_row.out_edges_with_all_properties.push_back(std::move(edges));
       }
       return {};
     };
@@ -348,15 +345,12 @@ 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.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(
-            EdgeWithSpecificProperties{ToMsgsVertexId(edge.From()), msgs::EdgeType{edge.EdgeType()},
-                                       edge.Gid().AsUint(), std::move(value_properties)});
+        result_row.in_edges_with_specific_properties.push_back(std::move(edges));
       } else {
-        result_row.out_edges_with_specific_properties.push_back(
-            EdgeWithSpecificProperties{ToMsgsVertexId(edge.To()), msgs::EdgeType{edge.EdgeType()}, edge.Gid().AsUint(),
-                                       std::move(value_properties)});
+        result_row.out_edges_with_specific_properties.push_back(std::move(edges));
       }
       return {};
     };
@@ -383,10 +377,13 @@ bool FilterOnEdge(DbAccessor &dba, const storage::v3::VertexAccessor &v_acc, con
 }
 
 ShardResult<msgs::ExpandOneResultRow> GetExpandOneResult(
-    VertexAccessor v_acc, msgs::VertexId src_vertex, const msgs::ExpandOneRequest &req,
+    Shard::Accessor &acc, msgs::VertexId src_vertex, const msgs::ExpandOneRequest &req,
     const EdgeUniquenessFunction &maybe_filter_based_on_edge_uniqueness, const EdgeFiller &edge_filler,
-    const Schemas::Schema &schema) {
+    const Schema &schema) {
   /// Fill up source vertex
+  const auto primary_key = ConvertPropertyVector(src_vertex.second);
+  auto v_acc = acc.FindVertex(primary_key, View::NEW);
+
   msgs::Vertex source_vertex = {.id = src_vertex};
   auto maybe_secondary_labels = FillUpSourceVertexSecondaryLabels(v_acc, req);
   if (maybe_secondary_labels.HasError()) {
@@ -425,7 +422,7 @@ ShardResult<msgs::ExpandOneResultRow> GetExpandOneResult(
     VertexAccessor v_acc, msgs::VertexId src_vertex, const msgs::ExpandOneRequest &req,
     std::vector<EdgeAccessor> in_edge_accessors, std::vector<EdgeAccessor> out_edge_accessors,
     const EdgeUniquenessFunction &maybe_filter_based_on_edge_uniqueness, const EdgeFiller &edge_filler,
-    const Schemas::Schema &schema) {
+    const Schema &schema) {
   /// Fill up source vertex
   msgs::Vertex source_vertex = {.id = src_vertex};
   auto maybe_secondary_labels = FillUpSourceVertexSecondaryLabels(v_acc, req);

src/storage/v3/request_helper.hpp

@@ -217,7 +217,7 @@ ShardResult<std::map<PropertyId, Value>> CollectSpecificPropertiesFromAccessor(c
 }
 
 ShardResult<std::map<PropertyId, Value>> CollectAllPropertiesFromAccessor(const VertexAccessor &acc, View view,
-                                                                          const Schemas::Schema &schema);
+                                                                          const Schema &schema);
 namespace impl {
 template <PropertiesAccessor TAccessor>
 ShardResult<std::map<PropertyId, Value>> CollectAllPropertiesImpl(const TAccessor &acc, View view) {
@@ -233,7 +233,7 @@ ShardResult<std::map<PropertyId, Value>> CollectAllPropertiesImpl(const TAccesso
                  [](std::pair<const PropertyId, PropertyValue> &pair) {
                    return std::make_pair(pair.first, conversions::FromPropertyValueToValue(std::move(pair.second)));
                  });
-  return {std::move(ret)};
+  return ret;
 }
 }  // namespace impl
 
@@ -247,13 +247,13 @@ EdgeUniquenessFunction InitializeEdgeUniquenessFunction(bool only_unique_neighbo
 EdgeFiller InitializeEdgeFillerFunction(const msgs::ExpandOneRequest &req);
 
 ShardResult<msgs::ExpandOneResultRow> GetExpandOneResult(
-    VertexAccessor v_acc, msgs::VertexId src_vertex, const msgs::ExpandOneRequest &req,
+    Shard::Accessor &acc, msgs::VertexId src_vertex, const msgs::ExpandOneRequest &req,
     const EdgeUniquenessFunction &maybe_filter_based_on_edge_uniqueness, const EdgeFiller &edge_filler,
-    const Schemas::Schema &schema);
+    const Schema &schema);
 
 ShardResult<msgs::ExpandOneResultRow> GetExpandOneResult(
     VertexAccessor v_acc, msgs::VertexId src_vertex, const msgs::ExpandOneRequest &req,
     std::vector<EdgeAccessor> in_edge_accessors, std::vector<EdgeAccessor> out_edge_accessors,
     const EdgeUniquenessFunction &maybe_filter_based_on_edge_uniqueness, const EdgeFiller &edge_filler,
-    const Schemas::Schema &schema);
+    const Schema &schema);
 }  // namespace memgraph::storage::v3

src/storage/v3/schema_validator.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -44,20 +44,20 @@ ShardResult<void> SchemaValidator::ValidateVertexCreate(LabelId primary_label, c
   }
 
   // Quick size check
-  if (schema->second.size() != primary_properties.size()) {
+  if (schema->properties.size() != primary_properties.size()) {
     return SHARD_ERROR(ErrorCode::SCHEMA_VERTEX_PRIMARY_PROPERTIES_UNDEFINED,
                        "Not all primary properties have been specified for :{} vertex",
                        name_id_mapper_->IdToName(primary_label.AsInt()));
   }
   // Check only properties defined by schema
-  for (size_t i{0}; i < schema->second.size(); ++i) {
+  for (size_t i{0}; i < schema->properties.size(); ++i) {
     // Check schema property type
     if (auto property_schema_type = PropertyTypeToSchemaType(primary_properties[i]);
-        property_schema_type && *property_schema_type != schema->second[i].type) {
+        property_schema_type && *property_schema_type != schema->properties[i].type) {
       return SHARD_ERROR(ErrorCode::SCHEMA_VERTEX_PROPERTY_WRONG_TYPE,
                          "Property {} is of wrong type, expected {}, actual {}",
-                         name_id_mapper_->IdToName(schema->second[i].property_id.AsInt()),
-                         SchemaTypeToString(schema->second[i].type), SchemaTypeToString(*property_schema_type));
+                         name_id_mapper_->IdToName(schema->properties[i].property_id.AsInt()),
+                         SchemaTypeToString(schema->properties[i].type), SchemaTypeToString(*property_schema_type));
     }
   }
 
@@ -72,9 +72,9 @@ ShardResult<void> SchemaValidator::ValidatePropertyUpdate(const LabelId primary_
 
   // Verify that updating property is not part of schema
   if (const auto schema_property = std::ranges::find_if(
-          schema->second,
+          schema->properties,
           [property_id](const auto &schema_property) { return property_id == schema_property.property_id; });
-      schema_property != schema->second.end()) {
+      schema_property != schema->properties.end()) {
     return SHARD_ERROR(ErrorCode::SCHEMA_VERTEX_UPDATE_PRIMARY_KEY,
                        "Cannot update primary property {} of schema on label :{}",
                        name_id_mapper_->IdToName(schema_property->property_id.AsInt()),
@@ -92,7 +92,7 @@ ShardResult<void> SchemaValidator::ValidateLabelUpdate(const LabelId label) cons
   return {};
 }
 
-const Schemas::Schema *SchemaValidator::GetSchema(LabelId label) const { return schemas_->GetSchema(label); }
+const Schema *SchemaValidator::GetSchema(LabelId label) const { return schemas_->GetSchema(label); }
 
 VertexValidator::VertexValidator(const SchemaValidator &schema_validator, const LabelId primary_label)
     : schema_validator{&schema_validator}, primary_label_{primary_label} {}

src/storage/v3/schema_validator.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -33,7 +33,7 @@ class SchemaValidator {
 
   [[nodiscard]] ShardResult<void> ValidateLabelUpdate(LabelId label) const;
 
-  const Schemas::Schema *GetSchema(LabelId label) const;
+  const Schema *GetSchema(LabelId label) const;
 
  private:
   Schemas *schemas_;

src/storage/v3/schemas.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -25,25 +25,26 @@ bool operator==(const SchemaProperty &lhs, const SchemaProperty &rhs) {
 }
 
 Schemas::SchemasList Schemas::ListSchemas() const {
-  Schemas::SchemasList ret;
+  SchemasList ret;
   ret.reserve(schemas_.size());
   std::transform(schemas_.begin(), schemas_.end(), std::back_inserter(ret),
-                 [](const auto &schema_property_type) { return schema_property_type; });
+                 [](const auto &schema_property_type) { return schema_property_type.second; });
   return ret;
 }
 
-const Schemas::Schema *Schemas::GetSchema(const LabelId primary_label) const {
+const Schema *Schemas::GetSchema(const LabelId primary_label) const {
   if (auto schema_map = schemas_.find(primary_label); schema_map != schemas_.end()) {
-    return &*schema_map;
+    return &schema_map->second;
   }
   return nullptr;
 }
 
-bool Schemas::CreateSchema(const LabelId primary_label, const std::vector<SchemaProperty> &schemas_types) {
+bool Schemas::CreateSchema(const LabelId primary_label, const std::vector<SchemaProperty> &schemas_types,
+                           Schema::SchemaConfiguration config) {
   if (schemas_.contains(primary_label)) {
     return false;
   }
-  schemas_.emplace(primary_label, schemas_types);
+  schemas_.insert({primary_label, Schema{.label = primary_label, .properties = schemas_types, .config = config}});
   return true;
 }
 
@@ -51,9 +52,9 @@ bool Schemas::DropSchema(const LabelId primary_label) { return schemas_.erase(pr
 
 bool Schemas::IsPropertyKey(const LabelId primary_label, const PropertyId property_id) const {
   if (const auto schema = schemas_.find(primary_label); schema != schemas_.end()) {
-    return std::ranges::find_if(schema->second, [property_id](const auto &elem) {
+    return std::ranges::find_if(schema->second.properties, [property_id](const auto &elem) {
              return elem.property_id == property_id;
-           }) != schema->second.end();
+           }) != schema->second.properties.end();
   }
   throw utils::BasicException("Schema not found!");
 }

src/storage/v3/schemas.hpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -11,6 +11,7 @@
 
 #pragma once
 
+#include <cstdint>
 #include <memory>
 #include <optional>
 #include <unordered_map>
@@ -43,12 +44,24 @@ struct SchemaProperty {
   }
 };
 
+struct Schema {
+  LabelId label;
+  std::vector<SchemaProperty> properties;
+  struct SchemaConfiguration {
+    uint64_t replication_factor;
+    uint64_t split_threshold;
+  } config;
+
+  friend bool operator==(const Schema &lhs, const Schema &rhs) noexcept {
+    return lhs.label == rhs.label && lhs.properties == rhs.properties;
+  }
+};
+
 /// Structure that represents a collection of schemas
 /// Schema can be mapped under only one label => primary label
 class Schemas {
  public:
-  using SchemasMap = std::unordered_map<LabelId, std::vector<SchemaProperty>>;
-  using Schema = SchemasMap::value_type;
+  using SchemasMap = std::unordered_map<LabelId, Schema>;
   using SchemasList = std::vector<Schema>;
 
   Schemas() = default;
@@ -64,7 +77,8 @@ class Schemas {
 
   // Returns true if it was successfully created or false if the schema
   // already exists
-  [[nodiscard]] bool CreateSchema(LabelId primary_label, const std::vector<SchemaProperty> &schemas_types);
+  [[nodiscard]] bool CreateSchema(LabelId primary_label, const std::vector<SchemaProperty> &schemas_types,
+                                  Schema::SchemaConfiguration config = {});
 
   // Returns true if it was successfully dropped or false if the schema
   // does not exist

src/storage/v3/shard.cpp

@@ -35,6 +35,7 @@
 #include "storage/v3/property_value.hpp"
 #include "storage/v3/result.hpp"
 #include "storage/v3/schema_validator.hpp"
+#include "storage/v3/schemas.hpp"
 #include "storage/v3/transaction.hpp"
 #include "storage/v3/vertex.hpp"
 #include "storage/v3/vertex_accessor.hpp"
@@ -332,7 +333,9 @@ Shard::Shard(const LabelId primary_label, const PrimaryKey min_primary_key,
       vertex_validator_{schema_validator_, primary_label},
       indices_{config.items, vertex_validator_},
       isolation_level_{config.transaction.isolation_level},
-      config_{config} {
+      config_{config},
+      shard_splitter_(primary_label, vertices_, edges_, start_logical_id_to_transaction_, indices_, config_, schema,
+                      name_id_mapper_) {
   CreateSchema(primary_label_, schema);
   StoreMapping(std::move(id_to_name));
 }
@@ -352,7 +355,9 @@ Shard::Shard(LabelId primary_label, PrimaryKey min_primary_key, std::optional<Pr
       indices_{config.items, vertex_validator_},
       isolation_level_{config.transaction.isolation_level},
       config_{config},
-      start_logical_id_to_transaction_(std::move(start_logical_id_to_transaction)) {
+      start_logical_id_to_transaction_(std::move(start_logical_id_to_transaction)),
+      shard_splitter_(primary_label, vertices_, edges_, start_logical_id_to_transaction_, indices_, config_, schema,
+                      name_id_mapper_) {
   CreateSchema(primary_label_, schema);
   StoreMapping(id_to_name);
 }
@@ -371,7 +376,9 @@ Shard::Shard(LabelId primary_label, PrimaryKey min_primary_key, std::optional<Pr
       indices_{config.items, vertex_validator_},
       isolation_level_{config.transaction.isolation_level},
       config_{config},
-      start_logical_id_to_transaction_(std::move(start_logical_id_to_transaction)) {
+      start_logical_id_to_transaction_(std::move(start_logical_id_to_transaction)),
+      shard_splitter_(primary_label, vertices_, edges_, start_logical_id_to_transaction_, indices_, config_, schema,
+                      name_id_mapper_) {
   CreateSchema(primary_label_, schema);
   StoreMapping(id_to_name);
 }
@@ -397,8 +404,6 @@ ShardResult<VertexAccessor> Shard::Accessor::CreateVertexAndValidate(
     const std::vector<LabelId> &labels, const PrimaryKey &primary_properties,
     const std::vector<std::pair<PropertyId, PropertyValue>> &properties) {
   OOMExceptionEnabler oom_exception;
-  const auto schema = shard_->GetSchema(shard_->primary_label_)->second;
-
   auto maybe_schema_violation =
       GetSchemaValidator().ValidateVertexCreate(shard_->primary_label_, labels, primary_properties);
   if (maybe_schema_violation.HasError()) {
@@ -901,8 +906,8 @@ bool Shard::CreateIndex(LabelId label, const std::optional<uint64_t> /*desired_c
 bool Shard::CreateIndex(LabelId label, PropertyId property,
                         const std::optional<uint64_t> /*desired_commit_timestamp*/) {
   // TODO(jbajic) response should be different when index conflicts with schema
-  if (label == primary_label_ && schemas_.GetSchema(primary_label_)->second.size() == 1 &&
-      schemas_.GetSchema(primary_label_)->second[0].property_id == property) {
+  if (label == primary_label_ && schemas_.GetSchema(primary_label_)->properties.size() == 1 &&
+      schemas_.GetSchema(primary_label_)->properties[0].property_id == property) {
     // Index already exists on primary key
     return false;
   }
@@ -928,10 +933,11 @@ const SchemaValidator &Shard::Accessor::GetSchemaValidator() const { return shar
 
 SchemasInfo Shard::ListAllSchemas() const { return {schemas_.ListSchemas()}; }
 
-const Schemas::Schema *Shard::GetSchema(const LabelId primary_label) const { return schemas_.GetSchema(primary_label); }
+const Schema *Shard::GetSchema(const LabelId primary_label) const { return schemas_.GetSchema(primary_label); }
 
-bool Shard::CreateSchema(const LabelId primary_label, const std::vector<SchemaProperty> &schemas_types) {
-  return schemas_.CreateSchema(primary_label, schemas_types);
+bool Shard::CreateSchema(const LabelId primary_label, const std::vector<SchemaProperty> &schemas_types,
+                         Schema::SchemaConfiguration config) {
+  return schemas_.CreateSchema(primary_label, schemas_types, config);
 }
 
 bool Shard::DropSchema(const LabelId primary_label) { return schemas_.DropSchema(primary_label); }
@@ -1111,11 +1117,7 @@ SplitData Shard::PerformSplit(const PrimaryKey &split_key, const uint64_t shard_
   shard_version_ = shard_version;
   const auto old_max_key = max_primary_key_;
   max_primary_key_ = split_key;
-  const auto *schema = GetSchema(primary_label_);
-  MG_ASSERT(schema, "Shard must know about schema of primary label!");
-  Splitter shard_splitter(primary_label_, vertices_, edges_, start_logical_id_to_transaction_, indices_, config_,
-                          schema->second, name_id_mapper_);
-  return shard_splitter.SplitShard(split_key, old_max_key, shard_version);
+  return shard_splitter_.SplitShard(split_key, old_max_key, shard_version);
 }
 
 bool Shard::IsVertexBelongToShard(const VertexId &vertex_id) const {

src/storage/v3/shard.hpp

@@ -364,9 +364,10 @@ class Shard final {
 
   SchemasInfo ListAllSchemas() const;
 
-  const Schemas::Schema *GetSchema(LabelId primary_label) const;
+  const Schema *GetSchema(LabelId primary_label) const;
 
-  bool CreateSchema(LabelId primary_label, const std::vector<SchemaProperty> &schemas_types);
+  bool CreateSchema(LabelId primary_label, const std::vector<SchemaProperty> &schemas_types,
+                    Schema::SchemaConfiguration = {});
 
   bool DropSchema(LabelId primary_label);
 
@@ -423,6 +424,7 @@ class Shard final {
   // Holds all of the (in progress, committed and aborted) transactions that are read or write to this shard, but
   // haven't been cleaned up yet
   std::map<uint64_t, std::unique_ptr<Transaction>> start_logical_id_to_transaction_{};
+  Splitter shard_splitter_;
   bool has_any_transaction_aborted_since_last_gc{false};
 };
 

src/storage/v3/shard_manager.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -250,8 +250,8 @@ class ShardManager {
 
     spdlog::info("SM sending heartbeat to coordinator {}", coordinator_leader_.ToString());
     heartbeat_res_.emplace(std::move(
-        io_.template Request<WriteResponse<CoordinatorWriteResponses>, WriteRequest<CoordinatorWriteRequests>>(
-            coordinator_leader_, std::move(ww))));
+        io_.template Request<WriteRequest<CoordinatorWriteRequests>, WriteResponse<CoordinatorWriteResponses>>(
+            coordinator_leader_, ww)));
     spdlog::info("SM sent heartbeat");
   }
 

src/storage/v3/shard_rsm.cpp

@@ -472,8 +472,7 @@ msgs::ReadResponses ShardRsm::HandleRead(msgs::ExpandOneRequest &&req) {
       if (req.order_by_edges.empty()) {
         const auto *schema = shard_->GetSchema(shard_->PrimaryLabel());
         MG_ASSERT(schema);
-        return GetExpandOneResult(src_vertex_acc, std::move(src_vertex), req, maybe_filter_based_on_edge_uniqueness,
-                                  edge_filler, *schema);
+        return GetExpandOneResult(acc, src_vertex, req, maybe_filter_based_on_edge_uniqueness, edge_filler, *schema);
       }
       auto [in_edge_accessors, out_edge_accessors] = GetEdgesFromVertex(src_vertex_acc, req.direction);
       const auto in_ordered_edges = OrderByEdges(dba, in_edge_accessors, req.order_by_edges, src_vertex_acc);
@@ -488,13 +487,12 @@ msgs::ReadResponses ShardRsm::HandleRead(msgs::ExpandOneRequest &&req) {
                      [](const auto &edge_element) { return edge_element.object_acc; });
       const auto *schema = shard_->GetSchema(shard_->PrimaryLabel());
       MG_ASSERT(schema);
-      return GetExpandOneResult(src_vertex_acc, std::move(src_vertex), req, std::move(in_edge_ordered_accessors),
-                                std::move(out_edge_ordered_accessors), maybe_filter_based_on_edge_uniqueness,
-                                edge_filler, *schema);
+      return GetExpandOneResult(src_vertex_acc, src_vertex, req, in_edge_ordered_accessors, out_edge_ordered_accessors,
+                                maybe_filter_based_on_edge_uniqueness, edge_filler, *schema);
     });
 
     if (maybe_result.HasError()) {
-      shard_error.emplace(CreateErrorResponse(maybe_result.GetError(), req.transaction_id, "getting expand result"));
+      shard_error.emplace(CreateErrorResponse(primary_key.GetError(), req.transaction_id, "getting primary key"));
       break;
     }
 
@@ -583,12 +581,12 @@ msgs::ReadResponses ShardRsm::HandleRead(msgs::GetPropertiesRequest &&req) {
     if (maybe_id.HasError()) {
       return {maybe_id.GetError()};
     }
-    auto &vertex_id = maybe_id.GetValue();
+    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{vertex_id.primary_label}, ConvertValueVector(std::move(vertex_id.primary_key))};
+    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()};

src/storage/v3/shard_rsm.hpp

@@ -57,7 +57,7 @@ class ShardRsm {
   }
 
   // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
-  msgs::ReadResponses Read(msgs::ReadRequests &&requests) {
+  msgs::ReadResponses Read(msgs::ReadRequests requests) {
     return std::visit([&](auto &&request) mutable { return HandleRead(std::forward<decltype(request)>(request)); },
                       std::move(requests));
   }

src/storage/v3/shard_worker.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -100,7 +100,7 @@ class Queue {
 
       inner_->submitted++;
 
-      inner_->queue.emplace_back(std::move(message));
+      inner_->queue.emplace_back(std::forward<Message>(message));
     }  // lock dropped before notifying condition variable
 
     inner_->cv.notify_all();

src/storage/v3/splitter.cpp

@@ -57,12 +57,12 @@ SplitData Splitter::SplitShard(const PrimaryKey &split_key, const std::optional<
   std::set<uint64_t> collected_transactions_;
   data.vertices = CollectVertices(data, collected_transactions_, split_key);
   data.edges = CollectEdges(collected_transactions_, data.vertices, split_key);
-  data.transactions = CollectTransactions(collected_transactions_, *data.edges, split_key);
+  data.transactions = CollectTransactions(collected_transactions_, data.vertices, *data.edges, split_key);
 
   return data;
 }
 
-void Splitter::ScanDeltas(std::set<uint64_t> &collected_transactions_, const Delta *delta) {
+void Splitter::ScanDeltas(std::set<uint64_t> &collected_transactions_, Delta *delta) {
   while (delta != nullptr) {
     collected_transactions_.insert(delta->commit_info->start_or_commit_timestamp.logical_id);
     delta = delta->next;
@@ -82,8 +82,8 @@ VertexContainer Splitter::CollectVertices(SplitData &data, std::set<uint64_t> &c
 
     auto next_it = std::next(split_key_it);
 
-    const auto new_it = splitted_data.insert(splitted_data.end(), vertices_.extract(split_key_it));
-    MG_ASSERT(new_it != splitted_data.end(), "Failed to extract vertex!");
+    const auto &[splitted_vertex_it, inserted, node] = splitted_data.insert(vertices_.extract(split_key_it->first));
+    MG_ASSERT(inserted, "Failed to extract vertex!");
 
     split_key_it = next_it;
   }
@@ -122,7 +122,8 @@ std::optional<EdgeContainer> Splitter::CollectEdges(std::set<uint64_t> &collecte
 }
 
 std::map<uint64_t, std::unique_ptr<Transaction>> Splitter::CollectTransactions(
-    const std::set<uint64_t> &collected_transactions_, EdgeContainer &cloned_edges, const PrimaryKey &split_key) {
+    const std::set<uint64_t> &collected_transactions_, VertexContainer &cloned_vertices, EdgeContainer &cloned_edges,
+    const PrimaryKey &split_key) {
   std::map<uint64_t, std::unique_ptr<Transaction>> transactions;
 
   for (const auto &[commit_start, transaction] : start_logical_id_to_transaction_) {
@@ -135,46 +136,12 @@ std::map<uint64_t, std::unique_ptr<Transaction>> Splitter::CollectTransactions(
 
   // It is necessary to clone all the transactions first so we have new addresses
   // for deltas, before doing alignment of deltas and prev_ptr
-  AdjustClonedTransactions(transactions, cloned_edges, split_key);
+  AdjustClonedTransactions(transactions, cloned_vertices, cloned_edges, split_key);
   return transactions;
 }
 
-void EraseDeltaChain(auto &transaction, auto &transactions, auto &delta_head_it) {
-  auto *current_next_delta = delta_head_it->next;
-  // We need to keep track of delta_head_it in the delta list of current transaction
-  delta_head_it = transaction.deltas.erase(delta_head_it);
-
-  while (current_next_delta != nullptr) {
-    auto *next_delta = current_next_delta->next;
-    // Find next delta transaction delta list
-    auto current_transaction_it = std::ranges::find_if(
-        transactions, [&start_or_commit_timestamp =
-                           current_next_delta->commit_info->start_or_commit_timestamp](const auto &transaction) {
-          return transaction.second->start_timestamp == start_or_commit_timestamp ||
-                 transaction.second->commit_info->start_or_commit_timestamp == start_or_commit_timestamp;
-        });
-    MG_ASSERT(current_transaction_it != transactions.end(), "Error when pruning deltas!");
-    // Remove the delta
-    const auto delta_it =
-        std::ranges::find_if(current_transaction_it->second->deltas,
-                             [current_next_delta](const auto &elem) { return elem.id == current_next_delta->id; });
-    if (delta_it != current_transaction_it->second->deltas.end()) {
-      // If the next delta is next in transaction list replace current_transaction_it
-      // with the next one
-      if (current_transaction_it->second->start_timestamp == transaction.start_timestamp &&
-          current_transaction_it == std::next(current_transaction_it)) {
-        delta_head_it = current_transaction_it->second->deltas.erase(delta_it);
-      } else {
-        current_transaction_it->second->deltas.erase(delta_it);
-      }
-    }
-
-    current_next_delta = next_delta;
-  }
-}
-
 void PruneDeltas(Transaction &cloned_transaction, std::map<uint64_t, std::unique_ptr<Transaction>> &cloned_transactions,
-                 const PrimaryKey &split_key, EdgeContainer &cloned_edges) {
+                 const PrimaryKey &split_key) {
   // Remove delta chains that don't point to objects on splitted shard
   auto cloned_delta_it = cloned_transaction.deltas.begin();
 
@@ -188,74 +155,49 @@ void PruneDeltas(Transaction &cloned_transaction, std::map<uint64_t, std::unique
       case PreviousPtr::Type::VERTEX: {
         if (prev.vertex->first < split_key) {
           // We can remove this delta chain
-          EraseDeltaChain(cloned_transaction, cloned_transactions, cloned_delta_it);
+          auto *current_next_delta = cloned_delta_it->next;
+          cloned_delta_it = cloned_transaction.deltas.erase(cloned_delta_it);
+
+          while (current_next_delta != nullptr) {
+            auto *next_delta = current_next_delta->next;
+            // Find next delta transaction delta list
+            auto current_transaction_it = std::ranges::find_if(
+                cloned_transactions,
+                [&start_or_commit_timestamp =
+                     current_next_delta->commit_info->start_or_commit_timestamp](const auto &transaction) {
+                  return transaction.second->start_timestamp == start_or_commit_timestamp ||
+                         transaction.second->commit_info->start_or_commit_timestamp == start_or_commit_timestamp;
+                });
+            MG_ASSERT(current_transaction_it != cloned_transactions.end(), "Error when pruning deltas!");
+            // Remove it
+            current_transaction_it->second->deltas.remove_if(
+                [&current_next_delta = *current_next_delta](const auto &delta) { return delta == current_next_delta; });
+
+            current_next_delta = next_delta;
+          }
         } else {
           ++cloned_delta_it;
         }
         break;
       }
-      case PreviousPtr::Type::EDGE: {
-        if (const auto edge_gid = prev.edge->gid; !cloned_edges.contains(edge_gid)) {
-          // We can remove this delta chain
-          EraseDeltaChain(cloned_transaction, cloned_transactions, cloned_delta_it);
-        } else {
-          ++cloned_delta_it;
-        }
+      case PreviousPtr::Type::EDGE:
+        ++cloned_delta_it;
         break;
-      }
-    }
-  }
-}
-
-void Splitter::PruneOriginalDeltas(Transaction &transaction,
-                                   std::map<uint64_t, std::unique_ptr<Transaction>> &transactions,
-                                   const PrimaryKey &split_key) {
-  // Remove delta chains that don't point to objects on splitted shard
-  auto delta_it = transaction.deltas.begin();
-
-  while (delta_it != transaction.deltas.end()) {
-    const auto prev = delta_it->prev.Get();
-    switch (prev.type) {
-      case PreviousPtr::Type::DELTA:
-      case PreviousPtr::Type::NULLPTR:
-        ++delta_it;
-        break;
-      case PreviousPtr::Type::VERTEX: {
-        if (prev.vertex->first >= split_key) {
-          // We can remove this delta chain
-          EraseDeltaChain(transaction, transactions, delta_it);
-        } else {
-          ++delta_it;
-        }
-        break;
-      }
-      case PreviousPtr::Type::EDGE: {
-        if (const auto edge_gid = prev.edge->gid; !edges_.contains(edge_gid)) {
-          // We can remove this delta chain
-          EraseDeltaChain(transaction, transactions, delta_it);
-        } else {
-          ++delta_it;
-        }
-        break;
-      }
     }
   }
 }
 
 void Splitter::AdjustClonedTransactions(std::map<uint64_t, std::unique_ptr<Transaction>> &cloned_transactions,
-                                        EdgeContainer &cloned_edges, const PrimaryKey &split_key) {
-  for (auto &[start_id, cloned_transaction] : cloned_transactions) {
-    AdjustClonedTransaction(*cloned_transaction, *start_logical_id_to_transaction_[start_id], cloned_transactions,
-                            cloned_edges);
+                                        VertexContainer &cloned_vertices, EdgeContainer &cloned_edges,
+                                        const PrimaryKey &split_key) {
+  for (auto &[commit_start, cloned_transaction] : cloned_transactions) {
+    AdjustClonedTransaction(*cloned_transaction, *start_logical_id_to_transaction_[commit_start], cloned_transactions,
+                            cloned_vertices, cloned_edges, split_key);
   }
   // Prune deltas whose delta chain points to vertex/edge that should not belong on that shard
-  // Prune must be after adjust, since next, and prev are not set and we cannot follow the chain
-  for (auto &[start_id, cloned_transaction] : cloned_transactions) {
-    PruneDeltas(*cloned_transaction, cloned_transactions, split_key, cloned_edges);
-  }
-  // Also we need to remove deltas from original transactions
-  for (auto &[start_id, original_transaction] : start_logical_id_to_transaction_) {
-    PruneOriginalDeltas(*original_transaction, start_logical_id_to_transaction_, split_key);
+  // Prune must be after ajdust, since next, and prev are not set and we cannot follow the chain
+  for (auto &[commit_start, cloned_transaction] : cloned_transactions) {
+    PruneDeltas(*cloned_transaction, cloned_transactions, split_key);
   }
 }
 
@@ -269,7 +211,8 @@ bool DoesPrevPtrPointsToSplittedData(const PreviousPtr::Pointer &prev_ptr, const
 
 void Splitter::AdjustClonedTransaction(Transaction &cloned_transaction, const Transaction &transaction,
                                        std::map<uint64_t, std::unique_ptr<Transaction>> &cloned_transactions,
-                                       EdgeContainer &cloned_edges) {
+                                       VertexContainer &cloned_vertices, EdgeContainer &cloned_edges,
+                                       const PrimaryKey & /*split_key*/) {
   auto delta_it = transaction.deltas.begin();
   auto cloned_delta_it = cloned_transaction.deltas.begin();
 
@@ -285,17 +228,18 @@ void Splitter::AdjustClonedTransaction(Transaction &cloned_transaction, const Tr
     const auto *delta = &*delta_it;
     auto *cloned_delta = &*cloned_delta_it;
     Delta *cloned_delta_prev_ptr = cloned_delta;
-    // The head of delta chains contain either vertex/edge as prev ptr so we adjust
-    // it just at the beginning of delta chain
-    AdjustDeltaPrevPtr(*delta, *cloned_delta_prev_ptr, cloned_transactions, cloned_edges);
-
     while (delta->next != nullptr) {
       AdjustEdgeRef(*cloned_delta, cloned_edges);
 
-      // Align next ptr and prev ptr
-      AdjustDeltaNextAndPrev(*delta, *cloned_delta, cloned_transactions);
+      // Align next ptr
+      AdjustDeltaNext(*delta, *cloned_delta, cloned_transactions);
 
-      // Next delta might not belong to the cloned transaction and thats
+      // Align prev ptr
+      if (cloned_delta_prev_ptr != nullptr) {
+        AdjustDeltaPrevPtr(*delta, *cloned_delta_prev_ptr, cloned_transactions, cloned_vertices, cloned_edges);
+      }
+
+      // TODO Next delta might not belong to the cloned transaction and thats
       // why we skip this delta of the delta chain
       if (cloned_delta->next != nullptr) {
         cloned_delta = cloned_delta->next;
@@ -307,7 +251,7 @@ void Splitter::AdjustClonedTransaction(Transaction &cloned_transaction, const Tr
     }
     // Align prev ptr
     if (cloned_delta_prev_ptr != nullptr) {
-      AdjustDeltaPrevPtr(*delta, *cloned_delta_prev_ptr, cloned_transactions, cloned_edges);
+      AdjustDeltaPrevPtr(*delta, *cloned_delta_prev_ptr, cloned_transactions, cloned_vertices, cloned_edges);
     }
 
     ++delta_it;
@@ -325,7 +269,11 @@ void Splitter::AdjustEdgeRef(Delta &cloned_delta, EdgeContainer &cloned_edges) c
     case Delta::Action::REMOVE_OUT_EDGE: {
       // Find edge
       if (config_.items.properties_on_edges) {
-        if (const auto cloned_edge_it = cloned_edges.find(cloned_delta.vertex_edge.edge.ptr->gid);
+        // Only case when not finding is when the edge is not on splitted shard
+        // TODO Do this after prune an move condition into assert
+        if (const auto cloned_edge_it =
+                std::ranges::find_if(cloned_edges, [edge_ptr = cloned_delta.vertex_edge.edge.ptr](
+                                                       const auto &elem) { return elem.second.gid == edge_ptr->gid; });
             cloned_edge_it != cloned_edges.end()) {
           cloned_delta.vertex_edge.edge = EdgeRef{&cloned_edge_it->second};
         }
@@ -343,18 +291,13 @@ void Splitter::AdjustEdgeRef(Delta &cloned_delta, EdgeContainer &cloned_edges) c
   }
 }
 
-void Splitter::AdjustDeltaNextAndPrev(const Delta &original, Delta &cloned,
-                                      std::map<uint64_t, std::unique_ptr<Transaction>> &cloned_transactions) {
+void Splitter::AdjustDeltaNext(const Delta &original, Delta &cloned,
+                               std::map<uint64_t, std::unique_ptr<Transaction>> &cloned_transactions) {
   // Get cloned_delta->next transaction, using delta->next original transaction
-  // cloned_transactions key is start_timestamp
-  auto cloned_transaction_it =
-      cloned_transactions.find(original.next->commit_info->start_or_commit_timestamp.logical_id);
-  if (cloned_transaction_it == cloned_transactions.end()) {
-    cloned_transaction_it = std::ranges::find_if(cloned_transactions, [&original](const auto &elem) {
-      return elem.second->commit_info->start_or_commit_timestamp ==
-             original.next->commit_info->start_or_commit_timestamp;
-    });
-  }
+  auto cloned_transaction_it = std::ranges::find_if(cloned_transactions, [&original](const auto &elem) {
+    return elem.second->start_timestamp == original.next->commit_info->start_or_commit_timestamp ||
+           elem.second->commit_info->start_or_commit_timestamp == original.next->commit_info->start_or_commit_timestamp;
+  });
   // TODO(jbajic) What if next in delta chain does not belong to cloned transaction?
   // MG_ASSERT(cloned_transaction_it != cloned_transactions.end(), "Cloned transaction not found");
   if (cloned_transaction_it == cloned_transactions.end()) return;
@@ -363,16 +306,15 @@ void Splitter::AdjustDeltaNextAndPrev(const Delta &original, Delta &cloned,
       cloned_transaction_it->second->deltas, [&original](const auto &elem) { return elem.id == original.next->id; });
   MG_ASSERT(found_cloned_delta_it != cloned_transaction_it->second->deltas.end(), "Delta with given uuid must exist!");
   cloned.next = &*found_cloned_delta_it;
-  found_cloned_delta_it->prev.Set(&cloned);
 }
 
 void Splitter::AdjustDeltaPrevPtr(const Delta &original, Delta &cloned,
                                   std::map<uint64_t, std::unique_ptr<Transaction>> &cloned_transactions,
-                                  EdgeContainer &cloned_edges) {
+                                  VertexContainer & /*cloned_vertices*/, EdgeContainer &cloned_edges) {
   auto ptr = original.prev.Get();
   switch (ptr.type) {
     case PreviousPtr::Type::NULLPTR: {
-      MG_ASSERT(false, "PreviousPtr cannot be a nullptr!");
+      // noop
       break;
     }
     case PreviousPtr::Type::DELTA: {
@@ -395,13 +337,11 @@ void Splitter::AdjustDeltaPrevPtr(const Delta &original, Delta &cloned,
     case PreviousPtr::Type::VERTEX: {
       // The vertex was extracted and it is safe to reuse address
       cloned.prev.Set(ptr.vertex);
-      ptr.vertex->second.delta = &cloned;
       break;
     }
     case PreviousPtr::Type::EDGE: {
       // We can never be here if we have properties on edge disabled
       auto *cloned_edge = &*cloned_edges.find(ptr.edge->gid);
-      ptr.edge->delta = &cloned;
       cloned.prev.Set(&cloned_edge->second);
       break;
     }

src/storage/v3/splitter.hpp

@@ -48,7 +48,6 @@ struct SplitData {
   std::map<std::pair<LabelId, PropertyId>, LabelPropertyIndex::IndexContainer> label_property_indices;
 };
 
-// TODO(jbajic) Handle deleted_vertices_ and deleted_edges_ after the finishing GC
 class Splitter final {
  public:
   Splitter(LabelId primary_label, VertexContainer &vertices, EdgeContainer &edges,
@@ -72,29 +71,28 @@ class Splitter final {
                                             const VertexContainer &split_vertices, const PrimaryKey &split_key);
 
   std::map<uint64_t, std::unique_ptr<Transaction>> CollectTransactions(
-      const std::set<uint64_t> &collected_transactions_start_id, EdgeContainer &cloned_edges,
-      const PrimaryKey &split_key);
+      const std::set<uint64_t> &collected_transactions_start_id, VertexContainer &cloned_vertices,
+      EdgeContainer &cloned_edges, const PrimaryKey &split_key);
 
-  static void ScanDeltas(std::set<uint64_t> &collected_transactions_start_id, const Delta *delta);
-
-  void PruneOriginalDeltas(Transaction &transaction, std::map<uint64_t, std::unique_ptr<Transaction>> &transactions,
-                           const PrimaryKey &split_key);
+  static void ScanDeltas(std::set<uint64_t> &collected_transactions_start_id, Delta *delta);
 
   void AdjustClonedTransaction(Transaction &cloned_transaction, const Transaction &transaction,
                                std::map<uint64_t, std::unique_ptr<Transaction>> &cloned_transactions,
-                               EdgeContainer &cloned_edges);
+                               VertexContainer &cloned_vertices, EdgeContainer &cloned_edges,
+                               const PrimaryKey &split_key);
 
   void AdjustClonedTransactions(std::map<uint64_t, std::unique_ptr<Transaction>> &cloned_transactions,
-                                EdgeContainer &cloned_edges, const PrimaryKey &split_key);
+                                VertexContainer &cloned_vertices, EdgeContainer &cloned_edges,
+                                const PrimaryKey &split_key);
 
   void AdjustEdgeRef(Delta &cloned_delta, EdgeContainer &cloned_edges) const;
 
-  static void AdjustDeltaNextAndPrev(const Delta &original, Delta &cloned,
-                                     std::map<uint64_t, std::unique_ptr<Transaction>> &cloned_transactions);
+  static void AdjustDeltaNext(const Delta &original, Delta &cloned,
+                              std::map<uint64_t, std::unique_ptr<Transaction>> &cloned_transactions);
 
   static void AdjustDeltaPrevPtr(const Delta &original, Delta &cloned,
                                  std::map<uint64_t, std::unique_ptr<Transaction>> &cloned_transactions,
-                                 EdgeContainer &cloned_edges);
+                                 VertexContainer &cloned_vertices, EdgeContainer &cloned_edges);
 
   const LabelId primary_label_;
   VertexContainer &vertices_;

src/storage/v3/transaction.hpp

@@ -31,11 +31,12 @@ struct CommitInfo {
 };
 
 struct Transaction {
-  Transaction(coordinator::Hlc start_timestamp, CommitInfo new_commit_info, uint64_t command_id, bool must_abort,
-              bool is_aborted, IsolationLevel isolation_level)
+  Transaction(coordinator::Hlc start_timestamp, CommitInfo new_commit_info, std::list<Delta> deltas,
+              uint64_t command_id, bool must_abort, bool is_aborted, IsolationLevel isolation_level)
       : start_timestamp{start_timestamp},
         commit_info{std::make_unique<CommitInfo>(new_commit_info)},
         command_id(command_id),
+        deltas(std::move(deltas)),
         must_abort(must_abort),
         is_aborted(is_aborted),
         isolation_level(isolation_level){};
@@ -107,10 +108,8 @@ struct Transaction {
 
   // This does not solve the whole problem of copying deltas
   std::unique_ptr<Transaction> Clone() const {
-    auto transaction_ptr = std::make_unique<Transaction>(start_timestamp, *commit_info, command_id, must_abort,
-                                                         is_aborted, isolation_level);
-    transaction_ptr->deltas = CopyDeltas(transaction_ptr->commit_info.get());
-    return transaction_ptr;
+    return std::make_unique<Transaction>(start_timestamp, *commit_info, CopyDeltas(commit_info.get()), command_id,
+                                         must_abort, is_aborted, isolation_level);
   }
 
   coordinator::Hlc start_timestamp;

src/storage/v3/value_conversions.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -126,17 +126,6 @@ inline std::vector<Value> ConvertValueVector(const std::vector<v3::PropertyValue
   return ret;
 }
 
-inline std::vector<Value> ConvertValueVector(std::vector<v3::PropertyValue> &&vec) {
-  std::vector<Value> ret;
-  ret.reserve(vec.size());
-
-  for (auto &&elem : vec) {
-    ret.push_back(FromPropertyValueToValue(std::move(elem)));
-  }
-
-  return ret;
-}
-
 inline msgs::VertexId ToMsgsVertexId(const v3::VertexId &vertex_id) {
   return {msgs::Label{vertex_id.primary_label}, ConvertValueVector(vertex_id.primary_key)};
 }

src/storage/v3/vertex_accessor.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -396,8 +396,8 @@ PropertyValue VertexAccessor::GetPropertyValue(PropertyId property, View view) c
     return value;
   }
   // Find PropertyId index in keystore
-  for (size_t property_index{0}; property_index < schema->second.size(); ++property_index) {
-    if (schema->second[property_index].property_id == property) {
+  for (size_t property_index{0}; property_index < schema->properties.size(); ++property_index) {
+    if (schema->properties[property_index].property_id == property) {
       return vertex_->first[property_index];
     }
   }

src/utils/concepts.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -12,7 +12,6 @@
 #pragma once
 #include <concepts>
 #include <iterator>
-#include <type_traits>
 
 namespace memgraph::utils {
 template <typename T, typename... Args>
@@ -35,7 +34,4 @@ template <typename T>
 concept Dereferenceable = requires(T t) {
   { *t } -> CanReference;
 };
-
-template <typename T>
-concept Object = std::is_object_v<T>;
 }  // namespace memgraph::utils

tests/benchmark/CMakeLists.txt

@@ -82,9 +82,3 @@ target_link_libraries(${test_prefix}data_structures_remove mg-utils mg-storage-v
 
 add_benchmark(storage_v3_split.cpp)
 target_link_libraries(${test_prefix}storage_v3_split mg-storage-v3 mg-query-v2)
-
-add_benchmark(storage_v3_split_1.cpp)
-target_link_libraries(${test_prefix}storage_v3_split_1 mg-storage-v3 mg-query-v2)
-
-add_benchmark(storage_v3_split_2.cpp)
-target_link_libraries(${test_prefix}storage_v3_split_2 mg-storage-v3 mg-query-v2)

tests/benchmark/storage_v3_split.cpp

@@ -120,48 +120,38 @@ BENCHMARK_DEFINE_F(ShardSplitBenchmark, BigDataSplitWithGc)(::benchmark::State &
   }
 }
 
-BENCHMARK_DEFINE_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)(::benchmark::State &state) {
+BENCHMARK_DEFINE_F(ShardSplitBenchmark, BigDataSplitWithFewTransactions)(::benchmark::State &state) {
   const auto number_of_vertices = state.range(0);
   const auto number_of_edges = state.range(1);
   const auto number_of_transactions = state.range(2);
   std::random_device r;
   std::default_random_engine e1(r());
-  std::uniform_int_distribution<int> uniform_dist(0, number_of_vertices - number_of_transactions - 1);
+  std::uniform_int_distribution<int> uniform_dist(0, number_of_vertices);
 
-  // Create Vertices
-  int64_t vertex_count{0};
-  {
+  const auto max_transactions_needed = std::max(number_of_vertices, number_of_edges);
+  for (int64_t vertex_counter{number_of_vertices}, edge_counter{number_of_edges}, i{0};
+       vertex_counter > 0 || edge_counter > 0; --vertex_counter, --edge_counter, ++i) {
     auto acc = storage->Access(GetNextHlc());
-    for (; vertex_count < number_of_vertices - number_of_transactions; ++vertex_count) {
-      MG_ASSERT(acc.CreateVertexAndValidate({secondary_label}, PrimaryKey{PropertyValue(vertex_count)},
-                                            {{secondary_property, PropertyValue(vertex_count)}})
+    if (vertex_counter > 0) {
+      MG_ASSERT(acc.CreateVertexAndValidate({secondary_label}, PrimaryKey{PropertyValue(i)},
+                                            {{secondary_property, PropertyValue(i)}})
                     .HasValue(),
-                "Failed creating with pk {}", vertex_count);
+                "Failed creating with pk {}", i);
     }
-
-    // Create Edges
-    for (int64_t i{0}; i < number_of_edges; ++i) {
-      const auto vtx1 = uniform_dist(e1);
-      const auto vtx2 = uniform_dist(e1);
+    if (edge_counter > 0 && i > 1) {
+      const auto vtx1 = uniform_dist(e1) % std::min(i, number_of_vertices);
+      const auto vtx2 = uniform_dist(e1) % std::min(i, number_of_vertices);
 
       MG_ASSERT(acc.CreateEdge(VertexId{primary_label, {PropertyValue(vtx1)}},
                                VertexId{primary_label, {PropertyValue(vtx2)}}, edge_type_id, Gid::FromUint(i))
                     .HasValue(),
                 "Failed on {} and {}", vtx1, vtx2);
     }
-    acc.Commit(GetNextHlc());
-  }
-  // Clean up transactional data
-  storage->CollectGarbage(GetNextHlc().coordinator_wall_clock);
 
-  // Create rest of the objects and leave transactions
-  for (; vertex_count < number_of_vertices; ++vertex_count) {
-    auto acc = storage->Access(GetNextHlc());
-    MG_ASSERT(acc.CreateVertexAndValidate({secondary_label}, PrimaryKey{PropertyValue(vertex_count)},
-                                          {{secondary_property, PropertyValue(vertex_count)}})
-                  .HasValue(),
-              "Failed creating with pk {}", vertex_count);
     acc.Commit(GetNextHlc());
+    if (i == max_transactions_needed - number_of_transactions) {
+      storage->CollectGarbage(GetNextHlc().coordinator_wall_clock);
+    }
   }
 
   for (auto _ : state) {
@@ -173,76 +163,31 @@ BENCHMARK_DEFINE_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertice
 // Range:
 // Number of vertices
 // This run is pessimistic, number of vertices corresponds with number if transactions
-// BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplit)
-//     ->RangeMultiplier(10)
-//     ->Range(100'000, 100'000)
-//     ->Unit(::benchmark::kMillisecond);
+BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplit)
+    ->RangeMultiplier(10)
+    ->Range(100'000, 100'000)
+    ->Unit(::benchmark::kMillisecond);
 
 // Range:
 // Number of vertices
 // This run is optimistic, in this run there are no transactions
-// BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithGc)
-//     ->RangeMultiplier(10)
-//     ->Range(100'000, 1'000'000)
-//     ->Unit(::benchmark::kMillisecond);
+BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithGc)
+    ->RangeMultiplier(10)
+    ->Range(100'000, 1'000'000)
+    ->Unit(::benchmark::kMillisecond);
 
 // Args:
 // Number of vertices
 // Number of edges
 // Number of transaction
-BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)
-    ->Args({100'000, 100'000, 100})
-    ->Args({200'000, 100'000, 100})
-    ->Args({300'000, 100'000, 100})
-    ->Args({400'000, 100'000, 100})
-    ->Args({500'000, 100'000, 100})
-    ->Args({600'000, 100'000, 100})
-    ->Args({700'000, 100'000, 100})
-    ->Args({800'000, 100'000, 100})
-    ->Args({900'000, 100'000, 100})
-    ->Args({1'000'000, 100'000, 100})
-    ->Args({2'000'000, 100'000, 100})
-    ->Args({3'000'000, 100'000, 100})
-    ->Args({4'000'000, 100'000, 100})
-    ->Args({5'000'000, 100'000, 100})
-    ->Args({6'000'000, 100'000, 100})
-    ->Args({7'000'000, 100'000, 100})
-    ->Args({8'000'000, 100'000, 100})
-    ->Args({9'000'000, 100'000, 100})
-    ->Args({10'000'000, 100'000, 100})
-    ->Unit(::benchmark::kMillisecond)
-    ->Name("IncreaseVertices");
-
-BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)
-    ->Args({100'000, 100'000, 100})
-    ->Args({100'000, 200'000, 100})
-    ->Args({100'000, 300'000, 100})
-    ->Args({100'000, 400'000, 100})
-    ->Args({100'000, 500'000, 100})
-    ->Args({100'000, 600'000, 100})
-    ->Args({100'000, 700'000, 100})
-    ->Args({100'000, 800'000, 100})
-    ->Args({100'000, 900'000, 100})
-    ->Args({100'000, 1'000'000, 100})
-    ->Args({100'000, 2'000'000, 100})
-    ->Args({100'000, 3'000'000, 100})
-    ->Args({100'000, 4'000'000, 100})
-    ->Args({100'000, 5'000'000, 100})
-    ->Args({100'000, 6'000'000, 100})
-    ->Args({100'000, 7'000'000, 100})
-    ->Args({100'000, 8'000'000, 100})
-    ->Args({100'000, 9'000'000, 100})
-    ->Args({100'000, 10'000'000, 100})
-    ->Unit(::benchmark::kMillisecond)
-    ->Name("IncreaseEdges");
-
-BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)
-    ->Args({100'000, 100'000, 100})
+BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithFewTransactions)
     ->Args({100'000, 100'000, 1'000})
     ->Args({100'000, 100'000, 10'000})
-    ->Args({100'000, 100'000, 100'000})
-    ->Unit(::benchmark::kMillisecond)
-    ->Name("IncreaseTransactions");
+    ->Args({1'000'000, 100'000, 1'000})
+    ->Args({1'000'000, 100'000, 10'000})
+    ->Args({100'000, 1'000'000, 1'000})
+    ->Args({1'000'000, 1'00'000, 10'000})
+    ->Unit(::benchmark::kMillisecond);
 
 }  // namespace memgraph::benchmark
 

tests/benchmark/storage_v3_split_1.cpp

@@ -1,270 +0,0 @@
-// Copyright 2023 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include <cstdint>
-#include <optional>
-#include <vector>
-
-#include <benchmark/benchmark.h>
-#include <gflags/gflags.h>
-
-#include "storage/v3/id_types.hpp"
-#include "storage/v3/key_store.hpp"
-#include "storage/v3/property_value.hpp"
-#include "storage/v3/shard.hpp"
-#include "storage/v3/vertex.hpp"
-#include "storage/v3/vertex_id.hpp"
-
-namespace memgraph::benchmark {
-
-class ShardSplitBenchmark : public ::benchmark::Fixture {
- protected:
-  using PrimaryKey = storage::v3::PrimaryKey;
-  using PropertyId = storage::v3::PropertyId;
-  using PropertyValue = storage::v3::PropertyValue;
-  using LabelId = storage::v3::LabelId;
-  using EdgeTypeId = storage::v3::EdgeTypeId;
-  using Shard = storage::v3::Shard;
-  using VertexId = storage::v3::VertexId;
-  using Gid = storage::v3::Gid;
-
-  void SetUp(const ::benchmark::State &state) override {
-    storage.emplace(primary_label, min_pk, std::nullopt, schema_property_vector);
-    storage->StoreMapping(
-        {{1, "label"}, {2, "property"}, {3, "edge_property"}, {4, "secondary_label"}, {5, "secondary_prop"}});
-  }
-
-  void TearDown(const ::benchmark::State &) override { storage = std::nullopt; }
-
-  const PropertyId primary_property{PropertyId::FromUint(2)};
-  const PropertyId secondary_property{PropertyId::FromUint(5)};
-  std::vector<storage::v3::SchemaProperty> schema_property_vector = {
-      storage::v3::SchemaProperty{primary_property, common::SchemaType::INT}};
-  const std::vector<PropertyValue> min_pk{PropertyValue{0}};
-  const LabelId primary_label{LabelId::FromUint(1)};
-  const LabelId secondary_label{LabelId::FromUint(4)};
-  const EdgeTypeId edge_type_id{EdgeTypeId::FromUint(3)};
-  std::optional<Shard> storage;
-
-  coordinator::Hlc last_hlc{0, io::Time{}};
-
-  coordinator::Hlc GetNextHlc() {
-    ++last_hlc.logical_id;
-    last_hlc.coordinator_wall_clock += std::chrono::seconds(1);
-    return last_hlc;
-  }
-};
-
-BENCHMARK_DEFINE_F(ShardSplitBenchmark, BigDataSplit)(::benchmark::State &state) {
-  const auto number_of_vertices{state.range(0)};
-  std::random_device r;
-  std::default_random_engine e1(r());
-  std::uniform_int_distribution<int> uniform_dist(0, number_of_vertices);
-
-  for (int64_t i{0}; i < number_of_vertices; ++i) {
-    auto acc = storage->Access(GetNextHlc());
-    MG_ASSERT(acc.CreateVertexAndValidate({secondary_label}, PrimaryKey{PropertyValue(i)},
-                                          {{secondary_property, PropertyValue(i)}})
-                  .HasValue(),
-              "Failed creating with pk {}", i);
-    if (i > 1) {
-      const auto vtx1 = uniform_dist(e1) % i;
-      const auto vtx2 = uniform_dist(e1) % i;
-
-      MG_ASSERT(acc.CreateEdge(VertexId{primary_label, {PropertyValue(vtx1)}},
-                               VertexId{primary_label, {PropertyValue(vtx2)}}, edge_type_id, Gid::FromUint(i))
-                    .HasValue(),
-                "Failed on {} and {}", vtx1, vtx2);
-    }
-    acc.Commit(GetNextHlc());
-  }
-  for (auto _ : state) {
-    auto data = storage->PerformSplit(PrimaryKey{PropertyValue{number_of_vertices / 2}}, 2);
-  }
-}
-
-BENCHMARK_DEFINE_F(ShardSplitBenchmark, BigDataSplitWithGc)(::benchmark::State &state) {
-  const auto number_of_vertices{state.range(0)};
-  std::random_device r;
-  std::default_random_engine e1(r());
-  std::uniform_int_distribution<int> uniform_dist(0, number_of_vertices);
-
-  for (int64_t i{0}; i < number_of_vertices; ++i) {
-    auto acc = storage->Access(GetNextHlc());
-    MG_ASSERT(acc.CreateVertexAndValidate({secondary_label}, PrimaryKey{PropertyValue(i)},
-                                          {{secondary_property, PropertyValue(i)}})
-                  .HasValue(),
-              "Failed creating with pk {}", i);
-    if (i > 1) {
-      const auto vtx1 = uniform_dist(e1) % i;
-      const auto vtx2 = uniform_dist(e1) % i;
-
-      MG_ASSERT(acc.CreateEdge(VertexId{primary_label, {PropertyValue(vtx1)}},
-                               VertexId{primary_label, {PropertyValue(vtx2)}}, edge_type_id, Gid::FromUint(i))
-                    .HasValue(),
-                "Failed on {} and {}", vtx1, vtx2);
-    }
-    acc.Commit(GetNextHlc());
-  }
-  storage->CollectGarbage(GetNextHlc().coordinator_wall_clock);
-  for (auto _ : state) {
-    auto data = storage->PerformSplit(PrimaryKey{PropertyValue{number_of_vertices / 2}}, 2);
-  }
-}
-
-BENCHMARK_DEFINE_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)(::benchmark::State &state) {
-  const auto number_of_vertices = state.range(0);
-  const auto number_of_edges = state.range(1);
-  const auto number_of_transactions = state.range(2);
-  std::random_device r;
-  std::default_random_engine e1(r());
-  std::uniform_int_distribution<int> uniform_dist(0, number_of_vertices - number_of_transactions - 1);
-
-  // Create Vertices
-  int64_t vertex_count{0};
-  {
-    auto acc = storage->Access(GetNextHlc());
-    for (; vertex_count < number_of_vertices - number_of_transactions; ++vertex_count) {
-      MG_ASSERT(acc.CreateVertexAndValidate({secondary_label}, PrimaryKey{PropertyValue(vertex_count)},
-                                            {{secondary_property, PropertyValue(vertex_count)}})
-                    .HasValue(),
-                "Failed creating with pk {}", vertex_count);
-    }
-
-    // Create Edges
-    for (int64_t i{0}; i < number_of_edges; ++i) {
-      const auto vtx1 = uniform_dist(e1);
-      const auto vtx2 = uniform_dist(e1);
-
-      MG_ASSERT(acc.CreateEdge(VertexId{primary_label, {PropertyValue(vtx1)}},
-                               VertexId{primary_label, {PropertyValue(vtx2)}}, edge_type_id, Gid::FromUint(i))
-                    .HasValue(),
-                "Failed on {} and {}", vtx1, vtx2);
-    }
-    acc.Commit(GetNextHlc());
-  }
-  // Clean up transactional data
-  storage->CollectGarbage(GetNextHlc().coordinator_wall_clock);
-
-  // Create rest of the objects and leave transactions
-  for (; vertex_count < number_of_vertices; ++vertex_count) {
-    auto acc = storage->Access(GetNextHlc());
-    MG_ASSERT(acc.CreateVertexAndValidate({secondary_label}, PrimaryKey{PropertyValue(vertex_count)},
-                                          {{secondary_property, PropertyValue(vertex_count)}})
-                  .HasValue(),
-              "Failed creating with pk {}", vertex_count);
-    acc.Commit(GetNextHlc());
-  }
-
-  for (auto _ : state) {
-    // Don't create shard since shard deallocation can take some time as well
-    auto data = storage->PerformSplit(PrimaryKey{PropertyValue{number_of_vertices / 2}}, 2);
-  }
-}
-
-// Range:
-// Number of vertices
-// This run is pessimistic, number of vertices corresponds with number if transactions
-// BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplit)
-//     ->RangeMultiplier(10)
-//     ->Range(100'000, 100'000)
-//     ->Unit(::benchmark::kMillisecond);
-
-// Range:
-// Number of vertices
-// This run is optimistic, in this run there are no transactions
-// BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithGc)
-//     ->RangeMultiplier(10)
-//     ->Range(100'000, 1'000'000)
-//     ->Unit(::benchmark::kMillisecond);
-
-// Args:
-// Number of vertices
-// Number of edges
-// Number of transaction
-BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)
-    // ->Args({100'000, 100'000, 100})
-    // ->Args({200'000, 100'000, 100})
-    // ->Args({300'000, 100'000, 100})
-    // ->Args({400'000, 100'000, 100})
-    // ->Args({500'000, 100'000, 100})
-    // ->Args({600'000, 100'000, 100})
-    // ->Args({700'000, 100'000, 100})
-    // ->Args({800'000, 100'000, 100})
-    ->Args({900'000, 100'000, 100})
-    // ->Args({1'000'000, 100'000, 100})
-    // ->Args({2'000'000, 100'000, 100})
-    // ->Args({3'000'000, 100'000, 100})
-    // ->Args({4'000'000, 100'000, 100})
-    // ->Args({6'000'000, 100'000, 100})
-    // ->Args({7'000'000, 100'000, 100})
-    // ->Args({8'000'000, 100'000, 100})
-    // ->Args({9'000'000, 100'000, 100})
-    // ->Args({10'000'000, 100'000, 100})
-    ->Unit(::benchmark::kMillisecond)
-    ->Name("IncreaseVertices");
-
-// BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)
-// ->Args({100'000, 100'000, 100})
-// ->Args({200'000, 100'000, 100})
-// ->Args({300'000, 100'000, 100})
-// ->Args({400'000, 100'000, 100})
-// ->Args({500'000, 100'000, 100})
-// ->Args({600'000, 100'000, 100})
-// ->Args({700'000, 100'000, 100})
-// ->Args({800'000, 100'000, 100})
-// ->Args({900'000, 100'000, 100})
-// ->Args({1'000'000, 100'000, 100})
-// ->Args({2'000'000, 100'000, 100})
-// ->Args({3'000'000, 100'000, 100})
-// ->Args({4'000'000, 100'000, 100})
-// ->Args({6'000'000, 100'000, 100})
-// ->Args({7'000'000, 100'000, 100})
-// ->Args({8'000'000, 100'000, 100})
-// ->Args({9'000'000, 100'000, 100})
-// ->Args({10'000'000, 100'000, 100})
-// ->Unit(::benchmark::kMillisecond)
-// ->Name("IncreaseVertices");
-
-// BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)
-//     ->Args({100'000, 100'000, 100})
-//     ->Args({100'000, 200'000, 100})
-//     ->Args({100'000, 300'000, 100})
-//     ->Args({100'000, 400'000, 100})
-//     ->Args({100'000, 500'000, 100})
-//     ->Args({100'000, 600'000, 100})
-//     ->Args({100'000, 700'000, 100})
-//     ->Args({100'000, 800'000, 100})
-//     ->Args({100'000, 900'000, 100})
-//     ->Args({100'000, 1'000'000, 100})
-//     ->Args({100'000, 2'000'000, 100})
-//     ->Args({100'000, 3'000'000, 100})
-//     ->Args({100'000, 4'000'000, 100})
-//     ->Args({100'000, 5'000'000, 100})
-//     ->Args({100'000, 6'000'000, 100})
-//     ->Args({100'000, 7'000'000, 100})
-//     ->Args({100'000, 8'000'000, 100})
-//     ->Args({100'000, 9'000'000, 100})
-//     ->Args({100'000, 10'000'000, 100})
-//     ->Unit(::benchmark::kMillisecond)
-//     ->Name("IncreaseEdges");
-
-// BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)
-//     ->Args({100'000, 100'000, 100})
-//     ->Args({100'000, 100'000, 1'000})
-//     ->Args({100'000, 100'000, 10'000})
-//     ->Args({100'000, 100'000, 100'000})
-//     ->Unit(::benchmark::kMillisecond)
-//     ->Name("IncreaseTransactions");
-
-}  // namespace memgraph::benchmark
-
-BENCHMARK_MAIN();

tests/benchmark/storage_v3_split_2.cpp

@@ -1,270 +0,0 @@
-// Copyright 2023 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include <cstdint>
-#include <optional>
-#include <vector>
-
-#include <benchmark/benchmark.h>
-#include <gflags/gflags.h>
-
-#include "storage/v3/id_types.hpp"
-#include "storage/v3/key_store.hpp"
-#include "storage/v3/property_value.hpp"
-#include "storage/v3/shard.hpp"
-#include "storage/v3/vertex.hpp"
-#include "storage/v3/vertex_id.hpp"
-
-namespace memgraph::benchmark {
-
-class ShardSplitBenchmark : public ::benchmark::Fixture {
- protected:
-  using PrimaryKey = storage::v3::PrimaryKey;
-  using PropertyId = storage::v3::PropertyId;
-  using PropertyValue = storage::v3::PropertyValue;
-  using LabelId = storage::v3::LabelId;
-  using EdgeTypeId = storage::v3::EdgeTypeId;
-  using Shard = storage::v3::Shard;
-  using VertexId = storage::v3::VertexId;
-  using Gid = storage::v3::Gid;
-
-  void SetUp(const ::benchmark::State &state) override {
-    storage.emplace(primary_label, min_pk, std::nullopt, schema_property_vector);
-    storage->StoreMapping(
-        {{1, "label"}, {2, "property"}, {3, "edge_property"}, {4, "secondary_label"}, {5, "secondary_prop"}});
-  }
-
-  void TearDown(const ::benchmark::State &) override { storage = std::nullopt; }
-
-  const PropertyId primary_property{PropertyId::FromUint(2)};
-  const PropertyId secondary_property{PropertyId::FromUint(5)};
-  std::vector<storage::v3::SchemaProperty> schema_property_vector = {
-      storage::v3::SchemaProperty{primary_property, common::SchemaType::INT}};
-  const std::vector<PropertyValue> min_pk{PropertyValue{0}};
-  const LabelId primary_label{LabelId::FromUint(1)};
-  const LabelId secondary_label{LabelId::FromUint(4)};
-  const EdgeTypeId edge_type_id{EdgeTypeId::FromUint(3)};
-  std::optional<Shard> storage;
-
-  coordinator::Hlc last_hlc{0, io::Time{}};
-
-  coordinator::Hlc GetNextHlc() {
-    ++last_hlc.logical_id;
-    last_hlc.coordinator_wall_clock += std::chrono::seconds(1);
-    return last_hlc;
-  }
-};
-
-BENCHMARK_DEFINE_F(ShardSplitBenchmark, BigDataSplit)(::benchmark::State &state) {
-  const auto number_of_vertices{state.range(0)};
-  std::random_device r;
-  std::default_random_engine e1(r());
-  std::uniform_int_distribution<int> uniform_dist(0, number_of_vertices);
-
-  for (int64_t i{0}; i < number_of_vertices; ++i) {
-    auto acc = storage->Access(GetNextHlc());
-    MG_ASSERT(acc.CreateVertexAndValidate({secondary_label}, PrimaryKey{PropertyValue(i)},
-                                          {{secondary_property, PropertyValue(i)}})
-                  .HasValue(),
-              "Failed creating with pk {}", i);
-    if (i > 1) {
-      const auto vtx1 = uniform_dist(e1) % i;
-      const auto vtx2 = uniform_dist(e1) % i;
-
-      MG_ASSERT(acc.CreateEdge(VertexId{primary_label, {PropertyValue(vtx1)}},
-                               VertexId{primary_label, {PropertyValue(vtx2)}}, edge_type_id, Gid::FromUint(i))
-                    .HasValue(),
-                "Failed on {} and {}", vtx1, vtx2);
-    }
-    acc.Commit(GetNextHlc());
-  }
-  for (auto _ : state) {
-    auto data = storage->PerformSplit(PrimaryKey{PropertyValue{number_of_vertices / 2}}, 2);
-  }
-}
-
-BENCHMARK_DEFINE_F(ShardSplitBenchmark, BigDataSplitWithGc)(::benchmark::State &state) {
-  const auto number_of_vertices{state.range(0)};
-  std::random_device r;
-  std::default_random_engine e1(r());
-  std::uniform_int_distribution<int> uniform_dist(0, number_of_vertices);
-
-  for (int64_t i{0}; i < number_of_vertices; ++i) {
-    auto acc = storage->Access(GetNextHlc());
-    MG_ASSERT(acc.CreateVertexAndValidate({secondary_label}, PrimaryKey{PropertyValue(i)},
-                                          {{secondary_property, PropertyValue(i)}})
-                  .HasValue(),
-              "Failed creating with pk {}", i);
-    if (i > 1) {
-      const auto vtx1 = uniform_dist(e1) % i;
-      const auto vtx2 = uniform_dist(e1) % i;
-
-      MG_ASSERT(acc.CreateEdge(VertexId{primary_label, {PropertyValue(vtx1)}},
-                               VertexId{primary_label, {PropertyValue(vtx2)}}, edge_type_id, Gid::FromUint(i))
-                    .HasValue(),
-                "Failed on {} and {}", vtx1, vtx2);
-    }
-    acc.Commit(GetNextHlc());
-  }
-  storage->CollectGarbage(GetNextHlc().coordinator_wall_clock);
-  for (auto _ : state) {
-    auto data = storage->PerformSplit(PrimaryKey{PropertyValue{number_of_vertices / 2}}, 2);
-  }
-}
-
-BENCHMARK_DEFINE_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)(::benchmark::State &state) {
-  const auto number_of_vertices = state.range(0);
-  const auto number_of_edges = state.range(1);
-  const auto number_of_transactions = state.range(2);
-  std::random_device r;
-  std::default_random_engine e1(r());
-  std::uniform_int_distribution<int> uniform_dist(0, number_of_vertices - number_of_transactions - 1);
-
-  // Create Vertices
-  int64_t vertex_count{0};
-  {
-    auto acc = storage->Access(GetNextHlc());
-    for (; vertex_count < number_of_vertices - number_of_transactions; ++vertex_count) {
-      MG_ASSERT(acc.CreateVertexAndValidate({secondary_label}, PrimaryKey{PropertyValue(vertex_count)},
-                                            {{secondary_property, PropertyValue(vertex_count)}})
-                    .HasValue(),
-                "Failed creating with pk {}", vertex_count);
-    }
-
-    // Create Edges
-    for (int64_t i{0}; i < number_of_edges; ++i) {
-      const auto vtx1 = uniform_dist(e1);
-      const auto vtx2 = uniform_dist(e1);
-
-      MG_ASSERT(acc.CreateEdge(VertexId{primary_label, {PropertyValue(vtx1)}},
-                               VertexId{primary_label, {PropertyValue(vtx2)}}, edge_type_id, Gid::FromUint(i))
-                    .HasValue(),
-                "Failed on {} and {}", vtx1, vtx2);
-    }
-    acc.Commit(GetNextHlc());
-  }
-  // Clean up transactional data
-  storage->CollectGarbage(GetNextHlc().coordinator_wall_clock);
-
-  // Create rest of the objects and leave transactions
-  for (; vertex_count < number_of_vertices; ++vertex_count) {
-    auto acc = storage->Access(GetNextHlc());
-    MG_ASSERT(acc.CreateVertexAndValidate({secondary_label}, PrimaryKey{PropertyValue(vertex_count)},
-                                          {{secondary_property, PropertyValue(vertex_count)}})
-                  .HasValue(),
-              "Failed creating with pk {}", vertex_count);
-    acc.Commit(GetNextHlc());
-  }
-
-  for (auto _ : state) {
-    // Don't create shard since shard deallocation can take some time as well
-    auto data = storage->PerformSplit(PrimaryKey{PropertyValue{number_of_vertices / 2}}, 2);
-  }
-}
-
-// Range:
-// Number of vertices
-// This run is pessimistic, number of vertices corresponds with number if transactions
-// BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplit)
-//     ->RangeMultiplier(10)
-//     ->Range(100'000, 100'000)
-//     ->Unit(::benchmark::kMillisecond);
-
-// Range:
-// Number of vertices
-// This run is optimistic, in this run there are no transactions
-// BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithGc)
-//     ->RangeMultiplier(10)
-//     ->Range(100'000, 1'000'000)
-//     ->Unit(::benchmark::kMillisecond);
-
-// Args:
-// Number of vertices
-// Number of edges
-// Number of transaction
-BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)
-    // ->Args({100'000, 100'000, 100})
-    // ->Args({200'000, 100'000, 100})
-    // ->Args({300'000, 100'000, 100})
-    // ->Args({400'000, 100'000, 100})
-    // ->Args({500'000, 100'000, 100})
-    // ->Args({600'000, 100'000, 100})
-    // ->Args({700'000, 100'000, 100})
-    // ->Args({800'000, 100'000, 100})
-    // ->Args({900'000, 100'000, 100})
-    ->Args({1'000'000, 100'000, 100})
-    // ->Args({2'000'000, 100'000, 100})
-    // ->Args({3'000'000, 100'000, 100})
-    // ->Args({4'000'000, 100'000, 100})
-    // ->Args({6'000'000, 100'000, 100})
-    // ->Args({7'000'000, 100'000, 100})
-    // ->Args({8'000'000, 100'000, 100})
-    // ->Args({9'000'000, 100'000, 100})
-    // ->Args({10'000'000, 100'000, 100})
-    ->Unit(::benchmark::kMillisecond)
-    ->Name("IncreaseVertices");
-
-// BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)
-//     ->Args({100'000, 100'000, 100})
-//     ->Args({200'000, 100'000, 100})
-//     ->Args({300'000, 100'000, 100})
-//     ->Args({400'000, 100'000, 100})
-//     ->Args({500'000, 100'000, 100})
-//     ->Args({600'000, 100'000, 100})
-//     ->Args({700'000, 100'000, 100})
-//     ->Args({800'000, 100'000, 100})
-//     ->Args({900'000, 100'000, 100})
-//     ->Args({1'000'000, 100'000, 100})
-//     ->Args({2'000'000, 100'000, 100})
-//     ->Args({3'000'000, 100'000, 100})
-//     ->Args({4'000'000, 100'000, 100})
-//     ->Args({6'000'000, 100'000, 100})
-//     ->Args({7'000'000, 100'000, 100})
-//     ->Args({8'000'000, 100'000, 100})
-//     ->Args({9'000'000, 100'000, 100})
-//     ->Args({10'000'000, 100'000, 100})
-//     ->Unit(::benchmark::kMillisecond)
-//     ->Name("IncreaseVertices");
-
-// BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)
-//     ->Args({100'000, 100'000, 100})
-//     ->Args({100'000, 200'000, 100})
-//     ->Args({100'000, 300'000, 100})
-//     ->Args({100'000, 400'000, 100})
-//     ->Args({100'000, 500'000, 100})
-//     ->Args({100'000, 600'000, 100})
-//     ->Args({100'000, 700'000, 100})
-//     ->Args({100'000, 800'000, 100})
-//     ->Args({100'000, 900'000, 100})
-//     ->Args({100'000, 1'000'000, 100})
-//     ->Args({100'000, 2'000'000, 100})
-//     ->Args({100'000, 3'000'000, 100})
-//     ->Args({100'000, 4'000'000, 100})
-//     ->Args({100'000, 5'000'000, 100})
-//     ->Args({100'000, 6'000'000, 100})
-//     ->Args({100'000, 7'000'000, 100})
-//     ->Args({100'000, 8'000'000, 100})
-//     ->Args({100'000, 9'000'000, 100})
-//     ->Args({100'000, 10'000'000, 100})
-//     ->Unit(::benchmark::kMillisecond)
-//     ->Name("IncreaseEdges");
-
-// BENCHMARK_REGISTER_F(ShardSplitBenchmark, BigDataSplitWithFewTransactionsOnVertices)
-//     ->Args({100'000, 100'000, 100})
-//     ->Args({100'000, 100'000, 1'000})
-//     ->Args({100'000, 100'000, 10'000})
-//     ->Args({100'000, 100'000, 100'000})
-//     ->Unit(::benchmark::kMillisecond)
-//     ->Name("IncreaseTransactions");
-
-}  // namespace memgraph::benchmark
-
-BENCHMARK_MAIN();

tests/e2e/distributed_queries/awesome_memgraph_functions.py

@@ -36,9 +36,7 @@ def test_awesome_memgraph_functions(connection):
     assert len(results) == 1
     assert results[0][0] == 5
 
-    results = execute_and_fetch_all(
-        cursor, "UNWIND [2, 1, 3] AS value WITH COLLECT(value) as nn RETURN ALL(i IN nn WHERE i > 0)"
-    )
+    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
 

tests/e2e/distributed_queries/distinct.py

@@ -9,13 +9,11 @@
 # by the Apache License, Version 2.0, included in the file
 # licenses/APL.txt.
 
-import sys
-import time
 import typing
-
 import mgclient
+import sys
 import pytest
-
+import time
 from common import *
 
 
@@ -32,7 +30,8 @@ def test_distinct(connection):
     assert len(results) == 2
     for i, n in enumerate(results):
         n_props = n[0].properties
-        assert len(n_props) == 0
+        assert len(n_props) == 1
+        assert n_props["property"] == i
 
 
 if __name__ == "__main__":

tests/e2e/distributed_queries/distributed_expand_one.py

@@ -13,12 +13,7 @@ import sys
 
 import pytest
 
-from common import (
-    connection,
-    execute_and_fetch_all,
-    has_n_result_row,
-    wait_for_shard_manager_to_initialize,
-)
+from common import connection, execute_and_fetch_all, has_n_result_row, wait_for_shard_manager_to_initialize
 
 
 def test_sequenced_expand_one(connection):
@@ -27,21 +22,15 @@ def test_sequenced_expand_one(connection):
 
     for i in range(1, 4):
         assert has_n_result_row(cursor, f"CREATE (:label {{property:{i}}})", 0), f"Failed creating node"
-    assert has_n_result_row(cursor, "MATCH (n:label {property:1}), (m:label {property:2}) CREATE (n)-[:TO]->(m)", 0)
-    assert has_n_result_row(cursor, "MATCH (n:label {property:2}), (m:label {property:3}) CREATE (n)-[:TO]->(m)", 0)
+    assert has_n_result_row(cursor, "MATCH (n {property:1}), (m {property:2}) CREATE (n)-[:TO]->(m)", 0)
+    assert has_n_result_row(cursor, "MATCH (n {property:2}), (m {property:3}) CREATE (n)-[:TO]->(m)", 0)
 
     results = execute_and_fetch_all(cursor, "MATCH (n)-[:TO]->(m)-[:TO]->(l) RETURN n,m,l")
     assert len(results) == 1
     n, m, l = results[0]
-    assert (
-        len(n.properties) == 0
-    ), "we don't return any properties of the node received from expansion and the bolt layer doesn't serialize the primary key of vertices"
-    assert (
-        len(m.properties) == 0
-    ), "we don't return any properties of the node received from expansion and the bolt layer doesn't serialize the primary key of vertices"
-    assert (
-        len(l.properties) == 0
-    ), "we don't return any properties of the node received from expansion and the bolt layer doesn't serialize the primary key of vertices"
+    assert n.properties["property"] == 1
+    assert m.properties["property"] == 2
+    assert l.properties["property"] == 3
 
 
 if __name__ == "__main__":

tests/e2e/distributed_queries/distributed_queries.py

@@ -9,13 +9,11 @@
 # by the Apache License, Version 2.0, included in the file
 # licenses/APL.txt.
 
-import sys
-import time
 import typing
-
 import mgclient
+import sys
 import pytest
-
+import time
 from common import *
 
 
@@ -37,13 +35,13 @@ def test_vertex_creation_and_scanall(connection):
     assert len(results) == 9
     for (n, r, m) in results:
         n_props = n.properties
-        assert len(n_props) == 0, "n is not expected to have properties, update the test!"
+        assert len(n_props) == 1, "n is not expected to have properties, update the test!"
         assert len(n.labels) == 0, "n is not expected to have labels, update the test!"
 
         assert r.type == "TO"
 
         m_props = m.properties
-        assert len(m_props) == 0, "n is not expected to have properties, update the test!"
+        assert m_props["property"] <= 3 and m_props["property"] >= 0, "Wrong key"
         assert len(m.labels) == 0, "m is not expected to have labels, update the test!"
 
 

tests/e2e/distributed_queries/order_by_and_limit.py

@@ -9,13 +9,11 @@
 # by the Apache License, Version 2.0, included in the file
 # licenses/APL.txt.
 
-import sys
-import time
 import typing
-
 import mgclient
+import sys
 import pytest
-
+import time
 from common import *
 
 
@@ -23,23 +21,23 @@ def test_order_by_and_limit(connection):
     wait_for_shard_manager_to_initialize()
     cursor = connection.cursor()
 
-    results = execute_and_fetch_all(
-        cursor,
-        "UNWIND [{property:1}, {property:3}, {property:2}] AS map RETURN map ORDER BY map.property DESC",
-    )
-    assert len(results) == 3
-    i = 3
-    for map in results:
-        assert len(map) == 1
-        assert map[0]["property"] == i
+    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)
+
+    results = execute_and_fetch_all(cursor, "MATCH (n) RETURN n ORDER BY n.property DESC")
+    assert len(results) == 4
+    i = 4
+    for n in results:
+        n_props = n[0].properties
+        assert len(n_props) == 1
+        assert n_props["property"] == i
         i = i - 1
 
-    result = execute_and_fetch_all(
-        cursor,
-        "UNWIND [{property:1}, {property:3}, {property:2}] AS map RETURN map ORDER BY map.property LIMIT 1",
-    )
+    result = execute_and_fetch_all(cursor, "MATCH (n) RETURN n ORDER BY n.property LIMIT 1")
     assert len(result) == 1
-    assert result[0][0]["property"] == 1
+    assert result[0][0].properties["property"] == 1
 
 
 if __name__ == "__main__":

tests/manual/CMakeLists.txt

@@ -9,7 +9,6 @@ function(add_manual_test test_cpp)
   get_filename_component(exec_name ${test_cpp} NAME_WE)
   set(target_name ${test_prefix}${exec_name})
   add_executable(${target_name} ${test_cpp} ${ARGN})
-
   # OUTPUT_NAME sets the real name of a target when it is built and can be
   # used to help create two targets of the same name even though CMake
   # requires unique logical target names
@@ -22,7 +21,7 @@ target_link_libraries(${test_prefix}antlr_parser antlr_opencypher_parser_lib)
 
 add_manual_test(antlr_sigsegv.cpp)
 target_link_libraries(${test_prefix}antlr_sigsegv gtest gtest_main
-  antlr_opencypher_parser_lib mg-utils)
+                      antlr_opencypher_parser_lib mg-utils)
 
 add_manual_test(antlr_tree_pretty_print.cpp)
 target_link_libraries(${test_prefix}antlr_tree_pretty_print antlr_opencypher_parser_lib)
@@ -38,15 +37,13 @@ target_link_libraries(${test_prefix}query_hash mg-query)
 
 add_manual_test(query_planner.cpp interactive/planning.cpp)
 target_link_libraries(${test_prefix}query_planner mg-query)
-
-if(READLINE_FOUND)
+if (READLINE_FOUND)
   target_link_libraries(${test_prefix}query_planner readline)
 endif()
 
 add_manual_test(query_execution_dummy.cpp)
 target_link_libraries(${test_prefix}query_execution_dummy mg-query)
-
-if(READLINE_FOUND)
+if (READLINE_FOUND)
   target_link_libraries(${test_prefix}query_execution_dummy readline)
 endif()
 
@@ -64,6 +61,3 @@ target_link_libraries(${test_prefix}ssl_client mg-communication)
 
 add_manual_test(ssl_server.cpp)
 target_link_libraries(${test_prefix}ssl_server mg-communication)
-
-add_manual_test(query_performance.cpp)
-target_link_libraries(${test_prefix}query_performance mg-communication mg-utils mg-io mg-io-simulator mg-coordinator mg-query-v2 mg-storage-v3 mg-query mg-storage-v2)

tests/manual/query_performance.cpp

@@ -1,352 +0,0 @@
-// Copyright 2023 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-// This binary is meant to easily compare the performance of:
-//  - Memgraph v2
-//  - Memgraph v3
-//  - Memgraph v3 with MultiFrame
-// This binary measures three things which provides a high level and easily understandable metric about the performance
-// difference between the different versions:
-//  1. Read time: how much time does it take to read the files:
-//  2. Init time: how much time does it take to run the init queries, including the index creation. For details please
-//     check RunV2.
-//  3. Benchmark time: how much time does it take to run the benchmark queries.
-// To quickly compare performance of the different versions just change the query or queries in the benchmark queries
-// file you can see the different by running this executable. This way we don't have keep multiple binaries of Memgraph
-// v2 and Memgraph v3 with/without MultiFrame, start Memgraph and connect to it with mgconsole and other hassles. As
-// everything is run in this binary, it makes easier to generate perf reports/flamegraphs from the query execution of
-// different Memgraph versions compared to using the full blown version of Memgraph.
-//
-// A few important notes:
-//  - All the input files are mandated to have an empty line at the end of the file as the reading logic expect that.
-//  - tests/mgbench/dataset_creator_unwind.py is recommended to generate the dataset because it generates queries with
-//    UNWIND that makes the import faster in Memgraph v3, thus we can compare the performance on non trivial datasets
-//    also. To make it possible to use the generated dataset, you have to move the generated index queries into a
-//    separate file that can be supplied as index queries file for this binary when using Memgraph v2. The reason for
-//    this is Memgraph v3 cannot handle indices yet, thus it crashes.
-//  - Check the command line flags and their description defined in this file.
-//  - Also check out the --default-multi-frame-size command line flag if you want to play with that.
-//  - The log level is manually set to warning in the main function to avoid the overwhelming log messages from Memgraph
-//    v3. Apart from ease of use, the huge amount of looging can degrade the actual performance.
-//
-// Example usage with Memgraph v2:
-// ./query_performance
-//   --index-queries-file indices.cypher
-//   --init-queries-file dataset.cypher
-//   --benchmark-queries-files expand.cypher,match.cypyher
-//   --use-v3=false
-//
-// Example usage with Memgraph v3 without MultiFrame:
-// ./query_performance
-//   --split-file split_file
-//   --init-queries-file dataset.cypher
-//   --benchmark-queries-files expand.cypher,match.cypyher
-//   --use-v3=true
-//   --use-multi-frame=false
-//
-// Example usage with Memgraph v3 with MultiFrame:
-// ./query_performance
-//   --split-file split_file
-//   --init-queries-file dataset.cypher
-//   --benchmark-queries-files expand.cypher,match.cypyher
-//   --use-v3=true
-//   --use-multi-frame=true
-//
-// The examples are using only the necessary flags, however specifying all of them is not a problem, so if you specify
-// --index-queries-file for Memgraph v3, then it will be safely ignored just as --split-file for Memgraph v2.
-//
-// To generate flamegraph you can use the following command:
-// flamegraph --cmd "record -F 997 --call-graph fp -g" --root -o flamegraph.svg -- ./query_performance <flags>
-// Using the default option (dwarf) for --call-graph when calling perf might result in too long runtine of flamegraph
-// because of address resolution. See https://github.com/flamegraph-rs/flamegraph/issues/74.
-
-#include <chrono>
-#include <filesystem>
-#include <fstream>
-#include <istream>
-#include <thread>
-
-#include <fmt/core.h>
-#include <gflags/gflags.h>
-#include <spdlog/cfg/env.h>
-#include <spdlog/spdlog.h>
-#include <json/json.hpp>
-
-// v3 includes
-#include "io/address.hpp"
-#include "io/local_transport/local_system.hpp"
-#include "io/message_histogram_collector.hpp"
-#include "machine_manager/machine_manager.hpp"
-#include "query/discard_value_stream.hpp"
-#include "query/v2/discard_value_stream.hpp"
-#include "query/v2/interpreter.hpp"
-#include "query/v2/request_router.hpp"
-
-// v2 includes
-#include "query/interpreter.hpp"
-#include "storage/v2/storage.hpp"
-
-// common includes
-#include "utils/string.hpp"
-
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_string(index_queries_file, "",
-              "Path to the file which contains the queries to create indices. Used only for v2. Must contain an empty "
-              "line at the end of the file after the queries.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_string(split_file, "",
-              "Path to the split file which contains the predefined labels, properties, edge types and shard-ranges. "
-              "Used only for v3. Must contain an empty line at the end of the file.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_string(init_queries_file, "",
-              "Path to the file that is used to insert the initial dataset, one query per line. Must contain an empty "
-              "line at the end of the file after the queries.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_string(benchmark_queries_files, "",
-              "Comma separated paths to the files that contain the queries that we want to compare, one query per "
-              "line. Must contain an empty line at the end of each file after the queries.");
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-DEFINE_bool(use_v3, true, "If set to true, then Memgraph v3 will be used, otherwise Memgraph v2 will be used.");
-
-DEFINE_string(export_json_results, "", "If not empty, then the results will be exported as a json file.");
-
-DEFINE_string(data_directory, "mg_data", "Path to directory to use as storage directory for Memgraph v2.");
-
-namespace memgraph::tests::manual {
-
-template <typename TInterpreterContext>
-struct DependantTypes {};
-
-template <>
-struct DependantTypes<query::InterpreterContext> {
-  using Interpreter = query::Interpreter;
-  using DiscardValueResultStream = query::DiscardValueResultStream;
-};
-
-template <>
-struct DependantTypes<query::v2::InterpreterContext> {
-  using Interpreter = query::v2::Interpreter;
-  using DiscardValueResultStream = query::v2::DiscardValueResultStream;
-};
-
-template <typename TRep, typename TPeriod>
-void PutResult(nlohmann::json &json, const std::string_view name, std::chrono::duration<TRep, TPeriod> duration) {
-  json[name] = std::chrono::duration_cast<std::chrono::microseconds>(duration).count();
-}
-
-template <typename TInterpreterContext>
-using Interpreter = typename DependantTypes<TInterpreterContext>::Interpreter;
-
-template <typename TInterpreterContext>
-using DiscardValueResultStream = typename DependantTypes<TInterpreterContext>::DiscardValueResultStream;
-
-template <typename TInterpreterContext>
-void RunQueries(TInterpreterContext &interpreter_context, const std::vector<std::string> &queries) {
-  Interpreter<TInterpreterContext> interpreter{&interpreter_context};
-  DiscardValueResultStream<TInterpreterContext> stream;
-
-  for (const auto &query : queries) {
-    auto result = interpreter.Prepare(query, {}, nullptr);
-    interpreter.Pull(&stream, std::nullopt, result.qid);
-  }
-}
-
-template <typename TInterpreterContext>
-void RunInitQueries(TInterpreterContext &interpreter_context, const std::vector<std::string> &init_queries) {
-  RunQueries(interpreter_context, init_queries);
-}
-
-template <typename TInterpreterContext>
-void RunBenchmarkQueries(TInterpreterContext &interpreter_context, const std::vector<std::string> &benchmark_queries) {
-  RunQueries(interpreter_context, benchmark_queries);
-}
-
-std::vector<std::string> ReadQueries(const std::string &file_name) {
-  std::vector<std::string> queries{};
-  std::string buffer;
-
-  std::ifstream file{file_name, std::ios::in};
-  MG_ASSERT(file.good(), "Cannot open queries file to read: {}", file_name);
-  while (file.good()) {
-    std::getline(file, buffer);
-    if (buffer.empty()) {
-      continue;
-    }
-    // Trim the trailing `;`
-    queries.push_back(buffer.substr(0, buffer.size() - 1));
-  }
-  return queries;
-}
-
-std::map<std::string, std::vector<std::string>> ReadBenchmarkQueries(const std::string benchmark_queries_files) {
-  auto benchmark_files = utils::Split(benchmark_queries_files, ",");
-  std::map<std::string, std::vector<std::string>> result;
-  for (const auto &benchmark_file : benchmark_files) {
-    const auto path = std::filesystem::path(benchmark_file);
-    result.emplace(path.stem().string(), ReadQueries(benchmark_file));
-  }
-  return result;
-}
-
-void RunV2() {
-  spdlog::critical("Running V2");
-  const auto run_start = std::chrono::high_resolution_clock::now();
-
-  const auto index_queries = ReadQueries(FLAGS_index_queries_file);
-  const auto init_queries = ReadQueries(FLAGS_init_queries_file);
-  const auto benchmarks = ReadBenchmarkQueries(FLAGS_benchmark_queries_files);
-
-  storage::Storage storage{
-      storage::Config{.durability{.storage_directory = FLAGS_data_directory,
-                                  .snapshot_wal_mode = storage::Config::Durability::SnapshotWalMode::DISABLED}}};
-
-  memgraph::query::InterpreterContext interpreter_context{
-      &storage,
-      {.query = {.allow_load_csv = false},
-       .execution_timeout_sec = 0,
-       .replication_replica_check_frequency = std::chrono::seconds(0),
-       .default_kafka_bootstrap_servers = "",
-       .default_pulsar_service_url = "",
-       .stream_transaction_conflict_retries = 0,
-       .stream_transaction_retry_interval = std::chrono::milliseconds(0)},
-      FLAGS_data_directory};
-
-  const auto init_start = std::chrono::high_resolution_clock::now();
-  RunInitQueries(interpreter_context, index_queries);
-  RunInitQueries(interpreter_context, init_queries);
-  const auto benchmark_start = std::chrono::high_resolution_clock::now();
-
-  spdlog::critical("Read: {}ms", std::chrono::duration_cast<std::chrono::milliseconds>(init_start - run_start).count());
-  spdlog::critical("Init: {}ms",
-                   std::chrono::duration_cast<std::chrono::milliseconds>(benchmark_start - init_start).count());
-
-  std::map<std::string, std::chrono::nanoseconds> benchmark_results;
-  for (const auto &[name, queries] : benchmarks) {
-    const auto current_start = std::chrono::high_resolution_clock::now();
-    RunBenchmarkQueries(interpreter_context, queries);
-    const auto current_stop = std::chrono::high_resolution_clock::now();
-    const auto elapsed = current_stop - current_start;
-    spdlog::critical("Benchmark {}: {}ms", name,
-                     std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count());
-    benchmark_results.emplace(name, elapsed);
-  }
-
-  const auto benchmark_end = std::chrono::high_resolution_clock::now();
-  spdlog::critical("Benchmark: {}ms",
-                   std::chrono::duration_cast<std::chrono::milliseconds>(benchmark_end - benchmark_start).count());
-
-  if (!FLAGS_export_json_results.empty()) {
-    nlohmann::json results;
-    PutResult(results, "init", benchmark_start - init_start);
-    nlohmann::json benchmark_results_json;
-    for (const auto &[name, duration] : benchmark_results) {
-      PutResult(benchmark_results_json, name, duration);
-    }
-    results["benchmarks"] = std::move(benchmark_results_json);
-    std::ofstream results_file{FLAGS_export_json_results};
-    results_file << results.dump();
-  }
-}
-
-void RunV3() {
-  spdlog::critical("Running V3");
-  const auto run_start = std::chrono::high_resolution_clock::now();
-  std::ifstream sm_file{FLAGS_split_file, std::ios::in};
-  MG_ASSERT(sm_file.good(), "Cannot open split file to read: {}", FLAGS_split_file);
-  auto sm = memgraph::coordinator::ShardMap::Parse(sm_file);
-
-  const auto init_queries = ReadQueries(FLAGS_init_queries_file);
-  const auto benchmarks = ReadBenchmarkQueries(FLAGS_benchmark_queries_files);
-
-  io::local_transport::LocalSystem ls;
-
-  auto unique_local_addr_query = io::Address::UniqueLocalAddress();
-  auto io = ls.Register(unique_local_addr_query);
-
-  memgraph::machine_manager::MachineConfig config{
-      .coordinator_addresses = std::vector<memgraph::io::Address>{unique_local_addr_query},
-      .is_storage = true,
-      .is_coordinator = true,
-      .listen_ip = unique_local_addr_query.last_known_ip,
-      .listen_port = unique_local_addr_query.last_known_port,
-      .shard_worker_threads = 2,
-  };
-
-  memgraph::coordinator::Coordinator coordinator{sm};
-
-  memgraph::machine_manager::MachineManager<memgraph::io::local_transport::LocalTransport> mm{io, config, coordinator};
-  std::jthread mm_thread([&mm] { mm.Run(); });
-
-  auto rr_factory = std::make_unique<memgraph::query::v2::LocalRequestRouterFactory>(io);
-
-  query::v2::InterpreterContext interpreter_context{(memgraph::storage::v3::Shard *)(nullptr),
-                                                    {.execution_timeout_sec = 0},
-                                                    "data",
-                                                    std::move(rr_factory),
-                                                    mm.CoordinatorAddress()};
-
-  // without this it fails sometimes because the CreateVertices request might reach the shard worker faster than the
-  // ShardToInitialize
-  std::this_thread::sleep_for(std::chrono::milliseconds(150));
-
-  const auto init_start = std::chrono::high_resolution_clock::now();
-  RunInitQueries(interpreter_context, init_queries);
-  const auto benchmark_start = std::chrono::high_resolution_clock::now();
-
-  spdlog::critical("Read: {}ms", std::chrono::duration_cast<std::chrono::milliseconds>(init_start - run_start).count());
-  spdlog::critical("Init: {}ms",
-                   std::chrono::duration_cast<std::chrono::milliseconds>(benchmark_start - init_start).count());
-
-  std::map<std::string, std::chrono::nanoseconds> benchmark_results;
-  for (const auto &[name, queries] : benchmarks) {
-    const auto current_start = std::chrono::high_resolution_clock::now();
-    RunBenchmarkQueries(interpreter_context, queries);
-    const auto current_stop = std::chrono::high_resolution_clock::now();
-    const auto elapsed = current_stop - current_start;
-    spdlog::critical("Benchmark {}: {}ms", name,
-                     std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count());
-    benchmark_results.emplace(name, elapsed);
-  }
-
-  const auto benchmark_end = std::chrono::high_resolution_clock::now();
-  spdlog::critical("Benchmark: {}ms",
-                   std::chrono::duration_cast<std::chrono::milliseconds>(benchmark_end - benchmark_start).count());
-
-  ls.ShutDown();
-  auto latency_histograms = nlohmann::json::parse(fmt::format("{}", io.ResponseLatencies()));
-  spdlog::warn(latency_histograms.dump(4));
-
-  if (!FLAGS_export_json_results.empty()) {
-    nlohmann::json results;
-    PutResult(results, "init", benchmark_start - init_start);
-    nlohmann::json benchmark_results_json;
-    for (const auto &[name, duration] : benchmark_results) {
-      PutResult(benchmark_results_json, name, duration);
-    }
-    results["benchmarks"] = std::move(benchmark_results_json);
-    results["latencies"] = std::move(latency_histograms);
-    std::ofstream results_file{FLAGS_export_json_results};
-    results_file << results.dump();
-  }
-}
-}  // namespace memgraph::tests::manual
-
-int main(int argc, char **argv) {
-  spdlog::set_level(spdlog::level::warn);
-  spdlog::cfg::load_env_levels();
-  gflags::ParseCommandLineFlags(&argc, &argv, true);
-  if (FLAGS_use_v3) {
-    memgraph::tests::manual::RunV3();
-  } else {
-    memgraph::tests::manual::RunV2();
-  }
-  return 0;
-}

tests/manual/query_performance_runner.py

@@ -1,116 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright 2023 Memgraph Ltd.
-#
-# Use of this software is governed by the Business Source License
-# included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-# License, and you may not use this file except in compliance with the Business Source License.
-#
-# As of the Change Date specified in that file, in accordance with
-# the Business Source License, use of this software will be governed
-# by the Apache License, Version 2.0, included in the file
-# licenses/APL.txt.
-
-import argparse
-import io
-import json
-import os
-import subprocess
-import tarfile
-import tempfile
-
-import requests
-
-SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
-PROJECT_DIR = os.path.normpath(os.path.join(SCRIPT_DIR, "..", ".."))
-BUILD_DIR = os.path.join(PROJECT_DIR, "build")
-BINARY_DIR = os.path.join(BUILD_DIR, "tests/manual")
-DEFAULT_BENCHMARK_DIR = os.path.join(BINARY_DIR, "query_performance_benchmark")
-DATA_URL = (
-    "https://s3.eu-west-1.amazonaws.com/deps.memgraph.io/dataset/query_performance/query_performance_benchmark.tar.gz"
-)
-
-parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-parser.add_argument(
-    "--binary",
-    type=str,
-    default=os.path.join(BINARY_DIR, "query_performance"),
-    help="Path to the binary to use for the benchmark.",
-)
-parser.add_argument(
-    "--data-dir",
-    type=str,
-    default=tempfile.TemporaryDirectory().name,
-    help="Path to directory that can be used as a data directory for ",
-)
-parser.add_argument(
-    "--summary-path",
-    type=str,
-    default=os.path.join(DEFAULT_BENCHMARK_DIR, "summary.json"),
-    help="Path to which file write the summary.",
-)
-
-parser.add_argument("--init-queries-file", type=str, default=os.path.join(DEFAULT_BENCHMARK_DIR, "dataset.cypher"))
-parser.add_argument("--index-queries-file", type=str, default=os.path.join(DEFAULT_BENCHMARK_DIR, "indices.cypher"))
-parser.add_argument("--split-file", type=str, default=os.path.join(DEFAULT_BENCHMARK_DIR, "split_file"))
-
-parser.add_argument(
-    "--benchmark-queries-files",
-    type=str,
-    default=",".join(
-        [os.path.join(DEFAULT_BENCHMARK_DIR, file_name) for file_name in ["expand.cypher", "match_files.cypher"]]
-    ),
-)
-
-args = parser.parse_args()
-
-v2_results_path = os.path.join(DEFAULT_BENCHMARK_DIR, "v2_results.json")
-v3_results_path = os.path.join(DEFAULT_BENCHMARK_DIR, "v3_results.json")
-
-
-if os.path.exists(DEFAULT_BENCHMARK_DIR):
-    print(f"Using cachced data from {DEFAULT_BENCHMARK_DIR}")
-else:
-    print(f"Downloading benchmark data to {DEFAULT_BENCHMARK_DIR}")
-    r = requests.get(DATA_URL)
-    assert r.ok, "Cannot download data"
-    file_like_object = io.BytesIO(r.content)
-    tar = tarfile.open(fileobj=file_like_object)
-    tar.extractall(os.path.dirname(DEFAULT_BENCHMARK_DIR))
-
-subprocess.run(
-    [
-        args.binary,
-        f"--split-file={args.split_file}",
-        f"--index-queries-file={args.index_queries_file}",
-        f"--init-queries-file={args.init_queries_file}",
-        f"--benchmark-queries-files={args.benchmark_queries_files}",
-        "--use-v3=false",
-        "--use-multi-frame=true",
-        f"--export-json-results={v2_results_path}",
-        f"--data-directory={args.data_dir}",
-    ]
-)
-
-subprocess.run(
-    [
-        args.binary,
-        f"--split-file={args.split_file}",
-        f"--index-queries-file={args.index_queries_file}",
-        f"--init-queries-file={args.init_queries_file}",
-        f"--benchmark-queries-files={args.benchmark_queries_files}",
-        "--use-v3=true",
-        "--use-multi-frame=true",
-        f"--export-json-results={v3_results_path}",
-        f"--data-directory={args.data_dir}",
-    ]
-)
-
-
-v2_results_file = open(v2_results_path)
-v2_results = json.load(v2_results_file)
-v3_results_file = open(v3_results_path)
-v3_results = json.load(v3_results_file)
-
-with open(args.summary_path, "w") as summary:
-    json.dump({"v2": v2_results, "v3": v3_results}, summary)

tests/mgbench/compare_results.py

@@ -14,6 +14,7 @@
 import argparse
 import json
 
+
 FIELDS = [
     {
         "name": "throughput",
@@ -84,32 +85,39 @@ def compare_results(results_from, results_to, fields):
                 if group == "__import__":
                     continue
                 for scenario, summary_to in scenarios.items():
-                    summary_from = recursive_get(results_from, dataset, variant, group, scenario, value={})
-                    if (
-                        len(summary_from) > 0
-                        and summary_to["count"] != summary_from["count"]
-                        or summary_to["num_workers"] != summary_from["num_workers"]
-                    ):
+                    summary_from = recursive_get(
+                        results_from, dataset, variant, group, scenario,
+                        value={})
+                    if len(summary_from) > 0 and \
+                            summary_to["count"] != summary_from["count"] or \
+                            summary_to["num_workers"] != \
+                            summary_from["num_workers"]:
                         raise Exception("Incompatible results!")
-                    testcode = "/".join([dataset, variant, group, scenario, "{:02d}".format(summary_to["num_workers"])])
+                    testcode = "/".join([dataset, variant, group, scenario,
+                                         "{:02d}".format(
+                                             summary_to["num_workers"])])
                     row = {}
                     performance_changed = False
                     for field in fields:
                         key = field["name"]
                         if key in summary_to:
-                            row[key] = compute_diff(summary_from.get(key, None), summary_to[key])
+                            row[key] = compute_diff(
+                                summary_from.get(key, None),
+                                summary_to[key])
                         elif key in summary_to["database"]:
                             row[key] = compute_diff(
-                                recursive_get(summary_from, "database", key, value=None), summary_to["database"][key]
-                            )
+                                recursive_get(summary_from, "database", key,
+                                              value=None),
+                                summary_to["database"][key])
                         else:
                             row[key] = compute_diff(
-                                recursive_get(summary_from, "metadata", key, "average", value=None),
-                                summary_to["metadata"][key]["average"],
-                            )
-                        if "diff" not in row[key] or (
-                            "diff_treshold" in field and abs(row[key]["diff"]) >= field["diff_treshold"]
-                        ):
+                                recursive_get(summary_from, "metadata", key,
+                                              "average", value=None),
+                                summary_to["metadata"][key]["average"])
+                        if "diff" not in row[key] or \
+                                ("diff_treshold" in field and
+                                 abs(row[key]["diff"]) >=
+                                 field["diff_treshold"]):
                             performance_changed = True
                     if performance_changed:
                         ret[testcode] = row
@@ -122,36 +130,29 @@ def generate_remarkup(fields, data):
         ret += "<table>\n"
         ret += "  <tr>\n"
         ret += "    <th>Testcode</th>\n"
-        ret += (
-            "\n".join(
-                map(
-                    lambda x: "    <th>{}</th>".format(x["name"].replace("_", " ").capitalize()),
-                    fields,
-                )
-            )
-            + "\n"
-        )
+        ret += "\n".join(map(lambda x: "    <th>{}</th>".format(
+            x["name"].replace("_", " ").capitalize()), fields)) + "\n"
         ret += "  </tr>\n"
         for testcode in sorted(data.keys()):
             ret += "  <tr>\n"
             ret += "    <td>{}</td>\n".format(testcode)
             for field in fields:
-                result = data[testcode].get(field["name"])
-                if result != None:
-                    value = result["value"] * field["scaling"]
-                    if "diff" in result:
-                        diff = result["diff"]
-                        arrow = "arrow-up" if diff >= 0 else "arrow-down"
-                        if not (field["positive_diff_better"] ^ (diff >= 0)):
-                            color = "green"
-                        else:
-                            color = "red"
-                        sign = "{{icon {} color={}}}".format(arrow, color)
-                        ret += '    <td bgcolor="{}">{:.3f}{} ({:+.2%})</td>\n'.format(
-                            color, value, field["unit"], diff
-                        )
+                result = data[testcode][field["name"]]
+                value = result["value"] * field["scaling"]
+                if "diff" in result:
+                    diff = result["diff"]
+                    arrow = "arrow-up" if diff >= 0 else "arrow-down"
+                    if not (field["positive_diff_better"] ^ (diff >= 0)):
+                        color = "green"
                     else:
-                        ret += '<td bgcolor="blue">{:.3f}{} //(new)// </td>\n'.format(value, field["unit"])
+                        color = "red"
+                    sign = "{{icon {} color={}}}".format(arrow, color)
+                    ret += "    <td>{:.3f}{} //({:+.2%})// {}</td>\n".format(
+                        value, field["unit"], diff, sign)
+                else:
+                    ret += "    <td>{:.3f}{} //(new)// " \
+                           "{{icon plus color=blue}}</td>\n".format(
+                               value, field["unit"])
             ret += "  </tr>\n"
         ret += "</table>\n"
     else:
@@ -160,14 +161,11 @@ def generate_remarkup(fields, data):
 
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Compare results of multiple benchmark runs.")
-    parser.add_argument(
-        "--compare",
-        action="append",
-        nargs=2,
-        metavar=("from", "to"),
-        help="compare results between `from` and `to` files",
-    )
+    parser = argparse.ArgumentParser(
+        description="Compare results of multiple benchmark runs.")
+    parser.add_argument("--compare", action="append", nargs=2,
+                        metavar=("from", "to"),
+                        help="compare results between `from` and `to` files")
     parser.add_argument("--output", default="", help="output file name")
     args = parser.parse_args()
 

tests/mgbench/dataset_creator.py

@@ -51,22 +51,10 @@ import helpers
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--number_of_identities",
-        type=int,
-        default=10,
-        help="Determines how many :Identity nodes will the dataset contain.",
-    )
-    parser.add_argument(
-        "--number_of_files", type=int, default=10, help="Determines how many :File nodes will the dataset contain."
-    )
-    parser.add_argument(
-        "--percentage_of_permissions",
-        type=float,
-        default=1.0,
-        help="Determines approximately what percentage of the all possible identity-permission-file connections will be created.",
-    )
-    parser.add_argument("--filename", default="dataset.cypher", help="The name of the output file.")
+    parser.add_argument("--number_of_identities", type=int, default=10)
+    parser.add_argument("--number_of_files", type=int, default=10)
+    parser.add_argument("--percentage_of_permissions", type=float, default=1.0)
+    parser.add_argument("--filename", default="dataset.cypher")
 
     args = parser.parse_args()
 

tests/mgbench/dataset_creator_unwind.py

@@ -1,151 +0,0 @@
-# Copyright 2022 Memgraph Ltd.
-#
-# Use of this software is governed by the Business Source License
-# included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-# License, and you may not use this file except in compliance with the Business Source License.
-#
-# As of the Change Date specified in that file, in accordance with
-# the Business Source License, use of this software will be governed
-# by the Apache License, Version 2.0, included in the file
-# licenses/APL.txt.
-
-import argparse
-import random
-
-import helpers
-
-# Explaination of datasets:
-#   - empty_only_index: contains index; contains no data
-#   - small: contains index; contains data (small dataset)
-#
-# Datamodel is as follow:
-#
-#                               ┌──────────────┐
-#                               │ Permission   │
-#         ┌────────────────┐    │  Schema:uuid │   ┌────────────┐
-#         │:IS_FOR_IDENTITY├────┤  Index:name  ├───┤:IS_FOR_FILE│
-#         └┬───────────────┘    └──────────────┘   └────────────┤
-#          │                                                    │
-#   ┌──────▼──────────────┐                                  ┌──▼────────────────┐
-#   │  Identity           │                                  │ File              │
-#   │   Schema:uuid       │                                  │  Schema:uuid      │
-#   │   Index:email       │                                  │  Index:name       │
-#   └─────────────────────┘                                  │  Index:platformId │
-#                                                            └───────────────────┘
-#
-#   - File: attributes: ["uuid", "name", "platformId"]
-#   - Permission: attributes: ["uuid", "name"]
-#   - Identity: attributes: ["uuid", "email"]
-#
-# Indexes:
-#   - File: [File(uuid), File(platformId), File(name)]
-#   - Permission: [Permission(uuid), Permission(name)]
-#   - Identity: [Identity(uuid), Identity(email)]
-#
-# Edges:
-#   - (:Permission)-[:IS_FOR_FILE]->(:File)
-#   - (:Permission)-[:IS_FOR_IDENTITYR]->(:Identity)
-#
-# AccessControl specific: uuid is the schema
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--number_of_identities",
-        type=int,
-        default=10,
-        help="Determines how many :Identity nodes will the dataset contain.",
-    )
-    parser.add_argument(
-        "--number_of_files", type=int, default=10, help="Determines how many :File nodes will the dataset contain."
-    )
-    parser.add_argument(
-        "--percentage_of_permissions",
-        type=float,
-        default=1.0,
-        help="Determines approximately what percentage of the all possible identity-permission-file connections will be created.",
-    )
-    parser.add_argument("--filename", default="dataset.cypher", help="The name of the output file.")
-
-    args = parser.parse_args()
-
-    number_of_identities = args.number_of_identities
-    number_of_files = args.number_of_files
-    percentage_of_permissions = args.percentage_of_permissions
-    filename = args.filename
-
-    assert number_of_identities >= 0
-    assert number_of_files >= 0
-    assert percentage_of_permissions > 0.0 and percentage_of_permissions <= 1.0
-    assert filename != ""
-
-    with open(filename, "w") as f:
-        f.write("MATCH (n) DETACH DELETE n;\n")
-
-        # Create the indexes
-        f.write("CREATE INDEX ON :File;\n")
-        f.write("CREATE INDEX ON :Permission;\n")
-        f.write("CREATE INDEX ON :Identity;\n")
-        f.write("CREATE INDEX ON :File(platformId);\n")
-        f.write("CREATE INDEX ON :File(name);\n")
-        f.write("CREATE INDEX ON :Permission(name);\n")
-        f.write("CREATE INDEX ON :Identity(email);\n")
-
-        # Create extra index: in distributed, this will be the schema
-        f.write("CREATE INDEX ON :File(uuid);\n")
-        f.write("CREATE INDEX ON :Permission(uuid);\n")
-        f.write("CREATE INDEX ON :Identity(uuid);\n")
-
-        uuid = 1
-
-        # Create the nodes File
-        f.write("UNWIND [")
-        for index in range(0, number_of_files):
-            if index != 0:
-                f.write(",")
-            f.write(f' {{uuid: {uuid}, platformId: "platform_id", name: "name_file_{uuid}"}}')
-            uuid += 1
-        f.write("] AS props CREATE (:File {uuid: props.uuid, platformId: props.platformId, name: props.name});\n")
-
-        identities = []
-        f.write("UNWIND [")
-        # Create the nodes Identity
-        for index in range(0, number_of_identities):
-            if index != 0:
-                f.write(",")
-            f.write(f' {{uuid: {uuid}, name: "mail_{uuid}@something.com"}}')
-            uuid += 1
-        f.write("] AS props CREATE (:Identity {uuid: props.uuid, name: props.name});\n")
-
-        f.write("UNWIND [")
-        created = 0
-        for outer_index in range(0, number_of_files):
-            for inner_index in range(0, number_of_identities):
-
-                file_uuid = outer_index + 1
-                identity_uuid = number_of_files + inner_index + 1
-
-                if random.random() <= percentage_of_permissions:
-
-                    if created > 0:
-                        f.write(",")
-
-                    f.write(
-                        f' {{permUuid: {uuid}, permName: "name_permission_{uuid}", fileUuid: {file_uuid}, identityUuid: {identity_uuid}}}'
-                    )
-                    created += 1
-                    uuid += 1
-
-                    if created == 5000:
-                        f.write(
-                            "] AS props MATCH (file:File {uuid:props.fileUuid}), (identity:Identity {uuid: props.identityUuid}) CREATE (permission:Permission {uuid: props.permUuid, name: props.permName}) CREATE (permission)-[: IS_FOR_FILE]->(file) CREATE (permission)-[: IS_FOR_IDENTITY]->(identity);\nUNWIND ["
-                        )
-                        created = 0
-        f.write(
-            "] AS props MATCH (file:File {uuid:props.fileUuid}), (identity:Identity {uuid: props.identityUuid}) CREATE (permission:Permission {uuid: props.permUuid, name: props.permName}) CREATE (permission)-[: IS_FOR_FILE]->(file) CREATE (permission)-[: IS_FOR_IDENTITY]->(identity);\n"
-        )
-
-
-if __name__ == "__main__":
-    main()

tests/mgbench/datasets.py

@@ -353,7 +353,7 @@ class AccessControl(Dataset):
 
     def benchmark__create__vertex(self):
         self.next_value_idx += 1
-        query = ("CREATE (:File {uuid: $uuid})", {"uuid": self.next_value_idx})
+        query = (f"CREATE (:File {{uuid: {self.next_value_idx}}});", {})
         return query
 
     def benchmark__create__edges(self):
@@ -379,24 +379,6 @@ class AccessControl(Dataset):
         return query
 
     def benchmark__match__match_all_vertices_with_edges(self):
+        self.next_value_idx += 1
         query = ("MATCH (permission:Permission)-[e:IS_FOR_FILE]->(file:File) RETURN *", {})
         return query
-
-    def benchmark__match__match_users_with_permission_for_files(self):
-        file_uuid_1 = self._get_random_uuid("File")
-        file_uuid_2 = self._get_random_uuid("File")
-        min_file_uuid = min(file_uuid_1, file_uuid_2)
-        max_file_uuid = max(file_uuid_1, file_uuid_2)
-        query = (
-            "MATCH (f:File)<-[ff:IS_FOR_FILE]-(p:Permission)-[fi:IS_FOR_IDENTITY]->(i:Identity) WHERE f.uuid >= $min_file_uuid  AND f.uuid <= $max_file_uuid RETURN *",
-            {"min_file_uuid": min_file_uuid, "max_file_uuid": max_file_uuid},
-        )
-        return query
-
-    def benchmark__match__match_users_with_permission_for_specific_file(self):
-        file_uuid = self._get_random_uuid("File")
-        query = (
-            "MATCH (f:File {uuid: $file_uuid})<-[ff:IS_FOR_FILE]-(p:Permission)-[fi:IS_FOR_IDENTITY]->(i:Identity) RETURN *",
-            {"file_uuid": file_uuid},
-        )
-        return query

tests/mgbench/runners.py

@@ -68,15 +68,6 @@ class Memgraph:
         self._cleanup()
         atexit.unregister(self._cleanup)
 
-    # Returns None if string_value is not true or false, casing doesn't matter
-    def _get_bool_value(self, string_value):
-        lower_string_value = string_value.lower()
-        if lower_string_value == "true":
-            return True
-        if lower_string_value == "false":
-            return False
-        return None
-
     def _get_args(self, **kwargs):
         data_directory = os.path.join(self._directory.name, "memgraph")
         if self._memgraph_version >= (0, 50, 0):
@@ -92,13 +83,7 @@ class Memgraph:
             args_list = self._extra_args.split(" ")
             assert len(args_list) % 2 == 0
             for i in range(0, len(args_list), 2):
-                key = args_list[i]
-                value = args_list[i + 1]
-                maybe_bool_value = self._get_bool_value(value)
-                if maybe_bool_value is not None:
-                    kwargs[key] = maybe_bool_value
-                else:
-                    kwargs[key] = value
+                kwargs[args_list[i]] = args_list[i + 1]
 
         return _convert_args_to_flags(self._memgraph_binary, **kwargs)
 

tests/mgbench/splitfiles/accesscontrol_large.shard_configuration

@@ -1,12 +1,8 @@
-8
+4
 uuid
 email
 name
 platformId
-permUuid
-permName
-fileUuid
-identityUuid
 2
 IS_FOR_IDENTITY
 IS_FOR_FILE

tests/mgbench/splitfiles/accesscontrol_medium.shard_configuration

@@ -1,12 +1,8 @@
-8
+4
 uuid
 email
 name
 platformId
-permUuid
-permName
-fileUuid
-identityUuid
 2
 IS_FOR_IDENTITY
 IS_FOR_FILE

tests/mgbench/splitfiles/accesscontrol_small.shard_configuration

@@ -1,12 +1,8 @@
-8
+4
 uuid
 email
 name
 platformId
-permUuid
-permName
-fileUuid
-identityUuid
 2
 IS_FOR_IDENTITY
 IS_FOR_FILE

tests/simulation/CMakeLists.txt

@@ -17,7 +17,7 @@ function(add_simulation_test test_cpp)
   # requires unique logical target names
   set_target_properties(${target_name} PROPERTIES OUTPUT_NAME ${exec_name})
 
-  target_link_libraries(${target_name} mg-communication mg-utils mg-io mg-io-simulator mg-coordinator mg-query-v2 mg-storage-v3)
+  target_link_libraries(${target_name} mg-storage-v3 mg-communication mg-utils mg-io mg-io-simulator mg-coordinator mg-query-v2)
   target_link_libraries(${target_name} Boost::headers)
   target_link_libraries(${target_name} gtest gtest_main gmock rapidcheck rapidcheck_gtest)
 
@@ -32,5 +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(cluster_property_test_cypher_queries.cpp)
 add_simulation_test(request_router.cpp)

tests/simulation/basic_request.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -55,7 +55,7 @@ void run_server(Io<SimulatorTransport> io) {
     highest_seen = std::max(highest_seen, req.proposal);
     auto srv_res = CounterResponse{highest_seen};
 
-    io.Send(request_envelope.from_address, request_envelope.request_id, std::move(srv_res));
+    io.Send(request_envelope.from_address, request_envelope.request_id, srv_res);
   }
 }
 
@@ -76,7 +76,7 @@ std::pair<SimulatorStats, LatencyHistogramSummaries> RunWorkload(SimulatorConfig
     CounterRequest cli_req;
     cli_req.proposal = i;
     spdlog::info("[CLIENT] calling Request");
-    auto res_f = cli_io.Request<CounterResponse, CounterRequest>(srv_addr, std::move(cli_req));
+    auto res_f = cli_io.Request<CounterRequest, CounterResponse>(srv_addr, cli_req);
     spdlog::info("[CLIENT] calling Wait");
     auto res_rez = std::move(res_f).Wait();
     spdlog::info("[CLIENT] Wait returned");

tests/simulation/cluster_property_test_cypher_queries.cpp

@@ -1,64 +0,0 @@
-// Copyright 2023 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-// This test serves as an example of a property-based model test.
-// It generates a cluster configuration and a set of operations to
-// apply against both the real system and a greatly simplified model.
-
-#include <chrono>
-
-#include <gtest/gtest.h>
-#include <rapidcheck.h>
-#include <rapidcheck/gtest.h>
-#include <spdlog/cfg/env.h>
-
-#include "generated_operations.hpp"
-#include "io/simulator/simulator_config.hpp"
-#include "io/time.hpp"
-#include "storage/v3/shard_manager.hpp"
-#include "test_cluster.hpp"
-
-namespace memgraph::tests::simulation {
-
-using io::Duration;
-using io::Time;
-using io::simulator::SimulatorConfig;
-using storage::v3::kMaximumCronInterval;
-
-RC_GTEST_PROP(RandomClusterConfig, HappyPath, (ClusterConfig cluster_config, NonEmptyOpVec ops, uint64_t rng_seed)) {
-  spdlog::cfg::load_env_levels();
-
-  SimulatorConfig sim_config{
-      .drop_percent = 0,
-      .perform_timeouts = false,
-      .scramble_messages = true,
-      .rng_seed = rng_seed,
-      .start_time = Time::min(),
-      .abort_time = Time::max(),
-  };
-
-  std::vector<std::string> queries = {"CREATE (n:test_label{property_1: 0, property_2: 0});", "MATCH (n) RETURN n;"};
-
-  auto [sim_stats_1, latency_stats_1] = RunClusterSimulationWithQueries(sim_config, cluster_config, queries);
-  auto [sim_stats_2, latency_stats_2] = RunClusterSimulationWithQueries(sim_config, cluster_config, queries);
-
-  if (latency_stats_1 != latency_stats_2) {
-    spdlog::error("simulator stats diverged across runs");
-    spdlog::error("run 1 simulator stats: {}", sim_stats_1);
-    spdlog::error("run 2 simulator stats: {}", sim_stats_2);
-    spdlog::error("run 1 latency:\n{}", latency_stats_1.SummaryTable());
-    spdlog::error("run 2 latency:\n{}", latency_stats_2.SummaryTable());
-    RC_ASSERT(latency_stats_1 == latency_stats_2);
-    RC_ASSERT(sim_stats_1 == sim_stats_2);
-  }
-}
-
-}  // namespace memgraph::tests::simulation

tests/simulation/simulation_interpreter.hpp

@@ -1,93 +0,0 @@
-// Copyright 2023 Memgraph Ltd.
-//
-// Use of this software is governed by the Business Source License
-// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
-// License, and you may not use this file except in compliance with the Business Source License.
-//
-// As of the Change Date specified in that file, in accordance with
-// the Business Source License, use of this software will be governed
-// by the Apache License, Version 2.0, included in the file
-// licenses/APL.txt.
-
-#include "io/simulator/simulator_handle.hpp"
-#include "machine_manager/machine_config.hpp"
-#include "machine_manager/machine_manager.hpp"
-#include "query/v2/config.hpp"
-#include "query/v2/discard_value_stream.hpp"
-#include "query/v2/frontend/ast/ast.hpp"
-#include "query/v2/interpreter.hpp"
-#include "query/v2/request_router.hpp"
-
-#include <string>
-#include <vector>
-
-// TODO(gvolfing)
-// -How to set up the entire raft cluster with the QE. Also provide abrstraction for that.
-// -Pass an argument to the setup to determine, how many times the retry of a query should happen.
-
-namespace memgraph::io::simulator {
-
-class SimulatedInterpreter {
-  using ResultStream = query::v2::DiscardValueResultStream;
-
- public:
-  explicit SimulatedInterpreter(std::unique_ptr<query::v2::InterpreterContext> interpreter_context)
-      : interpreter_context_(std::move(interpreter_context)) {
-    interpreter_ = std::make_unique<memgraph::query::v2::Interpreter>(interpreter_context_.get());
-  }
-
-  SimulatedInterpreter(const SimulatedInterpreter &) = delete;
-  SimulatedInterpreter &operator=(const SimulatedInterpreter &) = delete;
-  SimulatedInterpreter(SimulatedInterpreter &&) = delete;
-  SimulatedInterpreter &operator=(SimulatedInterpreter &&) = delete;
-  ~SimulatedInterpreter() = default;
-
-  void InstallSimulatorTicker(Simulator &simulator) {
-    interpreter_->InstallSimulatorTicker(simulator.GetSimulatorTickClosure());
-  }
-
-  std::vector<ResultStream> RunQueries(const std::vector<std::string> &queries) {
-    std::vector<ResultStream> results;
-    results.reserve(queries.size());
-
-    for (const auto &query : queries) {
-      results.emplace_back(RunQuery(query));
-    }
-    return results;
-  }
-
- private:
-  ResultStream RunQuery(const std::string &query) {
-    ResultStream stream;
-
-    std::map<std::string, memgraph::storage::v3::PropertyValue> params;
-    const std::string *username = nullptr;
-
-    interpreter_->Prepare(query, params, username);
-    interpreter_->PullAll(&stream);
-
-    return stream;
-  }
-
-  std::unique_ptr<query::v2::InterpreterContext> interpreter_context_;
-  std::unique_ptr<query::v2::Interpreter> interpreter_;
-};
-
-SimulatedInterpreter SetUpInterpreter(Address coordinator_address, Simulator &simulator) {
-  auto rr_factory = std::make_unique<memgraph::query::v2::SimulatedRequestRouterFactory>(simulator);
-
-  auto interpreter_context = std::make_unique<memgraph::query::v2::InterpreterContext>(
-      nullptr,
-      memgraph::query::v2::InterpreterConfig{.query = {.allow_load_csv = true},
-                                             .execution_timeout_sec = 600,
-                                             .replication_replica_check_frequency = std::chrono::seconds(1),
-                                             .default_kafka_bootstrap_servers = "",
-                                             .default_pulsar_service_url = "",
-                                             .stream_transaction_conflict_retries = 30,
-                                             .stream_transaction_retry_interval = std::chrono::milliseconds(500)},
-      std::filesystem::path("mg_data"), std::move(rr_factory), coordinator_address);
-
-  return SimulatedInterpreter(std::move(interpreter_context));
-}
-
-}  // namespace memgraph::io::simulator

tests/simulation/test_cluster.hpp

@@ -36,8 +36,6 @@
 #include "utils/print_helpers.hpp"
 #include "utils/variant_helpers.hpp"
 
-#include "simulation_interpreter.hpp"
-
 namespace memgraph::tests::simulation {
 
 using coordinator::Coordinator;
@@ -281,65 +279,4 @@ std::pair<SimulatorStats, LatencyHistogramSummaries> RunClusterSimulation(const
   return std::make_pair(stats, histo);
 }
 
-std::pair<SimulatorStats, LatencyHistogramSummaries> RunClusterSimulationWithQueries(
-    const SimulatorConfig &sim_config, const ClusterConfig &cluster_config, const std::vector<std::string> &queries) {
-  spdlog::info("========================== NEW SIMULATION ==========================");
-
-  auto simulator = Simulator(sim_config);
-
-  auto machine_1_addr = Address::TestAddress(1);
-  auto cli_addr = Address::TestAddress(2);
-  auto cli_addr_2 = Address::TestAddress(3);
-
-  Io<SimulatorTransport> cli_io = simulator.Register(cli_addr);
-  Io<SimulatorTransport> cli_io_2 = simulator.Register(cli_addr_2);
-
-  auto coordinator_addresses = std::vector{
-      machine_1_addr,
-  };
-
-  ShardMap initialization_sm = TestShardMap(cluster_config.shards - 1, cluster_config.replication_factor);
-
-  auto mm_1 = MkMm(simulator, coordinator_addresses, machine_1_addr, initialization_sm);
-  Address coordinator_address = mm_1.CoordinatorAddress();
-
-  auto mm_thread_1 = std::jthread(RunMachine, std::move(mm_1));
-  simulator.IncrementServerCountAndWaitForQuiescentState(machine_1_addr);
-
-  auto detach_on_error = DetachIfDropped{.handle = mm_thread_1};
-
-  // TODO(tyler) clarify addresses of coordinator etc... as it's a mess
-
-  CoordinatorClient<SimulatorTransport> coordinator_client(cli_io, coordinator_address, {coordinator_address});
-  WaitForShardsToInitialize(coordinator_client);
-
-  auto simulated_interpreter = io::simulator::SetUpInterpreter(coordinator_address, simulator);
-  simulated_interpreter.InstallSimulatorTicker(simulator);
-
-  auto query_results = simulated_interpreter.RunQueries(queries);
-
-  // We have now completed our workload without failing any assertions, so we can
-  // disable detaching the worker thread, which will cause the mm_thread_1 jthread
-  // to be joined when this function returns.
-  detach_on_error.detach = false;
-
-  simulator.ShutDown();
-
-  mm_thread_1.join();
-
-  SimulatorStats stats = simulator.Stats();
-
-  spdlog::info("total messages:     {}", stats.total_messages);
-  spdlog::info("dropped messages:   {}", stats.dropped_messages);
-  spdlog::info("timed out requests: {}", stats.timed_out_requests);
-  spdlog::info("total requests:     {}", stats.total_requests);
-  spdlog::info("total responses:    {}", stats.total_responses);
-  spdlog::info("simulator ticks:    {}", stats.simulator_ticks);
-
-  auto histo = cli_io_2.ResponseLatencies();
-
-  spdlog::info("========================== SUCCESS :) ==========================");
-  return std::make_pair(stats, histo);
-}
-
 }  // namespace memgraph::tests::simulation

tests/simulation/trial_query_storage/query_storage_test.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -44,7 +44,7 @@ void run_server(Io<SimulatorTransport> io) {
     for (auto index = start_index; index < start_index + req.count; ++index) {
       response.vertices.push_back({std::string("Vertex_") + std::to_string(index)});
     }
-    io.Send(request_envelope.from_address, request_envelope.request_id, std::move(response));
+    io.Send(request_envelope.from_address, request_envelope.request_id, response);
   }
 }
 
@@ -78,7 +78,7 @@ int main() {
 
   auto req = ScanVerticesRequest{2, std::nullopt};
 
-  auto res_f = cli_io.Request<VerticesResponse, ScanVerticesRequest>(srv_addr, std::move(req));
+  auto res_f = cli_io.Request<ScanVerticesRequest, VerticesResponse>(srv_addr, req);
   auto res_rez = std::move(res_f).Wait();
   simulator.ShutDown();
   return 0;

tests/unit/local_transport.cpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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
@@ -48,7 +48,7 @@ void RunServer(Io<LocalTransport> io) {
     highest_seen = std::max(highest_seen, req.proposal);
     auto srv_res = CounterResponse{highest_seen};
 
-    io.Send(request_envelope.from_address, request_envelope.request_id, std::move(srv_res));
+    io.Send(request_envelope.from_address, request_envelope.request_id, srv_res);
   }
 }
 
@@ -70,7 +70,7 @@ TEST(LocalTransport, BasicRequest) {
     auto value = 1;  // i;
     cli_req.proposal = value;
     spdlog::info("[CLIENT] sending request");
-    auto res_f = cli_io.Request<CounterResponse, CounterRequest>(srv_addr, std::move(cli_req));
+    auto res_f = cli_io.Request<CounterRequest, CounterResponse>(srv_addr, cli_req);
     spdlog::info("[CLIENT] waiting on future");
 
     auto res_rez = std::move(res_f).Wait();

tests/unit/mock_helpers.hpp

@@ -41,9 +41,7 @@ class MockedRequestRouter : public RequestRouterInterface {
   MOCK_METHOD(std::optional<storage::v3::EdgeTypeId>, MaybeNameToEdgeType, (const std::string &), (const));
   MOCK_METHOD(std::optional<storage::v3::LabelId>, MaybeNameToLabel, (const std::string &), (const));
   MOCK_METHOD(bool, IsPrimaryLabel, (storage::v3::LabelId), (const));
-  MOCK_METHOD(bool, IsPrimaryProperty, (storage::v3::LabelId, storage::v3::PropertyId), (const));
-  MOCK_METHOD((std::optional<std::pair<uint64_t, uint64_t>>), AllocateInitialEdgeIds, (io::Address));
-  MOCK_METHOD(void, InstallSimulatorTicker, (std::function<bool()>));
+  MOCK_METHOD(bool, IsPrimaryKey, (storage::v3::LabelId, storage::v3::PropertyId), (const));
   MOCK_METHOD(const std::vector<coordinator::SchemaProperty> &, GetSchemaForLabel, (storage::v3::LabelId), (const));
 };
 
@@ -61,7 +59,7 @@ class MockedLogicalOperator : public plan::LogicalOperator {
 class MockedCursor : public plan::Cursor {
  public:
   MOCK_METHOD(bool, Pull, (Frame &, expr::ExecutionContext &));
-  MOCK_METHOD(bool, PullMultiple, (MultiFrame &, expr::ExecutionContext &));
+  MOCK_METHOD(void, PullMultiple, (MultiFrame &, expr::ExecutionContext &));
   MOCK_METHOD(void, Reset, ());
   MOCK_METHOD(void, Shutdown, ());
 };

tests/unit/query_v2_common.hpp

@@ -1,4 +1,4 @@
-// Copyright 2023 Memgraph Ltd.
+// 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

tests/unit/query_v2_create_expand_multiframe.cpp

@@ -31,8 +31,8 @@ MultiFrame CreateMultiFrame(const size_t max_pos, const Symbol &src, const Symbo
   auto frames_populator = multi_frame.GetInvalidFramesPopulator();
   size_t i = 0;
   for (auto &frame : frames_populator) {
-    auto &src_acc = frame.At(src);
-    auto &dst_acc = frame.At(dst);
+    auto &src_acc = frame.at(src);
+    auto &dst_acc = frame.at(dst);
     auto v1 = msgs::Vertex{.id = {{msgs::LabelId::FromUint(1)}, {msgs::Value(static_cast<int64_t>(i++))}}};
     auto v2 = msgs::Vertex{.id = {{msgs::LabelId::FromUint(1)}, {msgs::Value(static_cast<int64_t>(i++))}}};
     std::map<msgs::PropertyId, msgs::Value> mp;

tests/unit/query_v2_create_node_multiframe.cpp

@@ -58,7 +58,7 @@ TEST(CreateNodeTest, CreateNodeCursor) {
   MockedRequestRouter router;
   EXPECT_CALL(router, CreateVertices(_)).Times(1).WillOnce(Return(std::vector<msgs::CreateVerticesResponse>{}));
   EXPECT_CALL(router, IsPrimaryLabel(_)).WillRepeatedly(Return(true));
-  EXPECT_CALL(router, IsPrimaryProperty(_, _)).WillRepeatedly(Return(true));
+  EXPECT_CALL(router, IsPrimaryKey(_, _)).WillRepeatedly(Return(true));
   auto context = MakeContext(ast, symbol_table, &router, &id_alloc);
   auto multi_frame = CreateMultiFrame(context.symbol_table.max_position());
   cursor->PullMultiple(multi_frame, context);

tests/unit/query_v2_expression_evaluator.cpp

@@ -123,13 +123,8 @@ class MockedRequestRouter : public RequestRouterInterface {
 
   bool IsPrimaryLabel(LabelId label) const override { return true; }
 
-  bool IsPrimaryProperty(LabelId primary_label, PropertyId property) const override { return true; }
+  bool IsPrimaryKey(LabelId primary_label, PropertyId property) const override { return true; }
 
-  std::optional<std::pair<uint64_t, uint64_t>> AllocateInitialEdgeIds(io::Address coordinator_address) override {
-    return {};
-  }
-
-  void InstallSimulatorTicker(std::function<bool()> tick_simulator) override {}
   const std::vector<coordinator::SchemaProperty> &GetSchemaForLabel(storage::v3::LabelId /*label*/) const override {
     static std::vector<coordinator::SchemaProperty> schema;
     return schema;

tests/unit/query_v2_plan.cpp

@@ -86,7 +86,7 @@ class TestPlanner : public ::testing::Test {};
 
 using PlannerTypes = ::testing::Types<Planner>;
 
-TYPED_TEST_SUITE(TestPlanner, PlannerTypes);
+TYPED_TEST_CASE(TestPlanner, PlannerTypes);
 
 TYPED_TEST(TestPlanner, MatchFilterPropIsNotNull) {
   const char *prim_label_name = "prim_label_one";

tests/unit/storage_v3_schema.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 Memgraph Ltd.
+// Copyright 2023 Memgraph Ltd.
 //
 // Use of this software is governed by the Business Source License
 // included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source
@@ -60,18 +60,22 @@ TEST_F(SchemaTest, TestSchemaCreate) {
     EXPECT_TRUE(schemas.CreateSchema(label2, {schema_prop_string, schema_prop_int}));
     const auto current_schemas = schemas.ListSchemas();
     EXPECT_EQ(current_schemas.size(), 2);
-    EXPECT_THAT(current_schemas,
-                UnorderedElementsAre(Pair(label1, std::vector<SchemaProperty>{schema_prop_string}),
-                                     Pair(label2, std::vector<SchemaProperty>{schema_prop_string, schema_prop_int})));
+    EXPECT_THAT(
+        current_schemas,
+        UnorderedElementsAre(
+            Schema{.label = label1, .properties = std::vector<SchemaProperty>{schema_prop_string}},
+            Schema{.label = label2, .properties = std::vector<SchemaProperty>{schema_prop_string, schema_prop_int}}));
   }
   {
     // Assert after unsuccessful creation, number oif schemas remains the same
     EXPECT_FALSE(schemas.CreateSchema(label2, {schema_prop_int}));
     const auto current_schemas = schemas.ListSchemas();
     EXPECT_EQ(current_schemas.size(), 2);
-    EXPECT_THAT(current_schemas,
-                UnorderedElementsAre(Pair(label1, std::vector<SchemaProperty>{schema_prop_string}),
-                                     Pair(label2, std::vector<SchemaProperty>{schema_prop_string, schema_prop_int})));
+    EXPECT_THAT(
+        current_schemas,
+        UnorderedElementsAre(
+            Schema{.label = label1, .properties = std::vector<SchemaProperty>{schema_prop_string}},
+            Schema{.label = label2, .properties = std::vector<SchemaProperty>{schema_prop_string, schema_prop_int}}));
   }
 }
 
@@ -89,27 +93,29 @@ TEST_F(SchemaTest, TestSchemaList) {
   {
     const auto current_schemas = schemas.ListSchemas();
     EXPECT_EQ(current_schemas.size(), 2);
-    EXPECT_THAT(current_schemas,
-                UnorderedElementsAre(
-                    Pair(label1, std::vector<SchemaProperty>{schema_prop_string}),
-                    Pair(label2, std::vector<SchemaProperty>{{NameToProperty("prop1"), SchemaType::STRING},
+    EXPECT_THAT(
+        current_schemas,
+        UnorderedElementsAre(
+            Schema{.label = label1, .properties = std::vector<SchemaProperty>{schema_prop_string}},
+            Schema{.label = label2,
+                   .properties = std::vector<SchemaProperty>{{NameToProperty("prop}"), SchemaType::STRING},
                                                              {NameToProperty("prop2"), SchemaType::INT},
                                                              {NameToProperty("prop3"), SchemaType::BOOL},
                                                              {NameToProperty("prop4"), SchemaType::DATE},
                                                              {NameToProperty("prop5"), SchemaType::LOCALDATETIME},
                                                              {NameToProperty("prop6"), SchemaType::DURATION},
-                                                             {NameToProperty("prop7"), SchemaType::LOCALTIME}})));
+                                                             {NameToProperty("prop7"), SchemaType::LOCALTIME}}}));
   }
   {
     const auto *const schema1 = schemas.GetSchema(label1);
     ASSERT_NE(schema1, nullptr);
-    EXPECT_EQ(*schema1, (Schemas::Schema{label1, std::vector<SchemaProperty>{schema_prop_string}}));
+    EXPECT_EQ(*schema1, (Schema{.label = label1, .properties = std::vector<SchemaProperty>{schema_prop_string}}));
   }
   {
     const auto *const schema2 = schemas.GetSchema(label2);
     ASSERT_NE(schema2, nullptr);
-    EXPECT_EQ(schema2->first, label2);
-    EXPECT_EQ(schema2->second.size(), 7);
+    EXPECT_EQ(schema2->label, label2);
+    EXPECT_EQ(schema2->properties.size(), 7);
   }
 }
 
@@ -132,7 +138,8 @@ TEST_F(SchemaTest, TestSchemaDrop) {
     const auto current_schemas = schemas.ListSchemas();
     EXPECT_EQ(current_schemas.size(), 1);
     EXPECT_THAT(current_schemas,
-                UnorderedElementsAre(Pair(label2, std::vector<SchemaProperty>{schema_prop_string, schema_prop_int})));
+                UnorderedElementsAre(Schema{
+                    .label = label2, .properties = std::vector<SchemaProperty>{schema_prop_string, schema_prop_int}}));
   }
 
   {
@@ -141,7 +148,8 @@ TEST_F(SchemaTest, TestSchemaDrop) {
     const auto current_schemas = schemas.ListSchemas();
     EXPECT_EQ(current_schemas.size(), 1);
     EXPECT_THAT(current_schemas,
-                UnorderedElementsAre(Pair(label2, std::vector<SchemaProperty>{schema_prop_string, schema_prop_int})));
+                UnorderedElementsAre(Schema{
+                    .label = label2, .properties = std::vector<SchemaProperty>{schema_prop_string, schema_prop_int}}));
   }
 
   EXPECT_TRUE(schemas.DropSchema(label2));